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