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