1 /*
2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "DrawingNativeCanvasCommon.h"
19 #include "drawing_bitmap.h"
20 #include "drawing_brush.h"
21 #include "drawing_canvas.h"
22 #include "drawing_color.h"
23 #include "drawing_color_filter.h"
24 #include "drawing_filter.h"
25 #include "drawing_font.h"
26 #include "drawing_image.h"
27 #include "drawing_mask_filter.h"
28 #include "drawing_matrix.h"
29 #include "drawing_memory_stream.h"
30 #include "drawing_path.h"
31 #include "drawing_pen.h"
32 #include "drawing_point.h"
33 #include "drawing_rect.h"
34 #include "drawing_region.h"
35 #include "drawing_round_rect.h"
36 #include "drawing_sampling_options.h"
37 #include "drawing_shader_effect.h"
38 #include "drawing_text_blob.h"
39 #include "drawing_typeface.h"
40
41 using namespace testing;
42 using namespace testing::ext;
43
44 namespace OHOS {
45 namespace Rosen {
46 namespace Drawing {
47
48 /*
49 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0100
50 * @tc.name: testCanvasDestroyNormal
51 * @tc.desc: test for testCanvasDestroyNormal.
52 * @tc.size : SmallTest
53 * @tc.type : Function
54 * @tc.level : Level 0
55 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDestroyNormal, TestSize.Level0)56 HWTEST_F(DrawingNativeCanvasTest, testCanvasDestroyNormal, TestSize.Level0) {
57 // step 1
58 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
59 EXPECT_NE(canvas, nullptr);
60 // step 2
61 OH_Drawing_CanvasDestroy(canvas);
62 }
63
64 /*
65 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0101
66 * @tc.name: testCanvasDestroyNull
67 * @tc.desc: test for testCanvasDestroyNull.
68 * @tc.size : SmallTest
69 * @tc.type : Function
70 * @tc.level : Level 3
71 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDestroyNull, TestSize.Level3)72 HWTEST_F(DrawingNativeCanvasTest, testCanvasDestroyNull, TestSize.Level3) {
73 // step 1
74 OH_Drawing_CanvasDestroy(nullptr);
75 }
76
77 /*
78 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0200
79 * @tc.name: testCanvasBindNormal
80 * @tc.desc: test for testCanvasBindNormal.
81 * @tc.size : SmallTest
82 * @tc.type : Function
83 * @tc.level : Level 0
84 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasBindNormal, TestSize.Level0)85 HWTEST_F(DrawingNativeCanvasTest, testCanvasBindNormal, TestSize.Level0) {
86 // step 1
87 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
88 EXPECT_NE(canvas, nullptr);
89
90 // step 2
91 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
92 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
93 constexpr uint32_t width = 200;
94 constexpr uint32_t height = 200;
95 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
96 OH_Drawing_CanvasBind(canvas, bitmap);
97
98 // step 3
99 OH_Drawing_BitmapDestroy(bitmap);
100 OH_Drawing_CanvasDestroy(canvas);
101 }
102
103 /*
104 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0201
105 * @tc.name: testCanvasBindNull
106 * @tc.desc: test for testCanvasBindNull.
107 * @tc.size : SmallTest
108 * @tc.type : Function
109 * @tc.level : Level 3
110 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasBindNull, TestSize.Level3)111 HWTEST_F(DrawingNativeCanvasTest, testCanvasBindNull, TestSize.Level3) {
112 // step 1
113 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
114 EXPECT_NE(canvas, nullptr);
115
116 // step 2
117 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
118 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
119 constexpr uint32_t width = 200;
120 constexpr uint32_t height = 200;
121 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
122 OH_Drawing_CanvasBind(nullptr, bitmap);
123
124 // step 3
125 OH_Drawing_CanvasBind(canvas, nullptr);
126
127 // step 4
128 OH_Drawing_BitmapDestroy(bitmap);
129 OH_Drawing_CanvasDestroy(canvas);
130 }
131
132 /*
133 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0202
134 * @tc.name: testCanvasBindDestroyBitmap
135 * @tc.desc: test for testCanvasBindNull.
136 * @tc.size : SmallTest
137 * @tc.type : Function
138 * @tc.level : Level 3
139 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasBindDestroyBitmap, TestSize.Level3)140 HWTEST_F(DrawingNativeCanvasTest, testCanvasBindDestroyBitmap, TestSize.Level3) {
141 // step 1
142 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
143 EXPECT_NE(canvas, nullptr);
144
145 // step 2
146 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
147 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
148 constexpr uint32_t width = 200;
149 constexpr uint32_t height = 200;
150 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
151 OH_Drawing_CanvasBind(canvas, bitmap);
152
153 // step 3
154 OH_Drawing_BitmapDestroy(bitmap);
155
156 // step 4
157 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 100, 200, 300);
158 OH_Drawing_CanvasDrawRect(canvas, rect);
159
160 // step 5
161 OH_Drawing_RectDestroy(rect);
162 OH_Drawing_CanvasDestroy(canvas);
163 }
164
165 /*
166 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0203
167 * @tc.name: testCanvasBindMultipleCalls
168 * @tc.desc: test for testCanvasBindNormal.
169 * @tc.size : SmallTest
170 * @tc.type : Function
171 * @tc.level : Level 0
172 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasBindMultipleCalls, TestSize.Level0)173 HWTEST_F(DrawingNativeCanvasTest, testCanvasBindMultipleCalls, TestSize.Level0) {
174 // step 1
175 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
176 EXPECT_NE(canvas, nullptr);
177
178 // step 2
179 for (int i = 0; i < 10; i++) {
180 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
181 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
182 uint32_t width = 200 + i;
183 uint32_t height = 200 + i;
184 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
185 OH_Drawing_CanvasBind(canvas, bitmap);
186 OH_Drawing_BitmapDestroy(bitmap);
187 }
188
189 // step 3
190 OH_Drawing_CanvasDestroy(canvas);
191 }
192
193 /*
194 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0204
195 * @tc.name: testCanvasBindBoundaryMultipleCallsBoundary
196 * @tc.desc: test for testCanvasBindBoundaryl.
197 * @tc.size : SmallTest
198 * @tc.type : Function
199 * @tc.level : Level 0
200 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasBindBoundaryMultipleCallsBoundary, TestSize.Level0)201 HWTEST_F(DrawingNativeCanvasTest, testCanvasBindBoundaryMultipleCallsBoundary, TestSize.Level0) {
202 // step 1
203 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
204 EXPECT_NE(canvas, nullptr);
205
206 // step 2
207 for (int i = 0; i < 10; i++) {
208 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
209 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
210 uint32_t width = 4096;
211 uint32_t height = 2160;
212 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
213 OH_Drawing_CanvasBind(canvas, bitmap);
214 OH_Drawing_BitmapDestroy(bitmap);
215 }
216
217 // step 3
218 OH_Drawing_CanvasDestroy(canvas);
219 }
220
221 /*
222 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0300
223 * @tc.name: testCanvasAttachPenDetachPenNormal
224 * @tc.desc: test for testCanvasAttachPenDetachPenNormal.
225 * @tc.size : SmallTest
226 * @tc.type : Function
227 * @tc.level : Level 0
228 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNormal, TestSize.Level0)229 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNormal, TestSize.Level0) {
230 // step 1
231 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
232 EXPECT_NE(canvas, nullptr);
233
234 // step 2
235 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
236 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
237 constexpr uint32_t width = 200;
238 constexpr uint32_t height = 200;
239 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
240 OH_Drawing_CanvasBind(canvas, bitmap);
241
242 // step 3
243 OH_Drawing_Pen *pen = OH_Drawing_PenCreate();
244 EXPECT_NE(pen, nullptr);
245 OH_Drawing_CanvasAttachPen(canvas, pen);
246
247 // step 4
248 OH_Drawing_CanvasDetachPen(canvas);
249
250 // step 5
251 OH_Drawing_PenDestroy(pen);
252 OH_Drawing_BitmapDestroy(bitmap);
253 OH_Drawing_CanvasDestroy(canvas);
254 }
255
256 /*
257 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0301
258 * @tc.name: testCanvasAttachPenDetachPenNull
259 * @tc.desc: test for testCanvasAttachPenDetachPenNull.
260 * @tc.size : SmallTest
261 * @tc.type : Function
262 * @tc.level : Level 3
263 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNull, TestSize.Level3)264 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNull, TestSize.Level3) {
265 // step 1
266 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
267 EXPECT_NE(canvas, nullptr);
268
269 OH_Drawing_Pen *pen = OH_Drawing_PenCreate();
270 EXPECT_NE(pen, nullptr);
271
272 // step 2
273 OH_Drawing_CanvasAttachPen(nullptr, pen);
274
275 // step 3
276 OH_Drawing_CanvasAttachPen(canvas, nullptr);
277
278 // step 4
279 OH_Drawing_CanvasDetachPen(nullptr);
280
281 // step 5
282 OH_Drawing_Canvas *canvas2 = OH_Drawing_CanvasCreate();
283 OH_Drawing_CanvasDetachPen(canvas2);
284
285 // step 6
286 OH_Drawing_PenDestroy(pen);
287 OH_Drawing_CanvasDestroy(canvas);
288 OH_Drawing_CanvasDestroy(canvas2);
289 }
290
291 /*
292 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0302
293 * @tc.name: testCanvasAttachPenDetachPenMultipleCalls
294 * @tc.desc: test for testCanvasAttachPenDetachPenMultipleCalls.
295 * @tc.size : SmallTest
296 * @tc.type : Function
297 * @tc.level : Level 3
298 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenMultipleCalls, TestSize.Level3)299 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenMultipleCalls, TestSize.Level3) {
300 // step 1
301 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
302 EXPECT_NE(canvas, nullptr);
303
304 OH_Drawing_Pen *pen = OH_Drawing_PenCreate();
305 EXPECT_NE(pen, nullptr);
306
307 // step 2
308 for (int i = 0; i < 10; i++) {
309 OH_Drawing_CanvasAttachPen(canvas, pen);
310 }
311
312 // step 3
313 for (int i = 0; i < 10; i++) {
314 OH_Drawing_CanvasDetachPen(canvas);
315 }
316
317 // step 4
318 for (int i = 0; i < 10; i++) {
319 OH_Drawing_CanvasAttachPen(canvas, pen);
320 OH_Drawing_CanvasDetachPen(canvas);
321 }
322
323 // step 5
324 OH_Drawing_PenDestroy(pen);
325 OH_Drawing_CanvasDestroy(canvas);
326 }
327
328 /*
329 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0303
330 * @tc.name: testCanvasAttachPenOnly
331 * @tc.desc: test for testCanvasAttachPenOnly.
332 * @tc.size : SmallTest
333 * @tc.type : Function
334 * @tc.level : Level 3
335 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenOnly, TestSize.Level3)336 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenOnly, TestSize.Level3) {
337 // step 1
338 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
339 EXPECT_NE(canvas, nullptr);
340
341 OH_Drawing_Pen *pen = OH_Drawing_PenCreate();
342 EXPECT_NE(pen, nullptr);
343
344 // step 2
345 OH_Drawing_CanvasAttachPen(canvas, pen);
346
347 // step 3
348 OH_Drawing_PenDestroy(pen);
349 OH_Drawing_CanvasDestroy(canvas);
350 }
351
352 /*
353 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0304
354 * @tc.name: testCanvasDetachPenOnly
355 * @tc.desc: test for testCanvasDetachPenOnly.
356 * @tc.size : SmallTest
357 * @tc.type : Function
358 * @tc.level : Level 3
359 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachPenOnly, TestSize.Level3)360 HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachPenOnly, TestSize.Level3) {
361 // step 1
362 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
363 EXPECT_NE(canvas, nullptr);
364
365 // step 2
366 OH_Drawing_CanvasDetachPen(canvas);
367
368 // step 3
369 OH_Drawing_CanvasDestroy(canvas);
370 }
371
372 /*
373 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0305
374 * @tc.name: testCanvasAttachPenDetachPenBoundary
375 * @tc.desc: test for testCanvasAttachPenDetachPenBounday.
376 * @tc.size : SmallTest
377 * @tc.type : Function
378 * @tc.level : Level 0
379 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenBoundary, TestSize.Level0)380 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenBoundary, TestSize.Level0) {
381 // step 1
382 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
383 EXPECT_NE(canvas, nullptr);
384
385 // step 2
386 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
387 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
388 constexpr uint32_t width = 4096;
389 constexpr uint32_t height = 2160;
390 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
391 OH_Drawing_CanvasBind(canvas, bitmap);
392
393 // step 3
394 OH_Drawing_Pen *pen = OH_Drawing_PenCreate();
395 EXPECT_NE(pen, nullptr);
396 OH_Drawing_CanvasAttachPen(canvas, pen);
397
398 // step 4
399 OH_Drawing_CanvasDetachPen(canvas);
400
401 // step 5
402 OH_Drawing_PenDestroy(pen);
403 OH_Drawing_BitmapDestroy(bitmap);
404 OH_Drawing_CanvasDestroy(canvas);
405 }
406
407 /*
408 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0400
409 * @tc.name: testCanvasAttachBrushDetachBrushNormal
410 * @tc.desc: test for testCanvasAttachBrushDetachBrushNormal.
411 * @tc.size : SmallTest
412 * @tc.type : Function
413 * @tc.level : Level 3
414 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNormal, TestSize.Level3)415 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNormal, TestSize.Level3) {
416 // step 1
417 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
418 EXPECT_NE(canvas, nullptr);
419
420 // step 2
421 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
422 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
423 constexpr uint32_t width = 200;
424 constexpr uint32_t height = 200;
425 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
426 OH_Drawing_CanvasBind(canvas, bitmap);
427
428 // step 3
429 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
430 EXPECT_NE(brush, nullptr);
431 OH_Drawing_CanvasAttachBrush(canvas, brush);
432
433 // step 4
434 OH_Drawing_CanvasDetachBrush(canvas);
435
436 // step 5
437 OH_Drawing_CanvasDestroy(canvas);
438 OH_Drawing_BrushDestroy(brush);
439 OH_Drawing_BitmapDestroy(bitmap);
440 }
441
442 /*
443 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0401
444 * @tc.name: testCanvasAttachBrushDetachBrushNull
445 * @tc.desc: test for testCanvasAttachBrushDetachBrushNull.
446 * @tc.size : SmallTest
447 * @tc.type : Function
448 * @tc.level : Level 3
449 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNull, TestSize.Level3)450 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNull, TestSize.Level3) {
451 // step 1
452 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
453 EXPECT_NE(canvas, nullptr);
454
455 // step 2
456 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
457 EXPECT_NE(brush, nullptr);
458 OH_Drawing_CanvasAttachBrush(nullptr, brush);
459
460 // step 3
461 OH_Drawing_CanvasAttachBrush(canvas, nullptr);
462
463 // step 4
464 OH_Drawing_CanvasDetachBrush(nullptr);
465
466 // step 5
467 OH_Drawing_Canvas *canvas2 = OH_Drawing_CanvasCreate();
468 EXPECT_NE(canvas2, nullptr);
469 OH_Drawing_CanvasDetachBrush(canvas2);
470
471 // step 6
472 OH_Drawing_CanvasDestroy(canvas);
473 OH_Drawing_BrushDestroy(brush);
474 }
475
476 /*
477 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0402
478 * @tc.name: testCanvasAttachBrushDetachBrushMultipleCalls
479 * @tc.desc: test for testCanvasAttachBrushDetachBrushMultipleCalls
480 * @tc.size : SmallTest
481 * @tc.type : Function
482 * @tc.level : Level 3
483 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushMultipleCalls, TestSize.Level3)484 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushMultipleCalls, TestSize.Level3) {
485 // step 1
486 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
487 EXPECT_NE(canvas, nullptr);
488
489 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
490 EXPECT_NE(brush, nullptr);
491
492 // step 2
493 for (int i = 0; i < 10; i++) {
494 OH_Drawing_CanvasAttachBrush(canvas, brush);
495 }
496
497 // step 3
498 for (int i = 0; i < 10; i++) {
499 OH_Drawing_CanvasDetachBrush(canvas);
500 }
501
502 // step 4
503 for (int i = 0; i < 10; i++) {
504 OH_Drawing_CanvasAttachBrush(canvas, brush);
505 OH_Drawing_CanvasDetachBrush(canvas);
506 }
507
508 // step 5
509 OH_Drawing_BrushDestroy(brush);
510 OH_Drawing_CanvasDestroy(canvas);
511 }
512
513 /*
514 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0403
515 * @tc.name: testCanvasAttachBrushOnly
516 * @tc.desc: test for testCanvasAttachPenOnly.
517 * @tc.size : SmallTest
518 * @tc.type : Function
519 * @tc.level : Level 3
520 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushOnly, TestSize.Level3)521 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushOnly, TestSize.Level3) {
522 // step 1
523 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
524 EXPECT_NE(canvas, nullptr);
525
526 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
527 EXPECT_NE(brush, nullptr);
528
529 // step 2
530 OH_Drawing_CanvasAttachBrush(canvas, brush);
531
532 // step 3
533 OH_Drawing_BrushDestroy(brush);
534 OH_Drawing_CanvasDestroy(canvas);
535 }
536
537 /*
538 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0404
539 * @tc.name: testCanvasDetachBrushOnly
540 * @tc.desc: test for testCanvasDetachBrushOnly.
541 * @tc.size : SmallTest
542 * @tc.type : Function
543 * @tc.level : Level 3
544 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachBrushOnly, TestSize.Level3)545 HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachBrushOnly, TestSize.Level3) {
546 // step 1
547 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
548 EXPECT_NE(canvas, nullptr);
549
550 // step 2
551 OH_Drawing_CanvasDetachBrush(canvas);
552
553 // step 3
554 OH_Drawing_CanvasDestroy(canvas);
555 }
556
557 /*
558 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0405
559 * @tc.name: testCanvasAttachBrushDetachBrushBoudary
560 * @tc.desc: test for testCanvasAttachBrushDetachBrushBoudary.
561 * @tc.size : SmallTest
562 * @tc.type : Function
563 * @tc.level : Level 3
564 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushBoudary, TestSize.Level3)565 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushBoudary, TestSize.Level3) {
566 // step 1
567 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
568 EXPECT_NE(canvas, nullptr);
569
570 // step 2
571 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
572 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
573 constexpr uint32_t width = 4096;
574 constexpr uint32_t height = 2160;
575 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
576 OH_Drawing_CanvasBind(canvas, bitmap);
577
578 // step 3
579 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
580 EXPECT_NE(brush, nullptr);
581 OH_Drawing_CanvasAttachBrush(canvas, brush);
582
583 // step 4
584 OH_Drawing_CanvasDetachBrush(canvas);
585
586 // step 5
587 OH_Drawing_CanvasDestroy(canvas);
588 OH_Drawing_BrushDestroy(brush);
589 OH_Drawing_BitmapDestroy(bitmap);
590 }
591
592 /*
593 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0500
594 * @tc.name: testCanvasSaveNormal
595 * @tc.desc: test for testCanvasSaveNormal
596 * @tc.size : SmallTest
597 * @tc.type : Function
598 * @tc.level : Level 0
599 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveNormal, TestSize.Level0)600 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveNormal, TestSize.Level0) {
601 // step 1
602 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
603 EXPECT_NE(canvas, nullptr);
604
605 // step 2
606 OH_Drawing_CanvasSave(canvas);
607 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
608
609 // step 3
610 OH_Drawing_CanvasTranslate(canvas, 300, 300);
611
612 // step 4
613 OH_Drawing_CanvasSave(canvas);
614 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 3);
615
616 // step 5
617 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
618 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200);
619 OH_Drawing_RectDestroy(rect);
620
621 // step 6
622 OH_Drawing_CanvasDestroy(canvas);
623 }
624
625 /*
626 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0501
627 * @tc.name: testCanvasSavetestCanvasGetSaveCountNull
628 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountNull
629 * @tc.size : SmallTest
630 * @tc.type : Function
631 * @tc.level : Level 3
632 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountNull, TestSize.Level3)633 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountNull, TestSize.Level3) {
634 // step 1
635 OH_Drawing_CanvasSave(nullptr);
636 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(nullptr), 0);
637 }
638
639 /*
640 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0502
641 * @tc.name: testCanvasSavetestCanvasGetSaveCountMultipleCalls
642 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountMultipleCalls
643 * @tc.size : SmallTest
644 * @tc.type : Function
645 * @tc.level : Level 3
646 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountMultipleCalls, TestSize.Level3)647 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountMultipleCalls, TestSize.Level3) {
648 // step 1
649 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
650 EXPECT_NE(canvas, nullptr);
651
652 // step 2
653 OH_Drawing_CanvasSkew(canvas, 10, 20);
654 OH_Drawing_CanvasSave(canvas);
655 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
656
657 // step 3
658 OH_Drawing_CanvasScale(canvas, 0.5, 0.5);
659 OH_Drawing_CanvasSave(canvas);
660 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 3);
661
662 // step 4
663 OH_Drawing_CanvasTranslate(canvas, 10, 20);
664 OH_Drawing_CanvasSave(canvas);
665 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 4);
666
667 // step 5
668 OH_Drawing_CanvasRotate(canvas, 10, 0, 0);
669 OH_Drawing_CanvasSave(canvas);
670 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 5);
671
672 // step 6
673 for (int i = 0; i < 10; i++) {
674 OH_Drawing_CanvasSave(canvas);
675 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 6 + i);
676 }
677
678 // step 7
679 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
680 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200);
681 OH_Drawing_RectDestroy(rect);
682
683 // step 8
684 OH_Drawing_CanvasDestroy(canvas);
685 }
686
687 /*
688 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0503
689 * @tc.name: testCanvasSavetestCanvasGetSaveCountInputDestroyed
690 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountInputDestroyed
691 * @tc.size : SmallTest
692 * @tc.type : Function
693 * @tc.level : Level 3
694 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountInputDestroyed, TestSize.Level3)695 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountInputDestroyed, TestSize.Level3) {
696 // Deprecated
697 }
698
699 /*
700 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0504
701 * @tc.name: testCanvasGetSaveCountWhenNoSave
702 * @tc.desc: test for testCanvasGetSaveCountWhenNoSave
703 * @tc.size : SmallTest
704 * @tc.type : Function
705 * @tc.level : Level 3
706 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasGetSaveCountWhenNoSave, TestSize.Level3)707 HWTEST_F(DrawingNativeCanvasTest, testCanvasGetSaveCountWhenNoSave, TestSize.Level3) {
708 // step 1
709 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
710 EXPECT_NE(canvas, nullptr);
711
712 // step 2
713 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
714
715 // step 3
716 OH_Drawing_CanvasScale(canvas, 0.5, 0.5);
717 OH_Drawing_CanvasTranslate(canvas, 10, 20);
718 OH_Drawing_CanvasRotate(canvas, 10, 0, 0);
719 OH_Drawing_CanvasSave(canvas);
720
721 // step 4
722 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
723
724 // step 5
725 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
726 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200);
727 OH_Drawing_RectDestroy(rect);
728
729 // step 6
730 OH_Drawing_CanvasDestroy(canvas);
731 }
732
733 /*
734 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0600
735 * @tc.name: testCanvasSaveLayerNormal
736 * @tc.desc: test for testCanvasSaveLayerNormal.
737 * @tc.size : SmallTest
738 * @tc.type : Function
739 * @tc.level : Level 0
740 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNormal, TestSize.Level0)741 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNormal, TestSize.Level0) {
742 // step 1
743 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
744 EXPECT_NE(canvas, nullptr);
745 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
746 EXPECT_NE(rect, nullptr);
747 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
748 EXPECT_NE(brush, nullptr);
749 OH_Drawing_CanvasSaveLayer(canvas, rect, brush);
750
751 // step 2
752 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
753
754 // step 3
755 OH_Drawing_RectDestroy(rect);
756 OH_Drawing_BrushDestroy(brush);
757 OH_Drawing_CanvasDestroy(canvas);
758 }
759
760 /*
761 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0601
762 * @tc.name: testCanvasSaveLayerNull
763 * @tc.desc: test for testCanvasSaveLayerNull.
764 * @tc.size : SmallTest
765 * @tc.type : Function
766 * @tc.level : Level 3
767 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNull, TestSize.Level3)768 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNull, TestSize.Level3) {
769 // step 1
770 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
771 EXPECT_NE(canvas, nullptr);
772 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
773 EXPECT_NE(rect, nullptr);
774 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
775 EXPECT_NE(brush, nullptr);
776
777 // step 2
778 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush);
779
780 // step 3
781 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 500, 300, 600);
782 OH_Drawing_CanvasSaveLayer(canvas, rect2, brush);
783 OH_Drawing_RectDestroy(rect2);
784
785 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(200, 0, 300, 600);
786 OH_Drawing_CanvasSaveLayer(canvas, rect3, brush);
787 OH_Drawing_RectDestroy(rect3);
788
789 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(200, 500, 0, 600);
790 OH_Drawing_CanvasSaveLayer(canvas, rect4, brush);
791 OH_Drawing_RectDestroy(rect4);
792
793 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 500, 300, 0);
794 OH_Drawing_CanvasSaveLayer(canvas, rect5, brush);
795 OH_Drawing_RectDestroy(rect5);
796
797 // step 4
798 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(0, 0, 0, 0);
799 OH_Drawing_CanvasSaveLayer(canvas, rect6, brush);
800 OH_Drawing_RectDestroy(rect6);
801
802 // step 5
803 OH_Drawing_CanvasSaveLayer(canvas, rect, nullptr);
804
805 // step 6
806 OH_Drawing_RectDestroy(rect);
807 OH_Drawing_BrushDestroy(brush);
808 OH_Drawing_CanvasDestroy(canvas);
809 }
810
811 /*
812 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0602
813 * @tc.name: testCanvasSaveLayerAbnormal
814 * @tc.desc: test for testCanvasSaveLayerAbnormal.
815 * @tc.size : SmallTest
816 * @tc.type : Function
817 * @tc.level : Level 3
818 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerAbnormal, TestSize.Level3)819 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerAbnormal, TestSize.Level3) {
820 // 1. OH_Drawing_CanvasCreate, OH_Drawing_BrushCreate
821 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
822 EXPECT_NE(canvas, nullptr);
823
824 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
825 EXPECT_NE(brush, nullptr);
826
827 // 2. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, negative numbers are passed for left, top, right,
828 // and bottom.
829 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(-200, 500, 300, 600);
830 OH_Drawing_CanvasSaveLayer(canvas, rect1, brush);
831 OH_Drawing_RectDestroy(rect1);
832 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(200, -500, 300, 600);
833 OH_Drawing_CanvasSaveLayer(canvas, rect2, brush);
834 OH_Drawing_RectDestroy(rect2);
835 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(200, 500, -300, 600);
836 OH_Drawing_CanvasSaveLayer(canvas, rect3, brush);
837 OH_Drawing_RectDestroy(rect3);
838 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(200, 500, 300, -600);
839 OH_Drawing_CanvasSaveLayer(canvas, rect4, brush);
840 OH_Drawing_RectDestroy(rect4);
841
842 // 3. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the horizontal coordinate of the top-left corner
843 // of the rectangle is equal to the horizontal coordinate of the bottom-right corner, or the vertical coordinate of
844 // the top-left corner of the rectangle is equal to the vertical coordinate of the bottom-right corner.
845 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 500, 200, 600);
846 OH_Drawing_CanvasSaveLayer(canvas, rect5, brush);
847 OH_Drawing_RectDestroy(rect5);
848 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(200, 500, 300, 500);
849 OH_Drawing_CanvasSaveLayer(canvas, rect6, brush);
850 OH_Drawing_RectDestroy(rect6);
851
852 // 4. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the coordinates of the top-left corner are equal
853 // to the coordinates of the bottom-right corner.
854 OH_Drawing_Rect *rect7 = OH_Drawing_RectCreate(200, 500, 200, 500);
855 OH_Drawing_CanvasSaveLayer(canvas, rect7, brush);
856 OH_Drawing_RectDestroy(rect7);
857
858 // 5. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the coordinates of the top-left corner are
859 // greater than the coordinates of the bottom-right corner.
860 OH_Drawing_Rect *rect8 = OH_Drawing_RectCreate(300, 600, 200, 500);
861 OH_Drawing_CanvasSaveLayer(canvas, rect8, brush);
862 OH_Drawing_RectDestroy(rect8);
863
864 // 6. Release memory.
865 OH_Drawing_BrushDestroy(brush);
866 OH_Drawing_CanvasDestroy(canvas);
867 }
868
869 /*
870 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0603
871 * @tc.name: testCanvasSaveLayerRestore
872 * @tc.desc: test for testCanvasSaveLayerRestore.
873 * @tc.size : SmallTest
874 * @tc.type : Function
875 * @tc.level : Level 2
876 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerRestore, TestSize.Level2)877 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerRestore, TestSize.Level2) {
878 // 1. OH_Drawing_CanvasCreate, OH_Drawing_RectCreate, OH_Drawing_BrushCreate
879 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
880 EXPECT_NE(canvas, nullptr);
881 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
882 EXPECT_NE(rect, nullptr);
883 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
884 EXPECT_NE(brush, nullptr);
885
886 // 2. Use OH_Drawing_CanvasSaveLayer and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states
887 // for the canvas.
888 OH_Drawing_CanvasSave(canvas);
889 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
890
891 // 3. Use the restore interface OH_Drawing_CanvasRestore to discard any changes made to the matrix and clip region
892 // and draw the bitmap.
893 OH_Drawing_CanvasRestore(canvas);
894 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
895
896 // 4. Release memory.
897 OH_Drawing_CanvasDestroy(canvas);
898 OH_Drawing_RectDestroy(rect);
899 OH_Drawing_BrushDestroy(brush);
900 }
901
902 /*
903 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0604
904 * @tc.name: testCanvasSaveLayerMultipleCalls
905 * @tc.desc: test for testCanvasSaveLayerMultipleCalls.
906 * @tc.size : SmallTest
907 * @tc.type : Function
908 * @tc.level : Level 3
909 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerMultipleCalls, TestSize.Level3)910 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerMultipleCalls, TestSize.Level3) {
911 // 1. OH_Drawing_CanvasCreate, OH_Drawing_BrushCreate
912 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
913 EXPECT_NE(canvas, nullptr);
914 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
915 EXPECT_NE(brush, nullptr);
916
917 // 2. Use OH_Drawing_CanvasSaveLayer in a loop 10 times, configure different sizes of rects. After each call to the
918 // interface, use OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for the canvas.
919 for (int i = 0; i < 10; i++) {
920 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300 + i, 600 + i);
921 OH_Drawing_CanvasSaveLayer(canvas, rect, brush);
922 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2);
923 OH_Drawing_RectDestroy(rect);
924 }
925
926 // 3. Release memory.
927 OH_Drawing_CanvasDestroy(canvas);
928 OH_Drawing_BrushDestroy(brush);
929 }
930
931 /*
932 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0700
933 * @tc.name: testCanvasRestoreNormal
934 * @tc.desc: test for testCanvasRestoreNormal.
935 * @tc.size : SmallTest
936 * @tc.type : Function
937 * @tc.level : Level 0
938 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNormal, TestSize.Level0)939 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNormal, TestSize.Level0) {
940 // 1. OH_Drawing_CanvasCreate
941 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
942
943 // 2. Use OH_Drawing_CanvasSave and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for
944 // the canvas.
945 OH_Drawing_CanvasSave(canvas);
946 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
947
948 // 3. Use OH_Drawing_CanvasRestore and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for
949 // the canvas.
950 OH_Drawing_CanvasRestore(canvas);
951 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
952
953 // 4. Release memory.
954 OH_Drawing_CanvasDestroy(canvas);
955 }
956
957 /*
958 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0701
959 * @tc.name: testCanvasRestoreNull
960 * @tc.desc: test for testCanvasRestoreNull.
961 * @tc.size : SmallTest
962 * @tc.type : Function
963 * @tc.level : Level 3
964 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNull, TestSize.Level3)965 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNull, TestSize.Level3) {
966 // 1. OH_Drawing_CanvasCreate
967 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
968 EXPECT_NE(canvas, nullptr);
969
970 // 2. Use OH_Drawing_CanvasSave and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for
971 // the canvas.
972 OH_Drawing_CanvasSave(canvas);
973 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
974
975 // 3. Use OH_Drawing_CanvasRestore with no arguments, and then call OH_Drawing_CanvasGetSaveCount to retrieve the
976 // number of saved states for the canvas.
977 OH_Drawing_CanvasRestore(nullptr);
978 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2);
979
980 // 4. Release memory.
981 OH_Drawing_CanvasDestroy(canvas);
982 }
983
984 /*
985 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0702
986 * @tc.name: testCanvasRestoreMultipleCalls
987 * @tc.desc: test for testCanvasRestoreMultipleCalls.
988 * @tc.size : SmallTest
989 * @tc.type : Function
990 * @tc.level : Level 3
991 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreMultipleCalls, TestSize.Level3)992 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreMultipleCalls, TestSize.Level3) {
993 // 1. OH_Drawing_CanvasCreate
994 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
995 EXPECT_NE(canvas, nullptr);
996
997 // 2. Call OH_Drawing_CanvasSave 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of
998 // saved states for the canvas.
999 for (int i = 0; i < 10; i++) {
1000 OH_Drawing_CanvasSave(canvas);
1001 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2);
1002 }
1003
1004 // 3. Call OH_Drawing_CanvasRestore 11 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of
1005 // saved states for the canvas.
1006 for (int i = 0; i < 11; i++) {
1007 OH_Drawing_CanvasRestore(canvas);
1008 if (10 - i <= 0) {
1009 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1010 } else {
1011 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 10 - i);
1012 }
1013 }
1014
1015 // 4. Call OH_Drawing_CanvasSave, then call OH_Drawing_CanvasRestore, and finally call OH_Drawing_CanvasGetSaveCount
1016 // to retrieve the number of saved states for the canvas.
1017 OH_Drawing_CanvasSave(canvas);
1018 OH_Drawing_CanvasRestore(canvas);
1019 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1020
1021 // 5. Repeat step 4 for 10 times
1022 for (int i = 0; i < 10; i++) {
1023 OH_Drawing_CanvasSave(canvas);
1024 OH_Drawing_CanvasRestore(canvas);
1025 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1026 }
1027
1028 // 6. Release memory.
1029 OH_Drawing_CanvasDestroy(canvas);
1030 }
1031
1032 /*
1033 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0703
1034 * @tc.name: testCanvasRestoreBeforeSave
1035 * @tc.desc: test for testCanvasRestoreBeforeSave.
1036 * @tc.size : SmallTest
1037 * @tc.type : Function
1038 * @tc.level : Level 3
1039 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreBeforeSave, TestSize.Level3)1040 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreBeforeSave, TestSize.Level3) {
1041 // 1. OH_Drawing_CanvasCreate
1042 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1043 EXPECT_NE(canvas, nullptr);
1044
1045 // 2. Use OH_Drawing_CanvasRestore and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for
1046 // the canvas.
1047 OH_Drawing_CanvasRestore(canvas);
1048 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1049
1050 // 3. Call OH_Drawing_CanvasRestore multiple times and then call OH_Drawing_CanvasGetSaveCount to retrieve the
1051 // number of saved states for the canvas.
1052 for (int i = 0; i < 10; i++) {
1053 OH_Drawing_CanvasRestore(canvas);
1054 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1055 }
1056
1057 // 4. Release memory.
1058 OH_Drawing_CanvasDestroy(canvas);
1059 }
1060
1061 /*
1062 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0704
1063 * @tc.name: testCanvasRestoreInputDestroyed
1064 * @tc.desc: test for testCanvasRestoreInputDestroyed.
1065 * @tc.size : SmallTest
1066 * @tc.type : Function
1067 * @tc.level : Level 3
1068 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreInputDestroyed, TestSize.Level3)1069 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreInputDestroyed, TestSize.Level3) {
1070 // Deprecated
1071 }
1072
1073 /*
1074 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0705
1075 * @tc.name: testCanvasRestoreExceededSaveSavelayerTimes
1076 * @tc.desc: test for testCanvasRestoreExceededSaveSavelayerTimes.
1077 * @tc.size : SmallTest
1078 * @tc.type : Function
1079 * @tc.level : Level 3
1080 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreExceededSaveSavelayerTimes, TestSize.Level3)1081 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreExceededSaveSavelayerTimes, TestSize.Level3) {
1082 // 1、OH_Drawing_CanvasCreate
1083 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1084 EXPECT_NE(canvas, nullptr);
1085 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
1086 EXPECT_NE(rect, nullptr);
1087 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
1088 EXPECT_NE(brush, nullptr);
1089
1090 // 2、Call OH_Drawing_CanvasSave 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of
1091 // saved states corresponding to the canvas status.
1092 for (int i = 0; i < 10; i++) {
1093 OH_Drawing_CanvasSave(canvas);
1094 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2);
1095 }
1096
1097 // 3、Use OH_Drawing_CanvasTranslate, OH_Drawing_CanvasScale, and OH_Drawing_CanvasSkew to modify the canvas status.
1098 OH_Drawing_CanvasTranslate(canvas, 10, 10);
1099 OH_Drawing_CanvasScale(canvas, 10, 10);
1100 OH_Drawing_CanvasSkew(canvas, 10, 10);
1101
1102 // 4、Call OH_Drawing_CanvasSaveLayer 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of
1103 // saved states corresponding to the canvas status.
1104 for (int i = 0; i < 10; i++) {
1105 OH_Drawing_CanvasSaveLayer(canvas, rect, brush);
1106 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 12 + i);
1107 }
1108
1109 // 5、Call OH_Drawing_CanvasRestore more than 20 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the
1110 // number of saved states corresponding to the canvas status.
1111 for (int i = 0; i < 20; i++) {
1112 OH_Drawing_CanvasRestore(canvas);
1113 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 20 - i);
1114 }
1115
1116 // 6、Call OH_Drawing_CanvasSave -> OH_Drawing_CanvasSaveLayer -> Call OH_Drawing_CanvasRestore 3 times, and then
1117 // call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states corresponding to the canvas status.
1118 OH_Drawing_CanvasSave(canvas);
1119 OH_Drawing_CanvasSaveLayer(canvas, rect, brush);
1120 OH_Drawing_CanvasRestore(canvas);
1121 OH_Drawing_CanvasRestore(canvas);
1122 OH_Drawing_CanvasRestore(canvas);
1123 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1124
1125 // 7、Repeat step 6 ten times
1126 for (int i = 0; i < 10; i++) {
1127 OH_Drawing_CanvasSave(canvas);
1128 OH_Drawing_CanvasSaveLayer(canvas, rect, brush);
1129 OH_Drawing_CanvasRestore(canvas);
1130 OH_Drawing_CanvasRestore(canvas);
1131 OH_Drawing_CanvasRestore(canvas);
1132 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1133 }
1134
1135 // 8、Release memory.
1136 OH_Drawing_CanvasDestroy(canvas);
1137 OH_Drawing_RectDestroy(rect);
1138 OH_Drawing_BrushDestroy(brush);
1139 }
1140
1141 /*
1142 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0800
1143 * @tc.name: testCanvasRestoreToCountNormal
1144 * @tc.desc: test for testCanvasRestoreToCountNormal.
1145 * @tc.size : SmallTest
1146 * @tc.type : Function
1147 * @tc.level : Level 0
1148 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNormal, TestSize.Level0)1149 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNormal, TestSize.Level0) {
1150 // 1. OH_Drawing_CanvasCreate
1151 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1152 EXPECT_NE(canvas, nullptr);
1153
1154 // 2. Call OH_Drawing_CanvasSave multiple times and then use OH_Drawing_CanvasGetSaveCount to retrieve the number of
1155 // saved states corresponding to the canvas status.
1156 for (int i = 0; i < 10; i++) {
1157 OH_Drawing_CanvasSave(canvas);
1158 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2);
1159 }
1160
1161 // 3. Iterate through the parameter saveCount from 1 to the maximum number of canvas states, and use
1162 // OH_Drawing_CanvasRestoreToCount to restore the canvas to each state. Use OH_Drawing_CanvasGetSaveCount to
1163 // retrieve the number of saved states corresponding to the canvas status.
1164 for (int i = 1; i <= 10; i++) {
1165 OH_Drawing_CanvasRestoreToCount(canvas, i);
1166 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1167 }
1168
1169 // 4. Free the memory.
1170 OH_Drawing_CanvasDestroy(canvas);
1171 }
1172
1173 /*
1174 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0801
1175 * @tc.name: testCanvasRestoreToCountNull
1176 * @tc.desc: test for testCanvasRestoreToCountNull.
1177 * @tc.size : SmallTest
1178 * @tc.type : Function
1179 * @tc.level : Level 3
1180 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNull, TestSize.Level3)1181 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNull, TestSize.Level3) {
1182 // 1. OH_Drawing_CanvasCreate
1183 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1184 EXPECT_NE(canvas, nullptr);
1185
1186 // 2. Use OH_Drawing_CanvasRestoreToCount with the first parameter empty to retrieve the number of saved states
1187 // corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount.
1188 OH_Drawing_CanvasRestoreToCount(nullptr, 1);
1189 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1190
1191 // 3. Use OH_Drawing_CanvasRestoreToCount with the second parameter as 0 to retrieve the number of saved states
1192 // corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount.
1193 OH_Drawing_CanvasRestoreToCount(canvas, 0);
1194 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1195
1196 // 4. Free the memory.
1197 OH_Drawing_CanvasDestroy(canvas);
1198 }
1199
1200 /*
1201 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0802
1202 * @tc.name: testCanvasRestoreToCountAbnormal
1203 * @tc.desc: test for testCanvasRestoreToCountAbnormal.
1204 * @tc.size : SmallTest
1205 * @tc.type : Function
1206 * @tc.level : Level 3
1207 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountAbnormal, TestSize.Level3)1208 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountAbnormal, TestSize.Level3) {
1209 // 1. OH_Drawing_CanvasCreate
1210 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1211 EXPECT_NE(canvas, nullptr);
1212
1213 // 2. Use OH_Drawing_CanvasRestoreToCount with a negative value for the saveCount parameter to retrieve the number
1214 // of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount.
1215 OH_Drawing_CanvasRestoreToCount(canvas, -1);
1216 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1217
1218 // 3. Use OH_Drawing_CanvasRestoreToCount with a floating-point value for the saveCount parameter to retrieve the
1219 // number of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount.
1220 OH_Drawing_CanvasRestoreToCount(canvas, 1.0);
1221 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1222
1223 // 4. Free the memory.
1224 OH_Drawing_CanvasDestroy(canvas);
1225 }
1226
1227 /*
1228 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0803
1229 * @tc.name: testCanvasRestoreToCountMaximum
1230 * @tc.desc: test for testCanvasRestoreToCountMaximum.
1231 * @tc.size : SmallTest
1232 * @tc.type : Function
1233 * @tc.level : Level 3
1234 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountMaximum, TestSize.Level3)1235 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountMaximum, TestSize.Level3) {
1236 // 1. OH_Drawing_CanvasCreate
1237 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1238 EXPECT_NE(canvas, nullptr);
1239
1240 // 2. Use OH_Drawing_CanvasRestoreToCount with a very large value for the saveCount parameter to retrieve the number
1241 // of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount.
1242 OH_Drawing_CanvasRestoreToCount(canvas, INT32_MAX);
1243 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1);
1244
1245 // 3. Free the memory.
1246 OH_Drawing_CanvasDestroy(canvas);
1247 }
1248
1249 /*
1250 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0804
1251 * @tc.name: testCanvasRestoreToCountExceeded
1252 * @tc.desc: test for testCanvasRestoreToCountExceeded.
1253 * @tc.size : SmallTest
1254 * @tc.type : Function
1255 * @tc.level : Level 3
1256 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountExceeded, TestSize.Level3)1257 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountExceeded, TestSize.Level3) {
1258 // 1. OH_Drawing_CanvasCreate
1259 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1260 EXPECT_NE(canvas, nullptr);
1261
1262 // 2. Call OH_Drawing_CanvasSave multiple times and use OH_Drawing_CanvasGetSaveCount to retrieve the number of
1263 // saved states corresponding to the canvas status.
1264 for (int i = 0; i < 10; i++) {
1265 OH_Drawing_CanvasSave(canvas);
1266 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2);
1267 }
1268
1269 // 3. Use OH_Drawing_CanvasRestoreToCount with a saveCount parameter greater than the maximum number of current
1270 // canvas states to retrieve the number of saved states corresponding to the canvas status using
1271 // OH_Drawing_CanvasGetSaveCount.
1272 OH_Drawing_CanvasRestoreToCount(canvas, INT32_MAX);
1273 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 11);
1274
1275 // 4. Free the memory.
1276 OH_Drawing_CanvasDestroy(canvas);
1277 }
1278
1279 /*
1280 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0805
1281 * @tc.name: testCanvasRestoreToCountInputDestroyed
1282 * @tc.desc: test for testCanvasRestoreToCountInputDestroyed.
1283 * @tc.size : SmallTest
1284 * @tc.type : Function
1285 * @tc.level : Level 3
1286 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountInputDestroyed, TestSize.Level3)1287 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountInputDestroyed, TestSize.Level3) {
1288 // Deprecated
1289 }
1290
1291 /*
1292 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0900
1293 * @tc.name: testCanvasDrawLineNormal
1294 * @tc.desc: test for testCanvasDrawLineNormal.
1295 * @tc.size : SmallTest
1296 * @tc.type : Function
1297 * @tc.level : Level 0
1298 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNormal, TestSize.Level0)1299 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNormal, TestSize.Level0) {
1300 // 1. OH_Drawing_CanvasCreate
1301 // 2. OH_Drawing_CanvasDrawLine, passing floating-point coordinates
1302 // 3. OH_Drawing_CanvasDrawLine, passing integer coordinates
1303 // 4. Free memory
1304 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1305 OH_Drawing_CanvasDrawLine(canvas, 0.0f, 0.0f, 20.0f, 20.0f);
1306 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, 20);
1307 OH_Drawing_CanvasDestroy(canvas);
1308 }
1309
1310 /*
1311 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0901
1312 * @tc.name: testCanvasDrawLineNull
1313 * @tc.desc: test for testCanvasDrawLineNull.
1314 * @tc.size : SmallTest
1315 * @tc.type : Function
1316 * @tc.level : Level 3
1317 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNull, TestSize.Level3)1318 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNull, TestSize.Level3) {
1319 // 1. OH_Drawing_CanvasCreate
1320 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1321 EXPECT_NE(canvas, nullptr);
1322
1323 // 2. Pass an empty value for the first parameter of OH_Drawing_CanvasDrawLine.
1324 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
1325
1326 // 3. Pass NULL for the second parameter of OH_Drawing_CanvasDrawLine.
1327 OH_Drawing_CanvasDrawLine(canvas, 0, 10, 20, 20);
1328
1329 // 4. Pass NULL for the third parameter of OH_Drawing_CanvasDrawLine.
1330 OH_Drawing_CanvasDrawLine(canvas, 10, 0, 20, 20);
1331
1332 // 5. Pass NULL for the fourth parameter of OH_Drawing_CanvasDrawLine.
1333 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 0, 20);
1334
1335 // 6. Pass NULL for the fifth parameter of OH_Drawing_CanvasDrawLine.
1336 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 20, 0);
1337
1338 // 7. Free the memory.
1339 OH_Drawing_CanvasDestroy(canvas);
1340 }
1341
1342 /*
1343 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0902
1344 * @tc.name: testCanvasDrawLineAbnormal
1345 * @tc.desc: test for testCanvasDrawLineAbnormal.
1346 * @tc.size : SmallTest
1347 * @tc.type : Function
1348 * @tc.level : Level 3
1349 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineAbnormal, TestSize.Level3)1350 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineAbnormal, TestSize.Level3) {
1351 // 1. OH_Drawing_CanvasCreate
1352 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1353 EXPECT_NE(canvas, nullptr);
1354
1355 // 2. Pass a negative value for the second parameter of OH_Drawing_CanvasDrawLine.
1356 OH_Drawing_CanvasDrawLine(canvas, -1, 0, 20, 20);
1357
1358 // 3. Pass a negative value for the third parameter of OH_Drawing_CanvasDrawLine.
1359 OH_Drawing_CanvasDrawLine(canvas, 0, -1, 20, 20);
1360
1361 // 4. Pass a negative value for the fourth parameter of OH_Drawing_CanvasDrawLine.
1362 OH_Drawing_CanvasDrawLine(canvas, 0, 0, -20, 20);
1363
1364 // 5. Pass a negative value for the fifth parameter of OH_Drawing_CanvasDrawLine.
1365 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, -20);
1366
1367 // 6. The Y-coordinate (Y1) of the starting point of the line segment in OH_Drawing_CanvasDrawLine is equal to the
1368 // X-coordinate (X2) of the end point, but the Y-coordinate is different.
1369 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, 21);
1370
1371 // 7. The X-coordinate (X1) of the starting point of the line segment in OH_Drawing_CanvasDrawLine is equal to the
1372 // Y-coordinate (Y2) of the starting point, but the X-coordinate is different.
1373 OH_Drawing_CanvasDrawLine(canvas, 0, 20, 21, 20);
1374
1375 // 8. The coordinates of the starting point of the line segment in OH_Drawing_CanvasDrawLine are equal to the
1376 // coordinates of the end point.
1377 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 10, 10);
1378
1379 // 9. The coordinates of the starting point of the line segment in OH_Drawing_CanvasDrawLine are greater than the
1380 // coordinates of the end point.
1381 OH_Drawing_CanvasDrawLine(canvas, 100, 100, 20, 20);
1382
1383 // 10. Free the memory.
1384 OH_Drawing_CanvasDestroy(canvas);
1385 }
1386
1387 /*
1388 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0903
1389 * @tc.name: testCanvasDrawLineMaximum
1390 * @tc.desc: test for testCanvasDrawLineMaximum.
1391 * @tc.size : SmallTest
1392 * @tc.type : Function
1393 * @tc.level : Level 3
1394 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineMaximum, TestSize.Level3)1395 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineMaximum, TestSize.Level3) {
1396 // 1. OH_Drawing_CanvasCreate
1397 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1398 EXPECT_NE(canvas, nullptr);
1399
1400 // 2. Pass a maximum value for the second parameter of OH_Drawing_CanvasDrawLine.
1401 OH_Drawing_CanvasDrawLine(canvas, FLT_MAX, 0, 20, 20);
1402
1403 // 3. Pass a maximum value for the third parameter of OH_Drawing_CanvasDrawLine.
1404 OH_Drawing_CanvasDrawLine(canvas, 0, FLT_MAX, 20, 20);
1405
1406 // 4. Pass a maximum value for the fourth parameter of OH_Drawing_CanvasDrawLine.
1407 OH_Drawing_CanvasDrawLine(canvas, 0, 0, FLT_MAX, 20);
1408
1409 // 5. Pass a maximum value for the fifth parameter of OH_Drawing_CanvasDrawLine.
1410 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, FLT_MAX);
1411
1412 // 6. Free the memory.
1413 OH_Drawing_CanvasDestroy(canvas);
1414 }
1415
1416 /*
1417 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0904
1418 * @tc.name: testCanvasDrawLineInputDestroyed
1419 * @tc.desc: test for testCanvasDrawLineInputDestroyed.
1420 * @tc.size : SmallTest
1421 * @tc.type : Function
1422 * @tc.level : Level 3
1423 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineInputDestroyed, TestSize.Level3)1424 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineInputDestroyed, TestSize.Level3) {
1425 // Deprecated
1426 }
1427
1428 /*
1429 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1000
1430 * @tc.name: testCanvasDrawPathNormal
1431 * @tc.desc: test for testCanvasDrawPathNormal.
1432 * @tc.size : SmallTest
1433 * @tc.type : Function
1434 * @tc.level : Level 0
1435 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNormal, TestSize.Level0)1436 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNormal, TestSize.Level0) {
1437 // 1. OH_Drawing_CanvasCreate
1438 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1439 EXPECT_NE(canvas, nullptr);
1440
1441 // 2. OH_Drawing_PathCreate
1442 OH_Drawing_Path *path = OH_Drawing_PathCreate();
1443 EXPECT_NE(path, nullptr);
1444
1445 // 3. OH_Drawing_PathMoveTo
1446 OH_Drawing_PathMoveTo(path, 50.0f, 50.0f);
1447
1448 // 4. OH_Drawing_PathLineTo
1449 OH_Drawing_PathLineTo(path, 100.0f, 50.0f);
1450
1451 // 5. OH_Drawing_CanvasDrawPath
1452 OH_Drawing_CanvasDrawPath(canvas, path);
1453
1454 // 6. Free the memory.
1455 OH_Drawing_CanvasDestroy(canvas);
1456 OH_Drawing_PathDestroy(path);
1457 }
1458
1459 /*
1460 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1001
1461 * @tc.name: testCanvasDrawPathNull
1462 * @tc.desc: test for testCanvasDrawPathNull.
1463 * @tc.size : SmallTest
1464 * @tc.type : Function
1465 * @tc.level : Level 3
1466 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNull, TestSize.Level3)1467 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNull, TestSize.Level3) {
1468 // 1. OH_Drawing_CanvasCreate
1469 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1470 EXPECT_NE(canvas, nullptr);
1471
1472 // 2. OH_Drawing_PathCreate
1473 OH_Drawing_Path *path = OH_Drawing_PathCreate();
1474 EXPECT_NE(path, nullptr);
1475
1476 // 3. Pass null as the first argument for OH_Drawing_CanvasDrawPath.
1477 OH_Drawing_CanvasDrawPath(nullptr, path);
1478
1479 // 4. Pass null as the second argument for OH_Drawing_CanvasDrawPath.
1480 OH_Drawing_CanvasDrawPath(canvas, nullptr);
1481
1482 // 5. Pass null path as the second argument for OH_Drawing_CanvasDrawPath.
1483 OH_Drawing_CanvasDrawPath(canvas, path);
1484
1485 // 6. Free the memory.
1486 OH_Drawing_CanvasDestroy(canvas);
1487 OH_Drawing_PathDestroy(path);
1488 }
1489
1490 /*
1491 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1002
1492 * @tc.name: testCanvasDrawPathInputDestroyed
1493 * @tc.desc: test for testCanvasDrawPathInputDestroyed.
1494 * @tc.size : SmallTest
1495 * @tc.type : Function
1496 * @tc.level : Level 3
1497 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathInputDestroyed, TestSize.Level3)1498 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathInputDestroyed, TestSize.Level3) {
1499 // Deprecated
1500 }
1501
1502 } // namespace Drawing
1503 } // namespace Rosen
1504 } // namespace OHOS
1505