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 "DrawingNativeCanvasTest.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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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_0300 195 * @tc.name: testCanvasAttachPenDetachPenNormal 196 * @tc.desc: test for testCanvasAttachPenDetachPenNormal. 197 * @tc.size : SmallTest 198 * @tc.type : Function 199 * @tc.level : Level 0 200 */ 201 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNormal, TestSize.Level0) { 202 // step 1 203 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 204 EXPECT_NE(canvas, nullptr); 205 206 // step 2 207 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 208 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 209 constexpr uint32_t width = 200; 210 constexpr uint32_t height = 200; 211 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 212 OH_Drawing_CanvasBind(canvas, bitmap); 213 214 // step 3 215 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 216 EXPECT_NE(pen, nullptr); 217 OH_Drawing_CanvasAttachPen(canvas, pen); 218 219 // step 4 220 OH_Drawing_CanvasDetachPen(canvas); 221 222 // step 5 223 OH_Drawing_PenDestroy(pen); 224 OH_Drawing_BitmapDestroy(bitmap); 225 OH_Drawing_CanvasDestroy(canvas); 226 } 227 228 /* 229 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0301 230 * @tc.name: testCanvasAttachPenDetachPenNull 231 * @tc.desc: test for testCanvasAttachPenDetachPenNull. 232 * @tc.size : SmallTest 233 * @tc.type : Function 234 * @tc.level : Level 3 235 */ 236 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenNull, TestSize.Level3) { 237 // step 1 238 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 239 EXPECT_NE(canvas, nullptr); 240 241 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 242 EXPECT_NE(pen, nullptr); 243 244 // step 2 245 OH_Drawing_CanvasAttachPen(nullptr, pen); 246 247 // step 3 248 OH_Drawing_CanvasAttachPen(canvas, nullptr); 249 250 // step 4 251 OH_Drawing_CanvasDetachPen(nullptr); 252 253 // step 5 254 OH_Drawing_Canvas *canvas2 = OH_Drawing_CanvasCreate(); 255 OH_Drawing_CanvasDetachPen(canvas2); 256 257 // step 6 258 OH_Drawing_PenDestroy(pen); 259 OH_Drawing_CanvasDestroy(canvas); 260 OH_Drawing_CanvasDestroy(canvas2); 261 } 262 263 /* 264 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0302 265 * @tc.name: testCanvasAttachPenDetachPenMultipleCalls 266 * @tc.desc: test for testCanvasAttachPenDetachPenMultipleCalls. 267 * @tc.size : SmallTest 268 * @tc.type : Function 269 * @tc.level : Level 3 270 */ 271 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenDetachPenMultipleCalls, TestSize.Level3) { 272 // step 1 273 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 274 EXPECT_NE(canvas, nullptr); 275 276 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 277 EXPECT_NE(pen, nullptr); 278 279 // step 2 280 for (int i = 0; i < 10; i++) { 281 OH_Drawing_CanvasAttachPen(canvas, pen); 282 } 283 284 // step 3 285 for (int i = 0; i < 10; i++) { 286 OH_Drawing_CanvasDetachPen(canvas); 287 } 288 289 // step 4 290 for (int i = 0; i < 10; i++) { 291 OH_Drawing_CanvasAttachPen(canvas, pen); 292 OH_Drawing_CanvasDetachPen(canvas); 293 } 294 295 // step 5 296 OH_Drawing_PenDestroy(pen); 297 OH_Drawing_CanvasDestroy(canvas); 298 } 299 300 /* 301 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0303 302 * @tc.name: testCanvasAttachPenOnly 303 * @tc.desc: test for testCanvasAttachPenOnly. 304 * @tc.size : SmallTest 305 * @tc.type : Function 306 * @tc.level : Level 3 307 */ 308 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachPenOnly, TestSize.Level3) { 309 // step 1 310 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 311 EXPECT_NE(canvas, nullptr); 312 313 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 314 EXPECT_NE(pen, nullptr); 315 316 // step 2 317 OH_Drawing_CanvasAttachPen(canvas, pen); 318 319 // step 3 320 OH_Drawing_PenDestroy(pen); 321 OH_Drawing_CanvasDestroy(canvas); 322 } 323 324 /* 325 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0304 326 * @tc.name: testCanvasDetachPenOnly 327 * @tc.desc: test for testCanvasDetachPenOnly. 328 * @tc.size : SmallTest 329 * @tc.type : Function 330 * @tc.level : Level 3 331 */ 332 HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachPenOnly, TestSize.Level3) { 333 // step 1 334 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 335 EXPECT_NE(canvas, nullptr); 336 337 // step 2 338 OH_Drawing_CanvasDetachPen(canvas); 339 340 // step 3 341 OH_Drawing_CanvasDestroy(canvas); 342 } 343 344 /* 345 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0400 346 * @tc.name: testCanvasAttachBrushDetachBrushNormal 347 * @tc.desc: test for testCanvasAttachBrushDetachBrushNormal. 348 * @tc.size : SmallTest 349 * @tc.type : Function 350 * @tc.level : Level 3 351 */ 352 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNormal, TestSize.Level3) { 353 // step 1 354 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 355 EXPECT_NE(canvas, nullptr); 356 357 // step 2 358 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 359 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 360 constexpr uint32_t width = 200; 361 constexpr uint32_t height = 200; 362 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 363 OH_Drawing_CanvasBind(canvas, bitmap); 364 365 // step 3 366 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 367 EXPECT_NE(brush, nullptr); 368 OH_Drawing_CanvasAttachBrush(canvas, brush); 369 370 // step 4 371 OH_Drawing_CanvasDetachBrush(canvas); 372 373 // step 5 374 OH_Drawing_CanvasDestroy(canvas); 375 OH_Drawing_BrushDestroy(brush); 376 OH_Drawing_BitmapDestroy(bitmap); 377 } 378 379 /* 380 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0401 381 * @tc.name: testCanvasAttachBrushDetachBrushNull 382 * @tc.desc: test for testCanvasAttachBrushDetachBrushNull. 383 * @tc.size : SmallTest 384 * @tc.type : Function 385 * @tc.level : Level 3 386 */ 387 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushNull, TestSize.Level3) { 388 // step 1 389 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 390 EXPECT_NE(canvas, nullptr); 391 392 // step 2 393 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 394 EXPECT_NE(brush, nullptr); 395 OH_Drawing_CanvasAttachBrush(nullptr, brush); 396 397 // step 3 398 OH_Drawing_CanvasAttachBrush(canvas, nullptr); 399 400 // step 4 401 OH_Drawing_CanvasDetachBrush(nullptr); 402 403 // step 5 404 OH_Drawing_Canvas *canvas2 = OH_Drawing_CanvasCreate(); 405 EXPECT_NE(canvas2, nullptr); 406 OH_Drawing_CanvasDetachBrush(canvas2); 407 408 // step 6 409 OH_Drawing_CanvasDestroy(canvas); 410 OH_Drawing_BrushDestroy(brush); 411 } 412 413 /* 414 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0402 415 * @tc.name: testCanvasAttachBrushDetachBrushMultipleCalls 416 * @tc.desc: test for testCanvasAttachBrushDetachBrushMultipleCalls 417 * @tc.size : SmallTest 418 * @tc.type : Function 419 * @tc.level : Level 3 420 */ 421 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushDetachBrushMultipleCalls, TestSize.Level3) { 422 // step 1 423 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 424 EXPECT_NE(canvas, nullptr); 425 426 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 427 EXPECT_NE(brush, nullptr); 428 429 // step 2 430 for (int i = 0; i < 10; i++) { 431 OH_Drawing_CanvasAttachBrush(canvas, brush); 432 } 433 434 // step 3 435 for (int i = 0; i < 10; i++) { 436 OH_Drawing_CanvasDetachBrush(canvas); 437 } 438 439 // step 4 440 for (int i = 0; i < 10; i++) { 441 OH_Drawing_CanvasAttachBrush(canvas, brush); 442 OH_Drawing_CanvasDetachBrush(canvas); 443 } 444 445 // step 5 446 OH_Drawing_BrushDestroy(brush); 447 OH_Drawing_CanvasDestroy(canvas); 448 } 449 450 /* 451 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0403 452 * @tc.name: testCanvasAttachBrushOnly 453 * @tc.desc: test for testCanvasAttachPenOnly. 454 * @tc.size : SmallTest 455 * @tc.type : Function 456 * @tc.level : Level 3 457 */ 458 HWTEST_F(DrawingNativeCanvasTest, testCanvasAttachBrushOnly, TestSize.Level3) { 459 // step 1 460 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 461 EXPECT_NE(canvas, nullptr); 462 463 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 464 EXPECT_NE(brush, nullptr); 465 466 // step 2 467 OH_Drawing_CanvasAttachBrush(canvas, brush); 468 469 // step 3 470 OH_Drawing_BrushDestroy(brush); 471 OH_Drawing_CanvasDestroy(canvas); 472 } 473 474 /* 475 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0404 476 * @tc.name: testCanvasDetachBrushOnly 477 * @tc.desc: test for testCanvasDetachBrushOnly. 478 * @tc.size : SmallTest 479 * @tc.type : Function 480 * @tc.level : Level 3 481 */ 482 HWTEST_F(DrawingNativeCanvasTest, testCanvasDetachBrushOnly, TestSize.Level3) { 483 // step 1 484 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 485 EXPECT_NE(canvas, nullptr); 486 487 // step 2 488 OH_Drawing_CanvasDetachBrush(canvas); 489 490 // step 3 491 OH_Drawing_CanvasDestroy(canvas); 492 } 493 494 /* 495 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0500 496 * @tc.name: testCanvasSaveNormal 497 * @tc.desc: test for testCanvasSaveNormal 498 * @tc.size : SmallTest 499 * @tc.type : Function 500 * @tc.level : Level 0 501 */ 502 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveNormal, TestSize.Level0) { 503 // step 1 504 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 505 EXPECT_NE(canvas, nullptr); 506 507 // step 2 508 OH_Drawing_CanvasSave(canvas); 509 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 510 511 // step 3 512 OH_Drawing_CanvasTranslate(canvas, 300, 300); 513 514 // step 4 515 OH_Drawing_CanvasSave(canvas); 516 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 3); 517 518 // step 5 519 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300); 520 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200); 521 OH_Drawing_RectDestroy(rect); 522 523 // step 6 524 OH_Drawing_CanvasDestroy(canvas); 525 } 526 527 /* 528 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0501 529 * @tc.name: testCanvasSavetestCanvasGetSaveCountNull 530 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountNull 531 * @tc.size : SmallTest 532 * @tc.type : Function 533 * @tc.level : Level 3 534 */ 535 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountNull, TestSize.Level3) { 536 // step 1 537 OH_Drawing_CanvasSave(nullptr); 538 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(nullptr), 0); 539 } 540 541 /* 542 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0502 543 * @tc.name: testCanvasSavetestCanvasGetSaveCountMultipleCalls 544 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountMultipleCalls 545 * @tc.size : SmallTest 546 * @tc.type : Function 547 * @tc.level : Level 3 548 */ 549 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountMultipleCalls, TestSize.Level3) { 550 // step 1 551 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 552 EXPECT_NE(canvas, nullptr); 553 554 // step 2 555 OH_Drawing_CanvasSkew(canvas, 10, 20); 556 OH_Drawing_CanvasSave(canvas); 557 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 558 559 // step 3 560 OH_Drawing_CanvasScale(canvas, 0.5, 0.5); 561 OH_Drawing_CanvasSave(canvas); 562 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 3); 563 564 // step 4 565 OH_Drawing_CanvasTranslate(canvas, 10, 20); 566 OH_Drawing_CanvasSave(canvas); 567 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 4); 568 569 // step 5 570 OH_Drawing_CanvasRotate(canvas, 10, 0, 0); 571 OH_Drawing_CanvasSave(canvas); 572 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 5); 573 574 // step 6 575 for (int i = 0; i < 10; i++) { 576 OH_Drawing_CanvasSave(canvas); 577 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 6 + i); 578 } 579 580 // step 7 581 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300); 582 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200); 583 OH_Drawing_RectDestroy(rect); 584 585 // step 8 586 OH_Drawing_CanvasDestroy(canvas); 587 } 588 589 /* 590 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0503 591 * @tc.name: testCanvasSavetestCanvasGetSaveCountInputDestroyed 592 * @tc.desc: test for testCanvasSavetestCanvasGetSaveCountInputDestroyed 593 * @tc.size : SmallTest 594 * @tc.type : Function 595 * @tc.level : Level 3 596 */ 597 HWTEST_F(DrawingNativeCanvasTest, testCanvasSavetestCanvasGetSaveCountInputDestroyed, TestSize.Level3) { 598 // Deprecated 599 } 600 601 /* 602 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0504 603 * @tc.name: testCanvasGetSaveCountWhenNoSave 604 * @tc.desc: test for testCanvasGetSaveCountWhenNoSave 605 * @tc.size : SmallTest 606 * @tc.type : Function 607 * @tc.level : Level 3 608 */ 609 HWTEST_F(DrawingNativeCanvasTest, testCanvasGetSaveCountWhenNoSave, TestSize.Level3) { 610 // step 1 611 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 612 EXPECT_NE(canvas, nullptr); 613 614 // step 2 615 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 616 617 // step 3 618 OH_Drawing_CanvasScale(canvas, 0.5, 0.5); 619 OH_Drawing_CanvasTranslate(canvas, 10, 20); 620 OH_Drawing_CanvasRotate(canvas, 10, 0, 0); 621 OH_Drawing_CanvasSave(canvas); 622 623 // step 4 624 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 625 626 // step 5 627 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300); 628 OH_Drawing_CanvasDrawArc(canvas, rect, 10, 200); 629 OH_Drawing_RectDestroy(rect); 630 631 // step 6 632 OH_Drawing_CanvasDestroy(canvas); 633 } 634 635 /* 636 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0600 637 * @tc.name: testCanvasSaveLayerNormal 638 * @tc.desc: test for testCanvasSaveLayerNormal. 639 * @tc.size : SmallTest 640 * @tc.type : Function 641 * @tc.level : Level 0 642 */ 643 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNormal, TestSize.Level0) { 644 // step 1 645 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 646 EXPECT_NE(canvas, nullptr); 647 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 648 EXPECT_NE(rect, nullptr); 649 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 650 EXPECT_NE(brush, nullptr); 651 OH_Drawing_CanvasSaveLayer(canvas, rect, brush); 652 653 // step 2 654 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 655 656 // step 3 657 OH_Drawing_RectDestroy(rect); 658 OH_Drawing_BrushDestroy(brush); 659 OH_Drawing_CanvasDestroy(canvas); 660 } 661 662 /* 663 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0601 664 * @tc.name: testCanvasSaveLayerNull 665 * @tc.desc: test for testCanvasSaveLayerNull. 666 * @tc.size : SmallTest 667 * @tc.type : Function 668 * @tc.level : Level 3 669 */ 670 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerNull, TestSize.Level3) { 671 // step 1 672 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 673 EXPECT_NE(canvas, nullptr); 674 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 675 EXPECT_NE(rect, nullptr); 676 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 677 EXPECT_NE(brush, nullptr); 678 679 // step 2 680 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush); 681 682 // step 3 683 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 500, 300, 600); 684 OH_Drawing_CanvasSaveLayer(canvas, rect2, brush); 685 OH_Drawing_RectDestroy(rect2); 686 687 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(200, 0, 300, 600); 688 OH_Drawing_CanvasSaveLayer(canvas, rect3, brush); 689 OH_Drawing_RectDestroy(rect3); 690 691 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(200, 500, 0, 600); 692 OH_Drawing_CanvasSaveLayer(canvas, rect4, brush); 693 OH_Drawing_RectDestroy(rect4); 694 695 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 500, 300, 0); 696 OH_Drawing_CanvasSaveLayer(canvas, rect5, brush); 697 OH_Drawing_RectDestroy(rect5); 698 699 // step 4 700 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(0, 0, 0, 0); 701 OH_Drawing_CanvasSaveLayer(canvas, rect6, brush); 702 OH_Drawing_RectDestroy(rect6); 703 704 // step 5 705 OH_Drawing_CanvasSaveLayer(canvas, rect, nullptr); 706 707 // step 6 708 OH_Drawing_RectDestroy(rect); 709 OH_Drawing_BrushDestroy(brush); 710 OH_Drawing_CanvasDestroy(canvas); 711 } 712 713 /* 714 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0602 715 * @tc.name: testCanvasSaveLayerAbnormal 716 * @tc.desc: test for testCanvasSaveLayerAbnormal. 717 * @tc.size : SmallTest 718 * @tc.type : Function 719 * @tc.level : Level 3 720 */ 721 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerAbnormal, TestSize.Level3) { 722 // 1. OH_Drawing_CanvasCreate, OH_Drawing_BrushCreate 723 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 724 EXPECT_NE(canvas, nullptr); 725 726 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 727 EXPECT_NE(brush, nullptr); 728 729 // 2. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, negative numbers are passed for left, top, right, 730 // and bottom. 731 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(-200, 500, 300, 600); 732 OH_Drawing_CanvasSaveLayer(canvas, rect1, brush); 733 OH_Drawing_RectDestroy(rect1); 734 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(200, -500, 300, 600); 735 OH_Drawing_CanvasSaveLayer(canvas, rect2, brush); 736 OH_Drawing_RectDestroy(rect2); 737 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(200, 500, -300, 600); 738 OH_Drawing_CanvasSaveLayer(canvas, rect3, brush); 739 OH_Drawing_RectDestroy(rect3); 740 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(200, 500, 300, -600); 741 OH_Drawing_CanvasSaveLayer(canvas, rect4, brush); 742 OH_Drawing_RectDestroy(rect4); 743 744 // 3. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the horizontal coordinate of the top-left corner 745 // of the rectangle is equal to the horizontal coordinate of the bottom-right corner, or the vertical coordinate of 746 // the top-left corner of the rectangle is equal to the vertical coordinate of the bottom-right corner. 747 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 500, 200, 600); 748 OH_Drawing_CanvasSaveLayer(canvas, rect5, brush); 749 OH_Drawing_RectDestroy(rect5); 750 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(200, 500, 300, 500); 751 OH_Drawing_CanvasSaveLayer(canvas, rect6, brush); 752 OH_Drawing_RectDestroy(rect6); 753 754 // 4. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the coordinates of the top-left corner are equal 755 // to the coordinates of the bottom-right corner. 756 OH_Drawing_Rect *rect7 = OH_Drawing_RectCreate(200, 500, 200, 500); 757 OH_Drawing_CanvasSaveLayer(canvas, rect7, brush); 758 OH_Drawing_RectDestroy(rect7); 759 760 // 5. When creating OH_Drawing_Rect in OH_Drawing_CanvasSaveLayer, the coordinates of the top-left corner are 761 // greater than the coordinates of the bottom-right corner. 762 OH_Drawing_Rect *rect8 = OH_Drawing_RectCreate(300, 600, 200, 500); 763 OH_Drawing_CanvasSaveLayer(canvas, rect8, brush); 764 OH_Drawing_RectDestroy(rect8); 765 766 // 6. Release memory. 767 OH_Drawing_BrushDestroy(brush); 768 OH_Drawing_CanvasDestroy(canvas); 769 } 770 771 /* 772 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0603 773 * @tc.name: testCanvasSaveLayerRestore 774 * @tc.desc: test for testCanvasSaveLayerRestore. 775 * @tc.size : SmallTest 776 * @tc.type : Function 777 * @tc.level : Level 2 778 */ 779 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerRestore, TestSize.Level2) { 780 // 1. OH_Drawing_CanvasCreate, OH_Drawing_RectCreate, OH_Drawing_BrushCreate 781 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 782 EXPECT_NE(canvas, nullptr); 783 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 784 EXPECT_NE(rect, nullptr); 785 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 786 EXPECT_NE(brush, nullptr); 787 788 // 2. Use OH_Drawing_CanvasSaveLayer and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states 789 // for the canvas. 790 OH_Drawing_CanvasSave(canvas); 791 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 792 793 // 3. Use the restore interface OH_Drawing_CanvasRestore to discard any changes made to the matrix and clip region 794 // and draw the bitmap. 795 OH_Drawing_CanvasRestore(canvas); 796 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 797 798 // 4. Release memory. 799 OH_Drawing_CanvasDestroy(canvas); 800 OH_Drawing_RectDestroy(rect); 801 OH_Drawing_BrushDestroy(brush); 802 } 803 804 /* 805 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0604 806 * @tc.name: testCanvasSaveLayerMultipleCalls 807 * @tc.desc: test for testCanvasSaveLayerMultipleCalls. 808 * @tc.size : SmallTest 809 * @tc.type : Function 810 * @tc.level : Level 3 811 */ 812 HWTEST_F(DrawingNativeCanvasTest, testCanvasSaveLayerMultipleCalls, TestSize.Level3) { 813 // 1. OH_Drawing_CanvasCreate, OH_Drawing_BrushCreate 814 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 815 EXPECT_NE(canvas, nullptr); 816 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 817 EXPECT_NE(brush, nullptr); 818 819 // 2. Use OH_Drawing_CanvasSaveLayer in a loop 10 times, configure different sizes of rects. After each call to the 820 // interface, use OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for the canvas. 821 for (int i = 0; i < 10; i++) { 822 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300 + i, 600 + i); 823 OH_Drawing_CanvasSaveLayer(canvas, rect, brush); 824 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2); 825 OH_Drawing_RectDestroy(rect); 826 } 827 828 // 3. Release memory. 829 OH_Drawing_CanvasDestroy(canvas); 830 OH_Drawing_BrushDestroy(brush); 831 } 832 833 /* 834 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0700 835 * @tc.name: testCanvasRestoreNormal 836 * @tc.desc: test for testCanvasRestoreNormal. 837 * @tc.size : SmallTest 838 * @tc.type : Function 839 * @tc.level : Level 0 840 */ 841 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNormal, TestSize.Level0) { 842 // 1. OH_Drawing_CanvasCreate 843 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 844 845 // 2. Use OH_Drawing_CanvasSave and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for 846 // the canvas. 847 OH_Drawing_CanvasSave(canvas); 848 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 849 850 // 3. Use OH_Drawing_CanvasRestore and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for 851 // the canvas. 852 OH_Drawing_CanvasRestore(canvas); 853 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 854 855 // 4. Release memory. 856 OH_Drawing_CanvasDestroy(canvas); 857 } 858 859 /* 860 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0701 861 * @tc.name: testCanvasRestoreNull 862 * @tc.desc: test for testCanvasRestoreNull. 863 * @tc.size : SmallTest 864 * @tc.type : Function 865 * @tc.level : Level 3 866 */ 867 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreNull, TestSize.Level3) { 868 // 1. OH_Drawing_CanvasCreate 869 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 870 EXPECT_NE(canvas, nullptr); 871 872 // 2. Use OH_Drawing_CanvasSave and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for 873 // the canvas. 874 OH_Drawing_CanvasSave(canvas); 875 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 876 877 // 3. Use OH_Drawing_CanvasRestore with no arguments, and then call OH_Drawing_CanvasGetSaveCount to retrieve the 878 // number of saved states for the canvas. 879 OH_Drawing_CanvasRestore(nullptr); 880 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 2); 881 882 // 4. Release memory. 883 OH_Drawing_CanvasDestroy(canvas); 884 } 885 886 /* 887 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0702 888 * @tc.name: testCanvasRestoreMultipleCalls 889 * @tc.desc: test for testCanvasRestoreMultipleCalls. 890 * @tc.size : SmallTest 891 * @tc.type : Function 892 * @tc.level : Level 3 893 */ 894 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreMultipleCalls, TestSize.Level3) { 895 // 1. OH_Drawing_CanvasCreate 896 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 897 EXPECT_NE(canvas, nullptr); 898 899 // 2. Call OH_Drawing_CanvasSave 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of 900 // saved states for the canvas. 901 for (int i = 0; i < 10; i++) { 902 OH_Drawing_CanvasSave(canvas); 903 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2); 904 } 905 906 // 3. Call OH_Drawing_CanvasRestore 11 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of 907 // saved states for the canvas. 908 for (int i = 0; i < 11; i++) { 909 OH_Drawing_CanvasRestore(canvas); 910 if (10 - i <= 0) { 911 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 912 } else { 913 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 10 - i); 914 } 915 } 916 917 // 4. Call OH_Drawing_CanvasSave, then call OH_Drawing_CanvasRestore, and finally call OH_Drawing_CanvasGetSaveCount 918 // to retrieve the number of saved states for the canvas. 919 OH_Drawing_CanvasSave(canvas); 920 OH_Drawing_CanvasRestore(canvas); 921 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 922 923 // 5. Repeat step 4 for 10 times 924 for (int i = 0; i < 10; i++) { 925 OH_Drawing_CanvasSave(canvas); 926 OH_Drawing_CanvasRestore(canvas); 927 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 928 } 929 930 // 6. Release memory. 931 OH_Drawing_CanvasDestroy(canvas); 932 } 933 934 /* 935 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0703 936 * @tc.name: testCanvasRestoreBeforeSave 937 * @tc.desc: test for testCanvasRestoreBeforeSave. 938 * @tc.size : SmallTest 939 * @tc.type : Function 940 * @tc.level : Level 3 941 */ 942 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreBeforeSave, TestSize.Level3) { 943 // 1. OH_Drawing_CanvasCreate 944 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 945 EXPECT_NE(canvas, nullptr); 946 947 // 2. Use OH_Drawing_CanvasRestore and call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states for 948 // the canvas. 949 OH_Drawing_CanvasRestore(canvas); 950 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 951 952 // 3. Call OH_Drawing_CanvasRestore multiple times and then call OH_Drawing_CanvasGetSaveCount to retrieve the 953 // number of saved states for the canvas. 954 for (int i = 0; i < 10; i++) { 955 OH_Drawing_CanvasRestore(canvas); 956 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 957 } 958 959 // 4. Release memory. 960 OH_Drawing_CanvasDestroy(canvas); 961 } 962 963 /* 964 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0704 965 * @tc.name: testCanvasRestoreInputDestroyed 966 * @tc.desc: test for testCanvasRestoreInputDestroyed. 967 * @tc.size : SmallTest 968 * @tc.type : Function 969 * @tc.level : Level 3 970 */ 971 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreInputDestroyed, TestSize.Level3) { 972 // Deprecated 973 } 974 975 /* 976 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0705 977 * @tc.name: testCanvasRestoreExceededSaveSavelayerTimes 978 * @tc.desc: test for testCanvasRestoreExceededSaveSavelayerTimes. 979 * @tc.size : SmallTest 980 * @tc.type : Function 981 * @tc.level : Level 3 982 */ 983 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreExceededSaveSavelayerTimes, TestSize.Level3) { 984 // 1、OH_Drawing_CanvasCreate 985 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 986 EXPECT_NE(canvas, nullptr); 987 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600); 988 EXPECT_NE(rect, nullptr); 989 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 990 EXPECT_NE(brush, nullptr); 991 992 // 2、Call OH_Drawing_CanvasSave 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of 993 // saved states corresponding to the canvas status. 994 for (int i = 0; i < 10; i++) { 995 OH_Drawing_CanvasSave(canvas); 996 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2); 997 } 998 999 // 3、Use OH_Drawing_CanvasTranslate, OH_Drawing_CanvasScale, and OH_Drawing_CanvasSkew to modify the canvas status. 1000 OH_Drawing_CanvasTranslate(canvas, 10, 10); 1001 OH_Drawing_CanvasScale(canvas, 10, 10); 1002 OH_Drawing_CanvasSkew(canvas, 10, 10); 1003 1004 // 4、Call OH_Drawing_CanvasSaveLayer 10 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the number of 1005 // saved states corresponding to the canvas status. 1006 for (int i = 0; i < 10; i++) { 1007 OH_Drawing_CanvasSaveLayer(canvas, rect, brush); 1008 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 12 + i); 1009 } 1010 1011 // 5、Call OH_Drawing_CanvasRestore more than 20 times and then call OH_Drawing_CanvasGetSaveCount to retrieve the 1012 // number of saved states corresponding to the canvas status. 1013 for (int i = 0; i < 20; i++) { 1014 OH_Drawing_CanvasRestore(canvas); 1015 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 20 - i); 1016 } 1017 1018 // 6、Call OH_Drawing_CanvasSave -> OH_Drawing_CanvasSaveLayer -> Call OH_Drawing_CanvasRestore 3 times, and then 1019 // call OH_Drawing_CanvasGetSaveCount to retrieve the number of saved states corresponding to the canvas status. 1020 OH_Drawing_CanvasSave(canvas); 1021 OH_Drawing_CanvasSaveLayer(canvas, rect, brush); 1022 OH_Drawing_CanvasRestore(canvas); 1023 OH_Drawing_CanvasRestore(canvas); 1024 OH_Drawing_CanvasRestore(canvas); 1025 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1026 1027 // 7、Repeat step 6 ten times 1028 for (int i = 0; i < 10; i++) { 1029 OH_Drawing_CanvasSave(canvas); 1030 OH_Drawing_CanvasSaveLayer(canvas, rect, brush); 1031 OH_Drawing_CanvasRestore(canvas); 1032 OH_Drawing_CanvasRestore(canvas); 1033 OH_Drawing_CanvasRestore(canvas); 1034 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1035 } 1036 1037 // 8、Release memory. 1038 OH_Drawing_CanvasDestroy(canvas); 1039 OH_Drawing_RectDestroy(rect); 1040 OH_Drawing_BrushDestroy(brush); 1041 } 1042 1043 /* 1044 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0800 1045 * @tc.name: testCanvasRestoreToCountNormal 1046 * @tc.desc: test for testCanvasRestoreToCountNormal. 1047 * @tc.size : SmallTest 1048 * @tc.type : Function 1049 * @tc.level : Level 0 1050 */ 1051 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNormal, TestSize.Level0) { 1052 // 1. OH_Drawing_CanvasCreate 1053 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1054 EXPECT_NE(canvas, nullptr); 1055 1056 // 2. Call OH_Drawing_CanvasSave multiple times and then use OH_Drawing_CanvasGetSaveCount to retrieve the number of 1057 // saved states corresponding to the canvas status. 1058 for (int i = 0; i < 10; i++) { 1059 OH_Drawing_CanvasSave(canvas); 1060 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2); 1061 } 1062 1063 // 3. Iterate through the parameter saveCount from 1 to the maximum number of canvas states, and use 1064 // OH_Drawing_CanvasRestoreToCount to restore the canvas to each state. Use OH_Drawing_CanvasGetSaveCount to 1065 // retrieve the number of saved states corresponding to the canvas status. 1066 for (int i = 1; i <= 10; i++) { 1067 OH_Drawing_CanvasRestoreToCount(canvas, i); 1068 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1069 } 1070 1071 // 4. Free the memory. 1072 OH_Drawing_CanvasDestroy(canvas); 1073 } 1074 1075 /* 1076 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0801 1077 * @tc.name: testCanvasRestoreToCountNull 1078 * @tc.desc: test for testCanvasRestoreToCountNull. 1079 * @tc.size : SmallTest 1080 * @tc.type : Function 1081 * @tc.level : Level 3 1082 */ 1083 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountNull, TestSize.Level3) { 1084 // 1. OH_Drawing_CanvasCreate 1085 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1086 EXPECT_NE(canvas, nullptr); 1087 1088 // 2. Use OH_Drawing_CanvasRestoreToCount with the first parameter empty to retrieve the number of saved states 1089 // corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount. 1090 OH_Drawing_CanvasRestoreToCount(nullptr, 1); 1091 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1092 1093 // 3. Use OH_Drawing_CanvasRestoreToCount with the second parameter as 0 to retrieve the number of saved states 1094 // corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount. 1095 OH_Drawing_CanvasRestoreToCount(canvas, 0); 1096 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1097 1098 // 4. Free the memory. 1099 OH_Drawing_CanvasDestroy(canvas); 1100 } 1101 1102 /* 1103 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0802 1104 * @tc.name: testCanvasRestoreToCountAbnormal 1105 * @tc.desc: test for testCanvasRestoreToCountAbnormal. 1106 * @tc.size : SmallTest 1107 * @tc.type : Function 1108 * @tc.level : Level 3 1109 */ 1110 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountAbnormal, TestSize.Level3) { 1111 // 1. OH_Drawing_CanvasCreate 1112 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1113 EXPECT_NE(canvas, nullptr); 1114 1115 // 2. Use OH_Drawing_CanvasRestoreToCount with a negative value for the saveCount parameter to retrieve the number 1116 // of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount. 1117 OH_Drawing_CanvasRestoreToCount(canvas, -1); 1118 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1119 1120 // 3. Use OH_Drawing_CanvasRestoreToCount with a floating-point value for the saveCount parameter to retrieve the 1121 // number of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount. 1122 OH_Drawing_CanvasRestoreToCount(canvas, 1.0); 1123 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1124 1125 // 4. Free the memory. 1126 OH_Drawing_CanvasDestroy(canvas); 1127 } 1128 1129 /* 1130 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0803 1131 * @tc.name: testCanvasRestoreToCountMaximum 1132 * @tc.desc: test for testCanvasRestoreToCountMaximum. 1133 * @tc.size : SmallTest 1134 * @tc.type : Function 1135 * @tc.level : Level 3 1136 */ 1137 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountMaximum, TestSize.Level3) { 1138 // 1. OH_Drawing_CanvasCreate 1139 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1140 EXPECT_NE(canvas, nullptr); 1141 1142 // 2. Use OH_Drawing_CanvasRestoreToCount with a very large value for the saveCount parameter to retrieve the number 1143 // of saved states corresponding to the canvas status using OH_Drawing_CanvasGetSaveCount. 1144 OH_Drawing_CanvasRestoreToCount(canvas, INT32_MAX); 1145 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 1); 1146 1147 // 3. Free the memory. 1148 OH_Drawing_CanvasDestroy(canvas); 1149 } 1150 1151 /* 1152 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0804 1153 * @tc.name: testCanvasRestoreToCountExceeded 1154 * @tc.desc: test for testCanvasRestoreToCountExceeded. 1155 * @tc.size : SmallTest 1156 * @tc.type : Function 1157 * @tc.level : Level 3 1158 */ 1159 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountExceeded, TestSize.Level3) { 1160 // 1. OH_Drawing_CanvasCreate 1161 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1162 EXPECT_NE(canvas, nullptr); 1163 1164 // 2. Call OH_Drawing_CanvasSave multiple times and use OH_Drawing_CanvasGetSaveCount to retrieve the number of 1165 // saved states corresponding to the canvas status. 1166 for (int i = 0; i < 10; i++) { 1167 OH_Drawing_CanvasSave(canvas); 1168 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), i + 2); 1169 } 1170 1171 // 3. Use OH_Drawing_CanvasRestoreToCount with a saveCount parameter greater than the maximum number of current 1172 // canvas states to retrieve the number of saved states corresponding to the canvas status using 1173 // OH_Drawing_CanvasGetSaveCount. 1174 OH_Drawing_CanvasRestoreToCount(canvas, INT32_MAX); 1175 EXPECT_EQ(OH_Drawing_CanvasGetSaveCount(canvas), 11); 1176 1177 // 4. Free the memory. 1178 OH_Drawing_CanvasDestroy(canvas); 1179 } 1180 1181 /* 1182 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0805 1183 * @tc.name: testCanvasRestoreToCountInputDestroyed 1184 * @tc.desc: test for testCanvasRestoreToCountInputDestroyed. 1185 * @tc.size : SmallTest 1186 * @tc.type : Function 1187 * @tc.level : Level 3 1188 */ 1189 HWTEST_F(DrawingNativeCanvasTest, testCanvasRestoreToCountInputDestroyed, TestSize.Level3) { 1190 // Deprecated 1191 } 1192 1193 /* 1194 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0900 1195 * @tc.name: testCanvasDrawLineNormal 1196 * @tc.desc: test for testCanvasDrawLineNormal. 1197 * @tc.size : SmallTest 1198 * @tc.type : Function 1199 * @tc.level : Level 0 1200 */ 1201 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNormal, TestSize.Level0) { 1202 // 1、OH_Drawing_CanvasCreate 1203 // 2、OH_Drawing_CanvasDrawLine,坐标传入浮点型数据 1204 // 3、OH_Drawing_CanvasDrawLine,坐标传入整型数据 1205 // 4、释放内存 1206 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1207 OH_Drawing_CanvasDrawLine(canvas, 0.0f, 0.0f, 20.0f, 20.0f); 1208 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, 20); 1209 OH_Drawing_CanvasDestroy(canvas); 1210 } 1211 1212 /* 1213 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0901 1214 * @tc.name: testCanvasDrawLineNull 1215 * @tc.desc: test for testCanvasDrawLineNull. 1216 * @tc.size : SmallTest 1217 * @tc.type : Function 1218 * @tc.level : Level 3 1219 */ 1220 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineNull, TestSize.Level3) { 1221 // 1. OH_Drawing_CanvasCreate 1222 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1223 EXPECT_NE(canvas, nullptr); 1224 1225 // 2. Pass an empty value for the first parameter of OH_Drawing_CanvasDrawLine. 1226 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20); 1227 1228 // 3. Pass NULL for the second parameter of OH_Drawing_CanvasDrawLine. 1229 OH_Drawing_CanvasDrawLine(canvas, 0, 10, 20, 20); 1230 1231 // 4. Pass NULL for the third parameter of OH_Drawing_CanvasDrawLine. 1232 OH_Drawing_CanvasDrawLine(canvas, 10, 0, 20, 20); 1233 1234 // 5. Pass NULL for the fourth parameter of OH_Drawing_CanvasDrawLine. 1235 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 0, 20); 1236 1237 // 6. Pass NULL for the fifth parameter of OH_Drawing_CanvasDrawLine. 1238 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 20, 0); 1239 1240 // 7. Free the memory. 1241 OH_Drawing_CanvasDestroy(canvas); 1242 } 1243 1244 /* 1245 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0902 1246 * @tc.name: testCanvasDrawLineAbnormal 1247 * @tc.desc: test for testCanvasDrawLineAbnormal. 1248 * @tc.size : SmallTest 1249 * @tc.type : Function 1250 * @tc.level : Level 3 1251 */ 1252 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineAbnormal, TestSize.Level3) { 1253 // 1. OH_Drawing_CanvasCreate 1254 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1255 EXPECT_NE(canvas, nullptr); 1256 1257 // 2. Pass a negative value for the second parameter of OH_Drawing_CanvasDrawLine. 1258 OH_Drawing_CanvasDrawLine(canvas, -1, 0, 20, 20); 1259 1260 // 3. Pass a negative value for the third parameter of OH_Drawing_CanvasDrawLine. 1261 OH_Drawing_CanvasDrawLine(canvas, 0, -1, 20, 20); 1262 1263 // 4. Pass a negative value for the fourth parameter of OH_Drawing_CanvasDrawLine. 1264 OH_Drawing_CanvasDrawLine(canvas, 0, 0, -20, 20); 1265 1266 // 5. Pass a negative value for the fifth parameter of OH_Drawing_CanvasDrawLine. 1267 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, -20); 1268 1269 // 6. The Y-coordinate (Y1) of the starting point of the line segment in OH_Drawing_CanvasDrawLine is equal to the 1270 // X-coordinate (X2) of the end point, but the Y-coordinate is different. 1271 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, 21); 1272 1273 // 7. The X-coordinate (X1) of the starting point of the line segment in OH_Drawing_CanvasDrawLine is equal to the 1274 // Y-coordinate (Y2) of the starting point, but the X-coordinate is different. 1275 OH_Drawing_CanvasDrawLine(canvas, 0, 20, 21, 20); 1276 1277 // 8. The coordinates of the starting point of the line segment in OH_Drawing_CanvasDrawLine are equal to the 1278 // coordinates of the end point. 1279 OH_Drawing_CanvasDrawLine(canvas, 10, 10, 10, 10); 1280 1281 // 9. The coordinates of the starting point of the line segment in OH_Drawing_CanvasDrawLine are greater than the 1282 // coordinates of the end point. 1283 OH_Drawing_CanvasDrawLine(canvas, 100, 100, 20, 20); 1284 1285 // 10. Free the memory. 1286 OH_Drawing_CanvasDestroy(canvas); 1287 } 1288 1289 /* 1290 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0903 1291 * @tc.name: testCanvasDrawLineMaximum 1292 * @tc.desc: test for testCanvasDrawLineMaximum. 1293 * @tc.size : SmallTest 1294 * @tc.type : Function 1295 * @tc.level : Level 3 1296 */ 1297 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineMaximum, TestSize.Level3) { 1298 // 1. OH_Drawing_CanvasCreate 1299 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1300 EXPECT_NE(canvas, nullptr); 1301 1302 // 2. Pass a maximum value for the second parameter of OH_Drawing_CanvasDrawLine. 1303 OH_Drawing_CanvasDrawLine(canvas, FLT_MAX, 0, 20, 20); 1304 1305 // 3. Pass a maximum value for the third parameter of OH_Drawing_CanvasDrawLine. 1306 OH_Drawing_CanvasDrawLine(canvas, 0, FLT_MAX, 20, 20); 1307 1308 // 4. Pass a maximum value for the fourth parameter of OH_Drawing_CanvasDrawLine. 1309 OH_Drawing_CanvasDrawLine(canvas, 0, 0, FLT_MAX, 20); 1310 1311 // 5. Pass a maximum value for the fifth parameter of OH_Drawing_CanvasDrawLine. 1312 OH_Drawing_CanvasDrawLine(canvas, 0, 0, 20, FLT_MAX); 1313 1314 // 6. Free the memory. 1315 OH_Drawing_CanvasDestroy(canvas); 1316 } 1317 1318 /* 1319 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_0904 1320 * @tc.name: testCanvasDrawLineInputDestroyed 1321 * @tc.desc: test for testCanvasDrawLineInputDestroyed. 1322 * @tc.size : SmallTest 1323 * @tc.type : Function 1324 * @tc.level : Level 3 1325 */ 1326 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawLineInputDestroyed, TestSize.Level3) { 1327 // Deprecated 1328 } 1329 1330 /* 1331 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1000 1332 * @tc.name: testCanvasDrawPathNormal 1333 * @tc.desc: test for testCanvasDrawPathNormal. 1334 * @tc.size : SmallTest 1335 * @tc.type : Function 1336 * @tc.level : Level 0 1337 */ 1338 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNormal, TestSize.Level0) { 1339 // 1. OH_Drawing_CanvasCreate 1340 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1341 EXPECT_NE(canvas, nullptr); 1342 1343 // 2. OH_Drawing_PathCreate 1344 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1345 EXPECT_NE(path, nullptr); 1346 1347 // 3. OH_Drawing_PathMoveTo 1348 OH_Drawing_PathMoveTo(path, 50.0f, 50.0f); 1349 1350 // 4. OH_Drawing_PathLineTo 1351 OH_Drawing_PathLineTo(path, 100.0f, 50.0f); 1352 1353 // 5. OH_Drawing_CanvasDrawPath 1354 OH_Drawing_CanvasDrawPath(canvas, path); 1355 1356 // 6. Free the memory. 1357 OH_Drawing_CanvasDestroy(canvas); 1358 OH_Drawing_PathDestroy(path); 1359 } 1360 1361 /* 1362 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1001 1363 * @tc.name: testCanvasDrawPathNull 1364 * @tc.desc: test for testCanvasDrawPathNull. 1365 * @tc.size : SmallTest 1366 * @tc.type : Function 1367 * @tc.level : Level 3 1368 */ 1369 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathNull, TestSize.Level3) { 1370 // 1. OH_Drawing_CanvasCreate 1371 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1372 EXPECT_NE(canvas, nullptr); 1373 1374 // 2. OH_Drawing_PathCreate 1375 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1376 EXPECT_NE(path, nullptr); 1377 1378 // 3. Pass null as the first argument for OH_Drawing_CanvasDrawPath. 1379 OH_Drawing_CanvasDrawPath(nullptr, path); 1380 1381 // 4. Pass null as the second argument for OH_Drawing_CanvasDrawPath. 1382 OH_Drawing_CanvasDrawPath(canvas, nullptr); 1383 1384 // 5. Pass null path as the second argument for OH_Drawing_CanvasDrawPath. 1385 OH_Drawing_CanvasDrawPath(canvas, path); 1386 1387 // 6. Free the memory. 1388 OH_Drawing_CanvasDestroy(canvas); 1389 OH_Drawing_PathDestroy(path); 1390 } 1391 1392 /* 1393 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1002 1394 * @tc.name: testCanvasDrawPathInputDestroyed 1395 * @tc.desc: test for testCanvasDrawPathInputDestroyed. 1396 * @tc.size : SmallTest 1397 * @tc.type : Function 1398 * @tc.level : Level 3 1399 */ 1400 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPathInputDestroyed, TestSize.Level3) { 1401 // Deprecated 1402 } 1403 1404 } // namespace Drawing 1405 } // namespace Rosen 1406 } // namespace OHOS 1407