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 DrawingNativeCanvasPart4Test : public testing::Test { 48 protected: 49 // 在每个测试用例执行前调用 SetUp()50 void SetUp() override 51 { 52 // 设置代码 53 std::cout << "DrawingNativeCanvasPart4Test Setup code called before each test case." << std::endl; 54 OH_Drawing_ErrorCodeReset(); 55 std::cout << "DrawingNativeCanvasPart4Test errorCodeReset before each test case." << std::endl; 56 } TearDown()57 void TearDown() override 58 { 59 std::cout << "DrawingNativeCanvasPart4Test Setup code called after each test case." << std::endl; 60 OH_Drawing_ErrorCodeReset(); 61 std::cout << "DrawingNativeCanvasPart4Test errorCodeReset after each test case." << std::endl; 62 } 63 }; 64 65 /* 66 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2900 67 * @tc.name: testCanvasSkewNormal 68 * @tc.desc: test for testCanvasSkewNormal. 69 * @tc.size : SmallTest 70 * @tc.type : Function 71 * @tc.level : Level 0 72 */ 73 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSkewNormal, Function | SmallTest | Level0) { 74 // 1. OH_Drawing_CanvasCreate 75 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 76 // add assert 77 EXPECT_NE(canvas, nullptr); 78 // 2. OH_Drawing_CanvasSkew with positive skew values on the x and y axes 79 OH_Drawing_CanvasSkew(canvas, 1.0, 1.0); 80 // add assert 81 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 82 // 3. Call drawing class interface 83 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(0, 0, 100, 100); 84 // add assert 85 EXPECT_NE(rect1, nullptr); 86 OH_Drawing_CanvasDrawRect(canvas, rect1); 87 // 4. OH_Drawing_CanvasSkew with negative skew values on the x and y axes 88 OH_Drawing_CanvasSkew(canvas, -1.0, -1.0); 89 // add assert 90 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 91 // 5. Call drawing class interface 92 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 93 // add assert 94 EXPECT_NE(rect2, nullptr); 95 OH_Drawing_CanvasDrawRect(canvas, rect2); 96 // 6. OH_Drawing_CanvasSkew with positive skew value on the x-axis and negative skew value on the y-axis 97 OH_Drawing_CanvasSkew(canvas, 1.0, -1.0); 98 // add assert 99 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 100 // 7. Call drawing class interface 101 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 100, 100); 102 // add assert 103 EXPECT_NE(rect3, nullptr); 104 OH_Drawing_CanvasDrawRect(canvas, rect3); 105 // 8. Free memory 106 OH_Drawing_RectDestroy(rect1); 107 OH_Drawing_RectDestroy(rect2); 108 OH_Drawing_RectDestroy(rect3); 109 OH_Drawing_CanvasDestroy(canvas); 110 } 111 112 /* 113 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2901 114 * @tc.name: testCanvasSkewNull 115 * @tc.desc: test for testCanvasSkewNull. 116 * @tc.size : SmallTest 117 * @tc.type : Function 118 * @tc.level : Level 3 119 */ 120 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSkewNull, Function | SmallTest | Level3) { 121 // 1. OH_Drawing_CanvasCreate 122 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 123 // add assert 124 EXPECT_NE(canvas, nullptr); 125 // 2. OH_Drawing_CanvasSkew with the first parameter as null 126 OH_Drawing_CanvasSkew(nullptr, 2, 2); 127 // add assert 128 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 129 // 3. OH_Drawing_CanvasSkew with the second parameter as 0 130 OH_Drawing_CanvasSkew(canvas, 0, 2); 131 // 4. OH_Drawing_CanvasSkew with the third parameter as 0 132 OH_Drawing_CanvasSkew(canvas, 2, 0); 133 // 5. Free memory 134 OH_Drawing_CanvasDestroy(canvas); 135 } 136 137 /* 138 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2903 139 * @tc.name: testCanvasSkewMaximum 140 * @tc.desc: test for testCanvasSkewMaximum. 141 * @tc.size : SmallTest 142 * @tc.type : Function 143 * @tc.level : Level 3 144 */ 145 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSkewMaximum, Function | SmallTest | Level3) { 146 // 1. OH_Drawing_CanvasCreate 147 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 148 // add assert 149 EXPECT_NE(canvas, nullptr); 150 // 2. OH_Drawing_CanvasSkew with the skew amount sx on the x-axis as the maximum value 151 OH_Drawing_CanvasSkew(canvas, FLT_MAX, 1); 152 // 3. OH_Drawing_CanvasSkew with the skew amount sy on the y-axis as the maximum value 153 OH_Drawing_CanvasSkew(canvas, 1, FLT_MAX); 154 // 4. Free memory 155 OH_Drawing_CanvasDestroy(canvas); 156 } 157 158 /* 159 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2904 160 * @tc.name: testCanvasSkewInputDestroyed 161 * @tc.desc: test for testCanvasSkewInputDestroyed. 162 * @tc.size : SmallTest 163 * @tc.type : Function 164 * @tc.level : Level 3 165 */ 166 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSkewInputDestroyed, Function | SmallTest | Level3) { 167 // Deprecated 168 } 169 170 /* 171 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2905 172 * @tc.name: testCanvasSkewMultipleCalls 173 * @tc.desc: test for testCanvasSkewMultipleCalls. 174 * @tc.size : SmallTest 175 * @tc.type : Function 176 * @tc.level : Level 3 177 */ 178 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSkewMultipleCalls, Function | SmallTest | Level3) { 179 // 1. OH_Drawing_CanvasCreate 180 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 181 // add assert 182 EXPECT_NE(canvas, nullptr); 183 // 2. Call OH_Drawing_CanvasSkew 10 times, each time with a different skew value 184 for (int i = 0; i < 10; i++) { 185 float skew = i * 0.1; 186 OH_Drawing_CanvasSkew(canvas, skew, skew); 187 } 188 // 3. Call drawing class interface 189 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 190 // add assert 191 EXPECT_NE(rect, nullptr); 192 OH_Drawing_CanvasDrawRect(canvas, rect); 193 // 4. Free memory 194 OH_Drawing_RectDestroy(rect); 195 OH_Drawing_CanvasDestroy(canvas); 196 } 197 198 /* 199 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3000 200 * @tc.name: testCanvasGetWidthtestCanvasGetHeightNormal 201 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightNormal. 202 * @tc.size : SmallTest 203 * @tc.type : Function 204 * @tc.level : Level 0 205 */ 206 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetWidthtestCanvasGetHeightNormal, Function | SmallTest | Level0) { 207 // 1. OH_Drawing_CanvasCreate 208 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 209 // add assert 210 EXPECT_NE(canvas, nullptr); 211 // 2. Switch the binding to a bitmap canvas using OH_Drawing_CanvasBind, and verify the canvas information by 212 // calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 213 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 214 // add assert 215 EXPECT_NE(bitmap, nullptr); 216 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 217 constexpr uint32_t width = 200; 218 constexpr uint32_t height = 200; 219 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 220 OH_Drawing_CanvasBind(canvas, bitmap); 221 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 222 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 223 EXPECT_EQ(canvasWidth, width); 224 EXPECT_EQ(canvasHeight, height); 225 // 3. Free memory 226 OH_Drawing_BitmapDestroy(bitmap); 227 OH_Drawing_CanvasDestroy(canvas); 228 } 229 230 /* 231 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3001 232 * @tc.name: testCanvasGetWidthtestCanvasGetHeightNull 233 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightNull. 234 * @tc.size : SmallTest 235 * @tc.type : Function 236 * @tc.level : Level 3 237 */ 238 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetWidthtestCanvasGetHeightNull, Function | SmallTest | Level3) { 239 // 1. OH_Drawing_CanvasCreate 240 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 241 // add assert 242 EXPECT_NE(canvas, nullptr); 243 // 2. OH_Drawing_CanvasGetHeight with null input 244 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(nullptr); 245 EXPECT_EQ(canvasHeight, 0); 246 // 3. OH_Drawing_CanvasGetWidth with null input 247 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(nullptr); 248 EXPECT_EQ(canvasWidth, 0); 249 // 4. Free memory 250 OH_Drawing_CanvasDestroy(canvas); 251 } 252 253 /* 254 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3002 255 * @tc.name: testCanvasGetWidthtestCanvasGetHeightMultipleCalls 256 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightMultipleCalls. 257 * @tc.size : SmallTest 258 * @tc.type : Function 259 * @tc.level : Level 3 260 */ 261 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetWidthtestCanvasGetHeightMultipleCalls, Function | SmallTest | Level3) { 262 // 1. OH_Drawing_CanvasCreate 263 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 264 // add assert 265 EXPECT_NE(canvas, nullptr); 266 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 267 // information by calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth after each switch 268 for (int i = 0; i < 10; i++) { 269 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 270 // add assert 271 EXPECT_NE(bitmap, nullptr); 272 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 273 uint32_t width = 200 + i * 10; 274 uint32_t height = 200 + i * 10; 275 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 276 OH_Drawing_CanvasBind(canvas, bitmap); 277 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 278 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 279 EXPECT_EQ(canvasWidth, width); 280 EXPECT_EQ(canvasHeight, height); 281 OH_Drawing_BitmapDestroy(bitmap); 282 } 283 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 284 for (int i = 0; i < 10; i++) { 285 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 286 // add assert 287 EXPECT_NE(bitmap, nullptr); 288 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 289 uint32_t width = 200 + i * 10; 290 uint32_t height = 200 + i * 10; 291 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 292 OH_Drawing_CanvasBind(canvas, bitmap); 293 OH_Drawing_BitmapDestroy(bitmap); 294 } 295 296 // 4. Call OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 10 times to verify the canvas 297 for (int i = 0; i < 10; i++) { 298 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 299 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 300 EXPECT_EQ(canvasWidth, 200 + 90); 301 EXPECT_EQ(canvasHeight, 200 + 90); 302 } 303 304 // 5. Free memory 305 OH_Drawing_CanvasDestroy(canvas); 306 } 307 308 /* 309 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3003 310 * @tc.name: testCanvasGetWidthtestCanvasGetHeightInputDestroyed 311 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightInputDestroyed. 312 * @tc.size : SmallTest 313 * @tc.type : Function 314 * @tc.level : Level 3 315 */ 316 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetWidthtestCanvasGetHeightInputDestroyed, Function | SmallTest | Level3) { 317 // Deprecated 318 } 319 320 /* 321 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3004 322 * @tc.name: testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary 323 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary. 324 * @tc.size : SmallTest 325 * @tc.type : Function 326 * @tc.level : Level 3 327 */ 328 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary, Function | SmallTest | Level3) { 329 // 1. OH_Drawing_CanvasCreate 330 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 331 // add assert 332 EXPECT_NE(canvas, nullptr); 333 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 334 // information by calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth after each switch 335 constexpr uint32_t width = 4096; 336 constexpr uint32_t height = 2160; 337 for (int i = 0; i < 10; i++) { 338 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 339 // add assert 340 EXPECT_NE(bitmap, nullptr); 341 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 342 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 343 OH_Drawing_CanvasBind(canvas, bitmap); 344 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 345 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 346 EXPECT_EQ(canvasWidth, width); 347 EXPECT_EQ(canvasHeight, height); 348 OH_Drawing_BitmapDestroy(bitmap); 349 } 350 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 351 for (int i = 0; i < 10; i++) { 352 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 353 // add assert 354 EXPECT_NE(bitmap, nullptr); 355 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 356 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 357 OH_Drawing_CanvasBind(canvas, bitmap); 358 OH_Drawing_BitmapDestroy(bitmap); 359 } 360 361 // 4. Call OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 10 times to verify the canvas 362 for (int i = 0; i < 10; i++) { 363 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 364 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 365 EXPECT_EQ(canvasWidth, width); 366 EXPECT_EQ(canvasHeight, height); 367 } 368 369 // 5. Free memory 370 OH_Drawing_CanvasDestroy(canvas); 371 } 372 373 /* 374 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3100 375 * @tc.name: testCanvasGetLocalClipBoundsNormal 376 * @tc.desc: test for testCanvasGetLocalClipBoundsNormal. 377 * @tc.size : SmallTest 378 * @tc.type : Function 379 * @tc.level : Level 0 380 */ 381 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsNormal, Function | SmallTest | Level0) { 382 // 1. OH_Drawing_CanvasCreate 383 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 384 // add assert 385 EXPECT_NE(canvas, nullptr); 386 // 2. OH_Drawing_RectCreate 387 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 388 // add assert 389 EXPECT_NE(rect, nullptr); 390 // 3. OH_Drawing_CanvasGetLocalClipBounds 391 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 392 // add assert 393 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 394 // 4. OH_Drawing_CanvasDrawRect 395 OH_Drawing_CanvasDrawRect(canvas, rect); 396 // 5. Free memory 397 OH_Drawing_RectDestroy(rect); 398 OH_Drawing_CanvasDestroy(canvas); 399 } 400 401 /* 402 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3101 403 * @tc.name: testCanvasGetLocalClipBoundsNull 404 * @tc.desc: test for testCanvasGetLocalClipBoundsNull. 405 * @tc.size : SmallTest 406 * @tc.type : Function 407 * @tc.level : Level 3 408 */ 409 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsNull, Function | SmallTest | Level3) { 410 // 1. OH_Drawing_CanvasCreate 411 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 412 // add assert 413 EXPECT_NE(canvas, nullptr); 414 // 2. OH_Drawing_RectCreate 415 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 416 // add assert 417 EXPECT_NE(rect, nullptr); 418 // 3. OH_Drawing_CanvasGetLocalClipBounds with the first parameter as null 419 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect); 420 // add assert 421 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 422 OH_Drawing_ErrorCodeReset(); 423 // 4. OH_Drawing_CanvasGetLocalClipBounds with the second parameter as null 424 OH_Drawing_CanvasGetLocalClipBounds(canvas, nullptr); 425 // add assert 426 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 427 // 5. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with left, top, right, bottom as 0 428 rect = OH_Drawing_RectCreate(0, 100, 100, 100); 429 // add assert 430 EXPECT_NE(rect, nullptr); 431 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 432 rect = OH_Drawing_RectCreate(100, 0, 100, 100); 433 // add assert 434 EXPECT_NE(rect, nullptr); 435 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 436 rect = OH_Drawing_RectCreate(100, 100, 0, 100); 437 // add assert 438 EXPECT_NE(rect, nullptr); 439 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 440 rect = OH_Drawing_RectCreate(100, 100, 100, 0); 441 // add assert 442 EXPECT_NE(rect, nullptr); 443 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 444 // 6. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with all values as 0 445 rect = OH_Drawing_RectCreate(0, 0, 0, 0); 446 // add assert 447 EXPECT_NE(rect, nullptr); 448 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 449 // 7. Free memory 450 OH_Drawing_RectDestroy(rect); 451 } 452 453 /* 454 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3102 455 * @tc.name: testCanvasGetLocalClipBoundsAbnormal 456 * @tc.desc: test for testCanvasGetLocalClipBoundsAbnormal. 457 * @tc.size : SmallTest 458 * @tc.type : Function 459 * @tc.level : Level 3 460 */ 461 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsAbnormal, Function | SmallTest | Level3) { 462 // 1. OH_Drawing_CanvasCreate 463 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 464 // add assert 465 EXPECT_NE(canvas, nullptr); 466 // 2. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with negative values for left, top, right, 467 // and bottom 468 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(-100, 100, 100, 100); 469 // add assert 470 EXPECT_NE(rect1, nullptr); 471 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect1); 472 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(100, -100, 100, 100); 473 // add assert 474 EXPECT_NE(rect2, nullptr); 475 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect2); 476 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(100, 100, -100, 100); 477 // add assert 478 EXPECT_NE(rect3, nullptr); 479 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect3); 480 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(100, 100, 100, -100); 481 // add assert 482 EXPECT_NE(rect4, nullptr); 483 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect4); 484 // 3. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate equal to the 485 // bottom-right coordinate or the top-left coordinate equal to the bottom-right coordinate 486 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(100, 200, 200, 200); 487 // add assert 488 EXPECT_NE(rect5, nullptr); 489 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect5); 490 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(200, 100, 200, 200); 491 // add assert 492 EXPECT_NE(rect6, nullptr); 493 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect6); 494 // 4. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate equal to the 495 // bottom-right coordinate 496 OH_Drawing_Rect *rect7 = OH_Drawing_RectCreate(100, 100, 100, 100); 497 // add assert 498 EXPECT_NE(rect7, nullptr); 499 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect7); 500 // 5. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate greater than 501 // the bottom-right coordinate 502 OH_Drawing_Rect *rect8 = OH_Drawing_RectCreate(200, 200, 100, 100); 503 // add assert 504 EXPECT_NE(rect8, nullptr); 505 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect8); 506 // 6. Free memory 507 OH_Drawing_RectDestroy(rect1); 508 OH_Drawing_RectDestroy(rect2); 509 OH_Drawing_RectDestroy(rect3); 510 OH_Drawing_RectDestroy(rect4); 511 OH_Drawing_RectDestroy(rect5); 512 OH_Drawing_RectDestroy(rect6); 513 OH_Drawing_RectDestroy(rect7); 514 OH_Drawing_RectDestroy(rect8); 515 OH_Drawing_CanvasDestroy(canvas); 516 } 517 518 /* 519 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3103 520 * @tc.name: testCanvasGetLocalClipBoundsMultipleCalls 521 * @tc.desc: test for testCanvasGetLocalClipBoundsMultipleCalls. 522 * @tc.size : SmallTest 523 * @tc.type : Function 524 * @tc.level : Level 3 525 */ 526 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsMultipleCalls, Function | SmallTest | Level3) { 527 // 1. OH_Drawing_CanvasCreate 528 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 529 // add assert 530 EXPECT_NE(canvas, nullptr); 531 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 532 // information by calling OH_Drawing_CanvasGetLocalClipBounds after each switch 533 for (int i = 0; i < 10; i++) { 534 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 535 // add assert 536 EXPECT_NE(bitmap, nullptr); 537 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 538 uint32_t width = 200; 539 uint32_t height = 200; 540 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 541 OH_Drawing_CanvasBind(canvas, bitmap); 542 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 543 // add assert 544 EXPECT_NE(rect, nullptr); 545 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 546 OH_Drawing_RectDestroy(rect); 547 OH_Drawing_BitmapDestroy(bitmap); 548 } 549 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 550 for (int i = 0; i < 10; i++) { 551 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 552 // add assert 553 EXPECT_NE(bitmap, nullptr); 554 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 555 uint32_t width = 200 + i * 10; 556 uint32_t height = 200 + i * 10; 557 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 558 OH_Drawing_CanvasBind(canvas, bitmap); 559 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 560 // add assert 561 EXPECT_NE(rect, nullptr); 562 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 563 OH_Drawing_RectDestroy(rect); 564 OH_Drawing_BitmapDestroy(bitmap); 565 } 566 // 4. Call OH_Drawing_CanvasGetLocalClipBounds 10 times to verify the canvas 567 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 568 // add assert 569 EXPECT_NE(rect, nullptr); 570 for (int i = 0; i < 10; i++) { 571 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 572 } 573 // 5. Free memory 574 OH_Drawing_RectDestroy(rect); 575 OH_Drawing_CanvasDestroy(canvas); 576 } 577 578 /* 579 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3104 580 * @tc.name: testCanvasGetLocalClipBoundsInputDestroyed 581 * @tc.desc: test for testCanvasGetLocalClipBoundsInputDestroyed. 582 * @tc.size : SmallTest 583 * @tc.type : Function 584 * @tc.level : Level 3 585 */ 586 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsInputDestroyed, Function | SmallTest | Level3) { 587 // Deprecated 588 } 589 590 /* 591 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3105 592 * @tc.name: testCanvasGetLocalClipBoundsMultipleCallsBoundary 593 * @tc.desc: test for testCanvasGetLocalClipBoundsMultipleCallsBoundary. 594 * @tc.size : SmallTest 595 * @tc.type : Function 596 * @tc.level : Level 3 597 */ 598 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetLocalClipBoundsMultipleCallsBoundary, Function | SmallTest | Level3) { 599 // 1. OH_Drawing_CanvasCreate 600 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 601 // add assert 602 EXPECT_NE(canvas, nullptr); 603 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 604 // information by calling OH_Drawing_CanvasGetLocalClipBounds after each switch 605 uint32_t width = 4096; 606 uint32_t height = 2160; 607 for (int i = 0; i < 10; i++) { 608 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 609 // add assert 610 EXPECT_NE(bitmap, nullptr); 611 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 612 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 613 OH_Drawing_CanvasBind(canvas, bitmap); 614 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 615 // add assert 616 EXPECT_NE(rect, nullptr); 617 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 618 OH_Drawing_RectDestroy(rect); 619 OH_Drawing_BitmapDestroy(bitmap); 620 } 621 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 622 for (int i = 0; i < 10; i++) { 623 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 624 // add assert 625 EXPECT_NE(bitmap, nullptr); 626 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 627 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 628 OH_Drawing_CanvasBind(canvas, bitmap); 629 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 630 // add assert 631 EXPECT_NE(rect, nullptr); 632 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 633 OH_Drawing_RectDestroy(rect); 634 OH_Drawing_BitmapDestroy(bitmap); 635 } 636 // 4. Call OH_Drawing_CanvasGetLocalClipBounds 10 times to verify the canvas 637 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 638 for (int i = 0; i < 10; i++) { 639 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 640 } 641 // 5. Free memory 642 OH_Drawing_RectDestroy(rect); 643 OH_Drawing_CanvasDestroy(canvas); 644 } 645 646 /* 647 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3200 648 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal 649 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal. 650 * @tc.size : SmallTest 651 * @tc.type : Function 652 * @tc.level : Level 0 653 */ 654 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal, Function | SmallTest | Level0) { 655 // 1. OH_Drawing_CanvasCreate 656 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 657 // add assert 658 EXPECT_NE(canvas, nullptr); 659 // 2. OH_Drawing_MatrixCreate 660 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 661 // add assert 662 EXPECT_NE(matrix, nullptr); 663 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 664 // 3. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 665 // OH_Drawing_CanvasGetTotalMatrix 666 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 667 // add assert 668 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 669 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 670 // add assert 671 EXPECT_NE(totalMatrix, nullptr); 672 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 673 EXPECT_NE(totalMatrix, nullptr); 674 // 4. Free memory 675 OH_Drawing_MatrixDestroy(matrix); 676 OH_Drawing_MatrixDestroy(totalMatrix); 677 OH_Drawing_CanvasDestroy(canvas); 678 } 679 680 /* 681 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3201 682 * @tc.name: testCanvasConcatMatrixNull 683 * @tc.desc: test for testCanvasConcatMatrixNull. 684 * @tc.size : SmallTest 685 * @tc.type : Function 686 * @tc.level : Level 3 687 */ 688 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasConcatMatrixNull, Function | SmallTest | Level3) { 689 // 1. OH_Drawing_CanvasCreate 690 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 691 // add assert 692 EXPECT_NE(canvas, nullptr); 693 // 2. OH_Drawing_MatrixCreate 694 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 695 // add assert 696 EXPECT_NE(matrix, nullptr); 697 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 698 // 3. OH_Drawing_CanvasConcatMatrix with the first parameter as null 699 OH_Drawing_CanvasConcatMatrix(nullptr, matrix); 700 // add assert 701 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 702 OH_Drawing_ErrorCodeReset(); 703 // 4. OH_Drawing_CanvasConcatMatrix with the second parameter as null 704 OH_Drawing_CanvasConcatMatrix(canvas, nullptr); 705 // add assert 706 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 707 // 5. Free memory 708 OH_Drawing_MatrixDestroy(matrix); 709 OH_Drawing_CanvasDestroy(canvas); 710 } 711 712 /* 713 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3202 714 * @tc.name: testCanvasGetTotalMatrixNull 715 * @tc.desc: test for testCanvasGetTotalMatrixNull. 716 * @tc.size : SmallTest 717 * @tc.type : Function 718 * @tc.level : Level 3 719 */ 720 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetTotalMatrixNull, Function | SmallTest | Level3) { 721 // 1. OH_Drawing_CanvasCreate 722 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 723 // add assert 724 EXPECT_NE(canvas, nullptr); 725 // 2. OH_Drawing_MatrixCreate 726 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 727 // add assert 728 EXPECT_NE(matrix, nullptr); 729 // 3. OH_Drawing_CanvasGetTotalMatrix with the first parameter as null 730 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrix); 731 // add assert 732 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 733 OH_Drawing_ErrorCodeReset(); 734 // 4. OH_Drawing_CanvasGetTotalMatrix with the second parameter as null 735 OH_Drawing_CanvasGetTotalMatrix(canvas, nullptr); 736 // add assert 737 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 738 // 5. Free memory 739 OH_Drawing_MatrixDestroy(matrix); 740 } 741 742 /* 743 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3203 744 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls 745 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls. 746 * @tc.size : SmallTest 747 * @tc.type : Function 748 * @tc.level : Level 3 749 */ 750 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls, Function | SmallTest | Level3) { 751 // 1. OH_Drawing_CanvasCreate 752 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 753 // add assert 754 EXPECT_NE(canvas, nullptr); 755 // 2. OH_Drawing_MatrixCreateScale 756 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreateScale(10, 10, 10, 10); 757 // add assert 758 EXPECT_NE(matrix, nullptr); 759 // 3. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 760 // OH_Drawing_CanvasGetTotalMatrix 761 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 762 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 763 // add assert 764 EXPECT_NE(totalMatrix, nullptr); 765 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 766 // 4. OH_Drawing_MatrixCreateRotation 767 OH_Drawing_Matrix *matrix2 = OH_Drawing_MatrixCreateRotation(180, 1, 1); 768 // add assert 769 EXPECT_NE(matrix2, nullptr); 770 // 5. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 771 // OH_Drawing_CanvasGetTotalMatrix 772 OH_Drawing_CanvasConcatMatrix(canvas, matrix2); 773 OH_Drawing_Matrix *totalMatrix2 = OH_Drawing_MatrixCreate(); 774 // add assert 775 EXPECT_NE(totalMatrix2, nullptr); 776 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix2); 777 // 6. OH_Drawing_MatrixCreateTranslation 778 OH_Drawing_Matrix *matrix3 = OH_Drawing_MatrixCreateTranslation(10, 10); 779 // add assert 780 EXPECT_NE(matrix3, nullptr); 781 // 7. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 782 // OH_Drawing_CanvasGetTotalMatrix 783 OH_Drawing_CanvasConcatMatrix(canvas, matrix3); 784 OH_Drawing_Matrix *totalMatrix3 = OH_Drawing_MatrixCreate(); 785 // add assert 786 EXPECT_NE(totalMatrix3, nullptr); 787 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix3); 788 // 8. Repeat steps 2-7 10 times 789 for (int i = 0; i < 10; i++) { 790 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreateScale(10, 10, 10, 10); 791 // add assert 792 EXPECT_NE(matrix, nullptr); 793 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 794 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 795 // add assert 796 EXPECT_NE(totalMatrix, nullptr); 797 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 798 799 OH_Drawing_Matrix *matrix2 = OH_Drawing_MatrixCreateRotation(180, 1, 1); 800 // add assert 801 EXPECT_NE(matrix2, nullptr); 802 OH_Drawing_CanvasConcatMatrix(canvas, matrix2); 803 OH_Drawing_Matrix *totalMatrix2 = OH_Drawing_MatrixCreate(); 804 // add assert 805 EXPECT_NE(totalMatrix2, nullptr); 806 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix2); 807 808 OH_Drawing_Matrix *matrix3 = OH_Drawing_MatrixCreateTranslation(10, 10); 809 // add assert 810 EXPECT_NE(matrix3, nullptr); 811 OH_Drawing_CanvasConcatMatrix(canvas, matrix3); 812 OH_Drawing_Matrix *totalMatrix3 = OH_Drawing_MatrixCreate(); 813 // add assert 814 EXPECT_NE(totalMatrix3, nullptr); 815 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix3); 816 817 OH_Drawing_MatrixDestroy(matrix); 818 OH_Drawing_MatrixDestroy(matrix2); 819 OH_Drawing_MatrixDestroy(matrix3); 820 OH_Drawing_MatrixDestroy(totalMatrix); 821 OH_Drawing_MatrixDestroy(totalMatrix2); 822 OH_Drawing_MatrixDestroy(totalMatrix3); 823 } 824 // 9. Call OH_Drawing_CanvasConcatMatrix 10 times 825 for (int i = 0; i < 10; i++) { 826 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 827 } 828 829 // 10. Free memory 830 OH_Drawing_MatrixDestroy(matrix); 831 OH_Drawing_MatrixDestroy(matrix2); 832 OH_Drawing_MatrixDestroy(matrix3); 833 OH_Drawing_MatrixDestroy(totalMatrix); 834 } 835 836 /* 837 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3204 838 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed 839 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed. 840 * @tc.size : SmallTest 841 * @tc.type : Function 842 * @tc.level : Level 3 843 */ 844 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed, Function | SmallTest | Level3) { 845 // Deprecated 846 } 847 848 /* 849 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3300 850 * @tc.name: testCanvasDrawShadowNormal 851 * @tc.desc: test for testCanvasDrawShadowNormal. 852 * @tc.size : SmallTest 853 * @tc.type : Function 854 * @tc.level : Level 0 855 */ 856 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawShadowNormal, Function | SmallTest | Level0) { 857 // 1. OH_Drawing_CanvasCreate 858 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 859 EXPECT_NE(canvas, nullptr); 860 // 2. OH_Drawing_PathCreate 861 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 862 EXPECT_NE(path, nullptr); 863 // 3. OH_Drawing_CanvasDrawShadow, iterate through the OH_Drawing_CanvasShadowFlags enumeration values 864 OH_Drawing_CanvasShadowFlags flags[] = { 865 SHADOW_FLAGS_NONE, 866 SHADOW_FLAGS_TRANSPARENT_OCCLUDER, 867 SHADOW_FLAGS_GEOMETRIC_ONLY, 868 SHADOW_FLAGS_ALL, 869 }; 870 OH_Drawing_Point3D p1{0.0, 0.0, 0.0}; 871 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 872 for (int i = 0; i < 4; i++) { 873 OH_Drawing_ErrorCodeReset(); 874 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0xFF000000, flags[i]); 875 // add assert 876 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 877 } 878 // 4. Free memory 879 OH_Drawing_PathDestroy(path); 880 OH_Drawing_CanvasDestroy(canvas); 881 } 882 883 /* 884 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3301 885 * @tc.name: testCanvasDrawShadowNull 886 * @tc.desc: test for testCanvasDrawShadowNull. 887 * @tc.size : SmallTest 888 * @tc.type : Function 889 * @tc.level : Level 3 890 */ 891 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawShadowNull, Function | SmallTest | Level3) { 892 // 1. OH_Drawing_CanvasCreate 893 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 894 // add assert 895 EXPECT_NE(canvas, nullptr); 896 // 2. OH_Drawing_PathCreate 897 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 898 // add assert 899 EXPECT_NE(path, nullptr); 900 // 3. OH_Drawing_CanvasDrawShadow with the first parameter as null 901 OH_Drawing_Point3D p1{0.0, 0.0, 0.0}; 902 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 903 OH_Drawing_CanvasDrawShadow(nullptr, path, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 904 // add assert 905 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 906 OH_Drawing_ErrorCodeReset(); 907 // 4. OH_Drawing_CanvasDrawShadow with the second parameter as null 908 OH_Drawing_CanvasDrawShadow(canvas, nullptr, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 909 // add assert 910 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 911 // 5. OH_Drawing_CanvasDrawShadow with the third parameter as null 912 // Unable to test, compilation error 913 // 6. OH_Drawing_CanvasDrawShadow with the fourth parameter as null 914 // Unable to test, compilation error 915 // 7. OH_Drawing_CanvasDrawShadow with the fifth parameter as 0 916 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 0, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 917 // 8. OH_Drawing_CanvasDrawShadow with the sixth parameter as 0 918 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0, 0xFF000000, SHADOW_FLAGS_ALL); 919 // 9. OH_Drawing_CanvasDrawShadow with the seventh parameter as 0 920 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0, SHADOW_FLAGS_ALL); 921 // 10. Free memory 922 OH_Drawing_PathDestroy(path); 923 OH_Drawing_CanvasDestroy(canvas); 924 } 925 926 /* 927 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3302 928 * @tc.name: testCanvasDrawShadowAbnormal 929 * @tc.desc: test for testCanvasDrawShadowAbnormal. 930 * @tc.size : SmallTest 931 * @tc.type : Function 932 * @tc.level : Level 3 933 */ 934 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawShadowAbnormal, Function | SmallTest | Level3) { 935 // 1. OH_Drawing_CanvasCreate 936 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 937 // add assert 938 EXPECT_NE(canvas, nullptr); 939 // 2. OH_Drawing_PathCreate 940 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 941 // add assert 942 EXPECT_NE(path, nullptr); 943 // 3. OH_Drawing_CanvasDrawShadow, the third parameter planeParams x, y, z are set to negative values 944 OH_Drawing_Point3D p1{-1.0, -1.0, -1.0}; 945 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 946 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 947 // 4. OH_Drawing_CanvasDrawShadow, the fourth parameter devLightPos x, y, z are set to negative values 948 OH_Drawing_Point3D p3{0.0, 0.0, 0.0}; 949 OH_Drawing_Point3D p4{-10.0, -10.0, -10.0}; 950 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 951 // 5. OH_Drawing_CanvasDrawShadow, the fifth parameter lightRadius is set to a negative value 952 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, -10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 953 // 6. OH_Drawing_CanvasDrawShadow, the sixth parameter ambientColor is set to a negative value 954 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, -0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 955 // 7. OH_Drawing_CanvasDrawShadow, the seventh parameter spotColor is set to a negative value 956 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, 0xFF000000, -0xFF000000, SHADOW_FLAGS_ALL); 957 // 8. Free memory 958 OH_Drawing_PathDestroy(path); 959 OH_Drawing_CanvasDestroy(canvas); 960 } 961 962 /* 963 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3303 964 * @tc.name: testCanvasDrawShadowMaximum 965 * @tc.desc: test for testCanvasDrawShadowMaximum. 966 * @tc.size : SmallTest 967 * @tc.type : Function 968 * @tc.level : Level 3 969 */ 970 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawShadowMaximum, Function | SmallTest | Level3) { 971 // 1. OH_Drawing_CanvasCreate 972 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 973 // add assert 974 EXPECT_NE(canvas, nullptr); 975 // 2. OH_Drawing_PathCreate 976 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 977 // add assert 978 EXPECT_NE(path, nullptr); 979 OH_Drawing_Point3D p1{1.0, 1.0, 1.0}; 980 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 981 // 3. OH_Drawing_CanvasDrawShadow, set the x, y, z values in the planeParams parameter to maximum values 982 p1 = {FLT_MAX, FLT_MAX, FLT_MAX}; 983 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 984 // 4. OH_Drawing_CanvasDrawShadow, set the x, y, z values in the devLightPos parameter to maximum values 985 p1 = {1.0, 1.0, 1.0}; 986 p2 = {FLT_MAX, FLT_MAX, FLT_MAX}; 987 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 988 // 5. OH_Drawing_CanvasDrawShadow, set the lightRadius parameter to maximum value 989 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, FLT_MAX, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 990 // 6. OH_Drawing_CanvasDrawShadow, set the ambientColor parameter to maximum value 991 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 992 // 7. OH_Drawing_CanvasDrawShadow, set the spotColor parameter to maximum value 993 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 994 // 8. Free memory 995 OH_Drawing_PathDestroy(path); 996 OH_Drawing_CanvasDestroy(canvas); 997 } 998 999 /* 1000 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3304 1001 * @tc.name: testCanvasDrawShadowInputDestroyed 1002 * @tc.desc: test for testCanvasDrawShadowInputDestroyed. 1003 * @tc.size : SmallTest 1004 * @tc.type : Function 1005 * @tc.level : Level 3 1006 */ 1007 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawShadowInputDestroyed, Function | SmallTest | Level3) { 1008 // Deprecated 1009 } 1010 1011 /* 1012 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3400 1013 * @tc.name: testCanvasClearNormal 1014 * @tc.desc: test for testCanvasClearNormal. 1015 * @tc.size : SmallTest 1016 * @tc.type : Function 1017 * @tc.level : Level 0 1018 */ 1019 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearNormal, Function | SmallTest | Level0) { 1020 // 1. OH_Drawing_CanvasCreate 1021 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1022 // add assert 1023 EXPECT_NE(canvas, nullptr); 1024 // 2. OH_Drawing_CanvasClear, covering the minimum value 0x00000000 and the maximum value 0xFFFFFFFF for color 1025 OH_Drawing_CanvasClear(canvas, 0x00000000); 1026 // add assert 1027 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1028 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 1029 // add assert 1030 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1031 // 3. Free memory 1032 OH_Drawing_CanvasDestroy(canvas); 1033 } 1034 1035 /* 1036 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3401 1037 * @tc.name: testCanvasClearNull 1038 * @tc.desc: test for testCanvasClearNull. 1039 * @tc.size : SmallTest 1040 * @tc.type : Function 1041 * @tc.level : Level 3 1042 */ 1043 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearNull, Function | SmallTest | Level3) { 1044 // 1. OH_Drawing_CanvasCreate 1045 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1046 // add assert 1047 EXPECT_NE(canvas, nullptr); 1048 // 2. OH_Drawing_CanvasClear with the first parameter as null 1049 OH_Drawing_CanvasClear(nullptr, 0x00000000); 1050 // add assert 1051 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1052 // 3. Free memory 1053 OH_Drawing_CanvasDestroy(canvas); 1054 } 1055 1056 /* 1057 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3402 1058 * @tc.name: testCanvasClearAbnormal 1059 * @tc.desc: test for testCanvasClearAbnormal. 1060 * @tc.size : SmallTest 1061 * @tc.type : Function 1062 * @tc.level : Level 3 1063 */ 1064 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearAbnormal, Function | SmallTest | Level3) { 1065 // 1. OH_Drawing_CanvasCreate 1066 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1067 // add assert 1068 EXPECT_NE(canvas, nullptr); 1069 // 2. OH_Drawing_CanvasClear with the parameter color set to a negative value 1070 OH_Drawing_CanvasClear(canvas, -1); 1071 // 3. OH_Drawing_CanvasClear with the parameter color set to a floating-point value 1072 // compile error, ignore 1073 // 4. Free memory 1074 OH_Drawing_CanvasDestroy(canvas); 1075 } 1076 1077 /* 1078 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3403 1079 * @tc.name: testCanvasClearMultipleCalls 1080 * @tc.desc: test for testCanvasClearMultipleCalls. 1081 * @tc.size : SmallTest 1082 * @tc.type : Function 1083 * @tc.level : Level 3 1084 */ 1085 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearMultipleCalls, Function | SmallTest | Level3) { 1086 // 1. OH_Drawing_CanvasCreate 1087 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1088 // add assert 1089 EXPECT_NE(canvas, nullptr); 1090 // 2. Call OH_Drawing_CanvasClear 10 times, each time with a different color 1091 for (int i = 0; i < 10; i++) { 1092 OH_Drawing_CanvasClear(canvas, 0x11111111 + i * 10); 1093 } 1094 // 3. Free memory 1095 OH_Drawing_CanvasDestroy(canvas); 1096 } 1097 1098 /* 1099 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3404 1100 * @tc.name: testCanvasClearInputDestroyed 1101 * @tc.desc: test for testCanvasClearInputDestroyed. 1102 * @tc.size : SmallTest 1103 * @tc.type : Function 1104 * @tc.level : Level 3 1105 */ 1106 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearInputDestroyed, Function | SmallTest | Level3) { 1107 // Deprecated 1108 } 1109 1110 /* 1111 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3405 1112 * @tc.name: testCanvasClearMaximum 1113 * @tc.desc: test for testCanvasClearMaximum. 1114 * @tc.size : SmallTest 1115 * @tc.type : Function 1116 * @tc.level : Level 3 1117 */ 1118 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClearMaximum, Function | SmallTest | Level3) { 1119 // 1. OH_Drawing_CanvasCreate 1120 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1121 // add assert 1122 EXPECT_NE(canvas, nullptr); 1123 // 2. OH_Drawing_CanvasClear with the parameter color set to the maximum value 1124 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 1125 // 3. Free memory 1126 OH_Drawing_CanvasDestroy(canvas); 1127 } 1128 1129 /* 1130 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3500 1131 * @tc.name: testCanvasSetMatrixNormal 1132 * @tc.desc: test for testCanvasSetMatrixNormal. 1133 * @tc.size : SmallTest 1134 * @tc.type : Function 1135 * @tc.level : Level 0 1136 */ 1137 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSetMatrixNormal, Function | SmallTest | Level0) { 1138 // 1. OH_Drawing_CanvasCreate 1139 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1140 // add assert 1141 EXPECT_NE(canvas, nullptr); 1142 // 2. OH_Drawing_MatrixCreate 1143 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1144 // add assert 1145 EXPECT_NE(matrix, nullptr); 1146 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 1147 // 3. Call OH_Drawing_CanvasSetMatrix and use OH_Drawing_MatrixGetValue to get the matrix information 1148 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1149 // add assert 1150 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1151 float val = OH_Drawing_MatrixGetValue(matrix, 0); 1152 EXPECT_EQ(val, 1); 1153 1154 // 4. Free memory 1155 OH_Drawing_MatrixDestroy(matrix); 1156 OH_Drawing_CanvasDestroy(canvas); 1157 } 1158 1159 /* 1160 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3501 1161 * @tc.name: testCanvasSetMatrixNull 1162 * @tc.desc: test for testCanvasSetMatrixNull. 1163 * @tc.size : SmallTest 1164 * @tc.type : Function 1165 * @tc.level : Level 3 1166 */ 1167 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSetMatrixNull, Function | SmallTest | Level3) { 1168 // 1. OH_Drawing_CanvasCreate 1169 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1170 // add assert 1171 EXPECT_NE(canvas, nullptr); 1172 // 2. OH_Drawing_MatrixCreate 1173 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1174 // add assert 1175 EXPECT_NE(matrix, nullptr); 1176 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 1177 // 3. OH_Drawing_CanvasSetMatrix with the first parameter as null 1178 OH_Drawing_CanvasSetMatrix(nullptr, matrix); 1179 // add assert 1180 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1181 OH_Drawing_ErrorCodeReset(); 1182 // 4. OH_Drawing_CanvasSetMatrix with the second parameter as null 1183 OH_Drawing_CanvasSetMatrix(canvas, nullptr); 1184 // add assert 1185 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1186 // 5. Free memory 1187 OH_Drawing_MatrixDestroy(matrix); 1188 OH_Drawing_CanvasDestroy(canvas); 1189 } 1190 /* 1191 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3502 1192 * @tc.name: testCanvasSetMatrixMultipleCalls 1193 * @tc.desc: test for testCanvasSetMatrixMultipleCalls. 1194 * @tc.size : SmallTest 1195 * @tc.type : Function 1196 * @tc.level : Level 3 1197 */ 1198 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSetMatrixMultipleCalls, Function | SmallTest | Level3) { 1199 // 1. OH_Drawing_CanvasCreate 1200 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1201 // add assert 1202 EXPECT_NE(canvas, nullptr); 1203 // 2. OH_Drawing_MatrixCreate 1204 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1205 // add assert 1206 EXPECT_NE(matrix, nullptr); 1207 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 1208 // 3. Call OH_Drawing_CanvasSetMatrix 10 times, and after each call, call OH_Drawing_MatrixGetValue to get the 1209 // matrix information 1210 for (int i = 0; i < 10; i++) { 1211 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1212 float val = OH_Drawing_MatrixGetValue(matrix, 0); 1213 EXPECT_EQ(val, 1); 1214 } 1215 // 4. Free memory 1216 OH_Drawing_MatrixDestroy(matrix); 1217 OH_Drawing_CanvasDestroy(canvas); 1218 } 1219 1220 /* 1221 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3503 1222 * @tc.name: testCanvasSetMatrixInputDestroyed 1223 * @tc.desc: test for testCanvasSetMatrixInputDestroyed. 1224 * @tc.size : SmallTest 1225 * @tc.type : Function 1226 * @tc.level : Level 3 1227 */ 1228 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasSetMatrixInputDestroyed, Function | SmallTest | Level3) { 1229 // Deprecated 1230 } 1231 1232 /* 1233 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3600 1234 * @tc.name: testCanvasResetMatrixNormal 1235 * @tc.desc: test for testCanvasResetMatrixNormal. 1236 * @tc.size : SmallTest 1237 * @tc.type : Function 1238 * @tc.level : Level 0 1239 */ 1240 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasResetMatrixNormal, Function | SmallTest | Level0) { 1241 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1242 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1243 // add assert 1244 EXPECT_NE(canvas, nullptr); 1245 // 2. Call OH_Drawing_CanvasResetMatrix 1246 OH_Drawing_CanvasResetMatrix(canvas); 1247 // add assert 1248 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1249 // 3. Free memory 1250 OH_Drawing_CanvasDestroy(canvas); 1251 } 1252 1253 /* 1254 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3601 1255 * @tc.name: testCanvasResetMatrixNull 1256 * @tc.desc: test for testCanvasResetMatrixNull. 1257 * @tc.size : SmallTest 1258 * @tc.type : Function 1259 * @tc.level : Level 3 1260 */ 1261 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasResetMatrixNull, Function | SmallTest | Level3) { 1262 // 1. Call OH_Drawing_CanvasResetMatrix with a null parameter 1263 OH_Drawing_CanvasResetMatrix(nullptr); 1264 // add assert 1265 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1266 } 1267 1268 /* 1269 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3603 1270 * @tc.name: testCanvasResetMatrixMultipleCalls 1271 * @tc.desc: test for testCanvasResetMatrixMultipleCalls. 1272 * @tc.size : SmallTest 1273 * @tc.type : Function 1274 * @tc.level : Level 3 1275 */ 1276 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasResetMatrixMultipleCalls, Function | SmallTest | Level3) { 1277 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1278 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1279 // add assert 1280 EXPECT_NE(canvas, nullptr); 1281 // 2. Call OH_Drawing_MatrixCreate 1282 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1283 // add assert 1284 EXPECT_NE(matrix, nullptr); 1285 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 1286 // 3. Call OH_Drawing_CanvasSetMatrix 10 times, call OH_Drawing_CanvasResetMatrix 10 times, and get matrix 1287 // information using OH_Drawing_MatrixGetValue 1288 for (int i = 0; i < 10; i++) { 1289 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1290 } 1291 for (int i = 0; i < 10; i++) { 1292 OH_Drawing_ErrorCodeReset(); 1293 OH_Drawing_CanvasResetMatrix(canvas); 1294 // add assert 1295 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1296 } 1297 // 4. Call OH_Drawing_CanvasSetMatrix, OH_Drawing_CanvasResetMatrix, and get matrix information using 1298 // OH_Drawing_MatrixGetValue 1299 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1300 OH_Drawing_CanvasResetMatrix(canvas); 1301 float val = OH_Drawing_MatrixGetValue(matrix, 0); 1302 EXPECT_EQ(val, 1); 1303 // 5. Repeat steps 4 for 10 times 1304 for (int i = 0; i < 10; i++) { 1305 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1306 OH_Drawing_CanvasResetMatrix(canvas); 1307 EXPECT_EQ(OH_Drawing_MatrixGetValue(matrix, 0), 1); 1308 } 1309 // 6. Free memory 1310 OH_Drawing_MatrixDestroy(matrix); 1311 OH_Drawing_CanvasDestroy(canvas); 1312 } 1313 1314 /* 1315 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3700 1316 * @tc.name: testCanvasDrawImageRectWithSrcNormal 1317 * @tc.desc: test for testCanvasDrawImageRectWithSrcNormal. 1318 * @tc.size : SmallTest 1319 * @tc.type : Function 1320 * @tc.level : Level 0 1321 */ 1322 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawImageRectWithSrcNormal, Function | SmallTest | Level0) { 1323 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1324 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1325 EXPECT_NE(canvas, nullptr); 1326 // 2. Call OH_Drawing_ImageCreate to create an image object 1327 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1328 EXPECT_NE(image, nullptr); 1329 // 3. Call OH_Drawing_RectCreate to create a rectangle object 1330 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1331 // add assert 1332 EXPECT_NE(rect, nullptr); 1333 // 4. Call OH_Drawing_RectCreate to create a rectangle object 1334 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 1335 // add assert 1336 EXPECT_NE(rect2, nullptr); 1337 // 5. Call OH_Drawing_SamplingOptionsCreate to create a sampling options object 1338 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1339 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1340 EXPECT_NE(options, nullptr); 1341 // 6. Call OH_Drawing_CanvasDrawImageRectWithSrc with the sixth parameter iterating through the enumeration 1342 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1343 // add assert 1344 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1345 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, options, FAST_SRC_RECT_CONSTRAINT); 1346 // add assert 1347 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1348 // 7. Free memory 1349 OH_Drawing_RectDestroy(rect); 1350 OH_Drawing_RectDestroy(rect2); 1351 OH_Drawing_SamplingOptionsDestroy(options); 1352 OH_Drawing_ImageDestroy(image); 1353 OH_Drawing_CanvasDestroy(canvas); 1354 } 1355 1356 /* 1357 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3701 1358 * @tc.name: testCanvasDrawImageRectWithSrcNull 1359 * @tc.desc: test for testCanvasDrawImageRectWithSrcNull. 1360 * @tc.size : SmallTest 1361 * @tc.type : Function 1362 * @tc.level : Level 3 1363 */ 1364 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawImageRectWithSrcNull, Function | SmallTest | Level3) { 1365 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1366 EXPECT_NE(canvas, nullptr); 1367 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1368 EXPECT_NE(image, nullptr); 1369 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1370 // add assert 1371 EXPECT_NE(rect, nullptr); 1372 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 1373 // add assert 1374 EXPECT_NE(rect2, nullptr); 1375 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1376 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1377 // 1. Call OH_Drawing_CanvasDrawImageRectWithSrc with the first parameter being nullptr 1378 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, image, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1379 // add assert 1380 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1381 OH_Drawing_ErrorCodeReset(); 1382 // 2. Call OH_Drawing_CanvasDrawImageRectWithSrc with the second parameter being nullptr 1383 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, nullptr, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1384 // add assert 1385 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1386 OH_Drawing_ErrorCodeReset(); 1387 // 3. Call OH_Drawing_CanvasDrawImageRectWithSrc with the third parameter being nullptr 1388 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, nullptr, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1389 // add assert 1390 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1391 OH_Drawing_ErrorCodeReset(); 1392 // 4. Call OH_Drawing_CanvasDrawImageRectWithSrc with the fourth parameter being nullptr 1393 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, nullptr, options, STRICT_SRC_RECT_CONSTRAINT); 1394 // add assert 1395 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1396 // 5. Call OH_Drawing_CanvasDrawImageRectWithSrc with the fifth parameter being nullptr 1397 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, nullptr, STRICT_SRC_RECT_CONSTRAINT); 1398 // 6. Free memory 1399 OH_Drawing_RectDestroy(rect); 1400 OH_Drawing_RectDestroy(rect2); 1401 OH_Drawing_SamplingOptionsDestroy(options); 1402 OH_Drawing_ImageDestroy(image); 1403 OH_Drawing_CanvasDestroy(canvas); 1404 } 1405 1406 /* 1407 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3800 1408 * @tc.name: testCanvasDrawImageRectNormal 1409 * @tc.desc: test for testCanvasDrawImageRectNormal. 1410 * @tc.size : SmallTest 1411 * @tc.type : Function 1412 * @tc.level : Level 0 1413 */ 1414 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawImageRectNormal, Function | SmallTest | Level0) { 1415 // 1. Create a canvas object using OH_Drawing_CanvasCreate 1416 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1417 // add assert 1418 EXPECT_NE(canvas, nullptr); 1419 // 2. Create an image object using OH_Drawing_ImageCreate 1420 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1421 // add assert 1422 EXPECT_NE(image, nullptr); 1423 // 3. Create a rectangle object using OH_Drawing_RectCreate 1424 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1425 // add assert 1426 EXPECT_NE(rect, nullptr); 1427 // 4. Create a sampling options object using OH_Drawing_SamplingOptionsCreate 1428 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1429 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1430 // add assert 1431 EXPECT_NE(options, nullptr); 1432 // 5. Call OH_Drawing_CanvasDrawImageRect 1433 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, options); 1434 // 6. Free memory 1435 OH_Drawing_RectDestroy(rect); 1436 OH_Drawing_SamplingOptionsDestroy(options); 1437 OH_Drawing_ImageDestroy(image); 1438 OH_Drawing_CanvasDestroy(canvas); 1439 } 1440 1441 /* 1442 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3801 1443 * @tc.name: testCanvasDrawImageRectNull 1444 * @tc.desc: test for testCanvasDrawImageRectNull. 1445 * @tc.size : SmallTest 1446 * @tc.type : Function 1447 * @tc.level : Level 3 1448 */ 1449 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawImageRectNull, Function | SmallTest | Level3) { 1450 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1451 // add assert 1452 EXPECT_NE(canvas, nullptr); 1453 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1454 // add assert 1455 EXPECT_NE(image, nullptr); 1456 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1457 // add assert 1458 EXPECT_NE(rect, nullptr); 1459 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1460 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1461 // add assert 1462 EXPECT_NE(options, nullptr); 1463 // 1. Call OH_Drawing_CanvasDrawImageRect with the first parameter as null 1464 OH_Drawing_CanvasDrawImageRect(nullptr, image, rect, options); 1465 // add assert 1466 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1467 OH_Drawing_ErrorCodeReset(); 1468 // 2. Call OH_Drawing_CanvasDrawImageRect with the second parameter as null 1469 OH_Drawing_CanvasDrawImageRect(canvas, nullptr, rect, options); 1470 // add assert 1471 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1472 OH_Drawing_ErrorCodeReset(); 1473 // 3. Call OH_Drawing_CanvasDrawImageRect with the third parameter as null 1474 OH_Drawing_CanvasDrawImageRect(canvas, image, nullptr, options); 1475 // add assert 1476 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1477 // 4. Call OH_Drawing_CanvasDrawImageRect with the fourth parameter as null 1478 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, nullptr); 1479 // 5. Free memory 1480 OH_Drawing_RectDestroy(rect); 1481 OH_Drawing_SamplingOptionsDestroy(options); 1482 OH_Drawing_ImageDestroy(image); 1483 OH_Drawing_CanvasDestroy(canvas); 1484 } 1485 1486 /* 1487 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3900 1488 * @tc.name: testCanvasDrawVerticesNormal 1489 * @tc.desc: test for testCanvasDrawVerticesNormal. 1490 * @tc.size : SmallTest 1491 * @tc.type : Function 1492 * @tc.level : Level 0 1493 */ 1494 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawVerticesNormal, Function | SmallTest | Level0) { 1495 OH_Drawing_Point2D point_one = {0, 0}; 1496 OH_Drawing_Point2D point_two = {100, 100}; 1497 OH_Drawing_Point2D point_three = {300, 100}; 1498 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1499 1500 OH_Drawing_Point2D texs_one = {0, 0}; 1501 OH_Drawing_Point2D texs_two = {1, 1}; 1502 OH_Drawing_Point2D texs_three = {2, 0}; 1503 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1504 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1505 uint16_t indices[3] = {0, 1, 2}; 1506 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1507 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1508 // add assert 1509 EXPECT_NE(canvas, nullptr); 1510 // 2. Call OH_Drawing_CanvasDrawVertices with the second parameter iterating through the enum 1511 OH_Drawing_VertexMode mode[] = {VERTEX_MODE_TRIANGLES, VERTEX_MODE_TRIANGLES_STRIP, VERTEX_MODE_TRIANGLE_FAN}; 1512 for (int i = 0; i < 3; i++) { 1513 OH_Drawing_ErrorCodeReset(); 1514 OH_Drawing_CanvasDrawVertices(canvas, mode[i], 3, points_vertices, texs_vertices, colors, 3, indices, 1515 BLEND_MODE_COLOR); 1516 // add assert 1517 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1518 } 1519 // 3. Call OH_Drawing_CanvasDrawVertices with the ninth parameter iterating through the enum 1520 OH_Drawing_BlendMode blendMode[] = { 1521 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1522 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1523 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 1524 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 1525 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 1526 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 1527 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 1528 BLEND_MODE_LUMINOSITY, 1529 }; 1530 for (int i = 0; i < 29; i++) { 1531 OH_Drawing_ErrorCodeReset(); 1532 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, 1533 indices, blendMode[i]); 1534 // add assert 1535 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1536 } 1537 // 4. Free memory 1538 OH_Drawing_CanvasDestroy(canvas); 1539 } 1540 1541 /* 1542 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3901 1543 * @tc.name: testCanvasDrawVerticesNull 1544 * @tc.desc: test for testCanvasDrawVerticesNull. 1545 * @tc.size : SmallTest 1546 * @tc.type : Function 1547 * @tc.level : Level 3 1548 */ 1549 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawVerticesNull, Function | SmallTest | Level3) { 1550 OH_Drawing_Point2D point_one = {0, 0}; 1551 OH_Drawing_Point2D point_two = {100, 100}; 1552 OH_Drawing_Point2D point_three = {300, 100}; 1553 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1554 1555 OH_Drawing_Point2D texs_one = {0, 0}; 1556 OH_Drawing_Point2D texs_two = {1, 1}; 1557 OH_Drawing_Point2D texs_three = {2, 0}; 1558 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1559 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1560 uint16_t indices[3] = {0, 1, 2}; 1561 1562 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1563 // add assert 1564 EXPECT_NE(canvas, nullptr); 1565 1566 // 1. Call OH_Drawing_CanvasDrawVertices with the first parameter as nullptr 1567 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, indices, 1568 BLEND_MODE_COLOR); 1569 // add assert 1570 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1571 OH_Drawing_ErrorCodeReset(); 1572 // 2. Call OH_Drawing_CanvasDrawVertices with the third parameter as 0 1573 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 0, points_vertices, texs_vertices, colors, 3, indices, 1574 BLEND_MODE_COLOR); 1575 // add assert 1576 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1577 OH_Drawing_ErrorCodeReset(); 1578 // 3. Call OH_Drawing_CanvasDrawVertices with the fourth parameter as nullptr 1579 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, nullptr, texs_vertices, colors, 3, indices, 1580 BLEND_MODE_COLOR); 1581 // add assert 1582 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1583 // 4. Call OH_Drawing_CanvasDrawVertices with the fifth parameter as nullptr 1584 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, nullptr, colors, 3, indices, 1585 BLEND_MODE_COLOR); 1586 // 5. Call OH_Drawing_CanvasDrawVertices with the sixth parameter as nullptr 1587 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, nullptr, 3, indices, 1588 BLEND_MODE_COLOR); 1589 // 6. Call OH_Drawing_CanvasDrawVertices with the seventh parameter as 0 1590 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 0, indices, 1591 BLEND_MODE_COLOR); 1592 // 7. Call OH_Drawing_CanvasDrawVertices with the eighth parameter as nullptr 1593 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, nullptr, 1594 BLEND_MODE_COLOR); 1595 // 8. Free memory 1596 OH_Drawing_CanvasDestroy(canvas); 1597 } 1598 1599 /* 1600 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3902 1601 * @tc.name: testCanvasDrawVerticesAbnormal 1602 * @tc.desc: test for testCanvasDrawVerticesAbnormal. 1603 * @tc.size : SmallTest 1604 * @tc.type : Function 1605 * @tc.level : Level 3 1606 */ 1607 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawVerticesAbnormal, Function | SmallTest | Level3) { 1608 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1609 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1610 // add assert 1611 EXPECT_NE(canvas, nullptr); 1612 1613 // 2. Call OH_Drawing_CanvasDrawVertices with a floating-point number as the third parameter 1614 // Compilation error, cannot pass a floating-point number 1615 1616 // 3. Call OH_Drawing_CanvasDrawVertices with a floating-point number as the seventh parameter 1617 // Compilation error, cannot pass a floating-point number 1618 1619 // 4. Free memory 1620 OH_Drawing_CanvasDestroy(canvas); 1621 } 1622 1623 /* 1624 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3903 1625 * @tc.name: testCanvasDrawVerticesMaximum 1626 * @tc.desc: test for testCanvasDrawVerticesMaximum. 1627 * @tc.size : SmallTest 1628 * @tc.type : Function 1629 * @tc.level : Level 3 1630 */ 1631 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawVerticesMaximum, Function | SmallTest | Level3) { 1632 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1633 OH_Drawing_Point2D point_one = {0, 0}; 1634 OH_Drawing_Point2D point_two = {100, 100}; 1635 OH_Drawing_Point2D point_three = {300, 100}; 1636 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1637 1638 OH_Drawing_Point2D texs_one = {0, 0}; 1639 OH_Drawing_Point2D texs_two = {1, 1}; 1640 OH_Drawing_Point2D texs_three = {2, 0}; 1641 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1642 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1643 uint16_t indices[3] = {0, 1, 2}; 1644 1645 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1646 // add assert 1647 EXPECT_NE(canvas, nullptr); 1648 1649 if (0) { 1650 // todo cpp crash 1651 // 2. Call OH_Drawing_CanvasDrawVertices with the third parameter as the maximum value 0x7FFFFFFF 1652 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 0x7FFFFFFF, points_vertices, texs_vertices, colors, 1653 3, indices, BLEND_MODE_COLOR); 1654 // 3. Call OH_Drawing_CanvasDrawVertices with the seventh parameter as the maximum value 0x7FFFFFFF 1655 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 1656 0x7FFFFFFF, indices, BLEND_MODE_COLOR); 1657 } 1658 1659 // 4. Free memory 1660 OH_Drawing_CanvasDestroy(canvas); 1661 } 1662 1663 /* 1664 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4000 1665 * @tc.name: testCanvasReadPixelsNormal 1666 * @tc.desc: test for testCanvasReadPixelsNormal. 1667 * @tc.size : SmallTest 1668 * @tc.type : Function 1669 * @tc.level : Level 0 1670 */ 1671 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsNormal, Function | SmallTest | Level0) { 1672 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1673 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1674 // add assert 1675 EXPECT_NE(canvas, nullptr); 1676 // 2. Call OH_Drawing_CanvasReadPixels 1677 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1678 // add assert 1679 EXPECT_NE(bitmap, nullptr); 1680 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1681 constexpr uint32_t width = 200; 1682 constexpr uint32_t height = 200; 1683 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1684 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1685 OH_Drawing_Image_Info imageInfo; 1686 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0); 1687 // add assert 1688 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1689 // 3. Free memory 1690 OH_Drawing_BitmapDestroy(bitmap); 1691 OH_Drawing_CanvasDestroy(canvas); 1692 } 1693 1694 /* 1695 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4001 1696 * @tc.name: testCanvasReadPixelsNull 1697 * @tc.desc: test for testCanvasReadPixelsNull. 1698 * @tc.size : SmallTest 1699 * @tc.type : Function 1700 * @tc.level : Level 3 1701 */ 1702 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsNull, Function | SmallTest | Level3) { 1703 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1704 // add assert 1705 EXPECT_NE(canvas, nullptr); 1706 // 1. Call OH_Drawing_CanvasReadPixels with the first parameter as nullptr 1707 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1708 // add assert 1709 EXPECT_NE(bitmap, nullptr); 1710 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1711 constexpr uint32_t width = 200; 1712 constexpr uint32_t height = 200; 1713 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1714 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1715 OH_Drawing_Image_Info imageInfo; 1716 OH_Drawing_CanvasReadPixels(nullptr, &imageInfo, pixels, 0, 0, 0); 1717 // add assert 1718 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1719 OH_Drawing_ErrorCodeReset(); 1720 // 2. Call OH_Drawing_CanvasReadPixels with the second parameter as nullptr 1721 OH_Drawing_CanvasReadPixels(canvas, nullptr, pixels, 0, 0, 0); 1722 // add assert 1723 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1724 OH_Drawing_ErrorCodeReset(); 1725 // 3. Call OH_Drawing_CanvasReadPixels with the third parameter as nullptr 1726 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, nullptr, 0, 0, 0); 1727 // add assert 1728 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1729 // 4. Free memory 1730 OH_Drawing_BitmapDestroy(bitmap); 1731 OH_Drawing_CanvasDestroy(canvas); 1732 } 1733 1734 /* 1735 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4002 1736 * @tc.name: testCanvasReadPixelsMismatch 1737 * @tc.desc: test for testCanvasReadPixelsMismatch. 1738 * @tc.size : SmallTest 1739 * @tc.type : Function 1740 * @tc.level : Level 3 1741 */ 1742 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsMismatch, Function | SmallTest | Level3) { 1743 // Deprecated 1744 } 1745 1746 /* 1747 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4003 1748 * @tc.name: testCanvasReadPixelsAbnormal 1749 * @tc.desc: test for testCanvasReadPixelsAbnormal. 1750 * @tc.size : SmallTest 1751 * @tc.type : Function 1752 * @tc.level : Level 3 1753 */ 1754 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsAbnormal, Function | SmallTest | Level3) { 1755 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1756 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1757 // add assert 1758 EXPECT_NE(canvas, nullptr); 1759 // 2. Call OH_Drawing_CanvasReadPixels with the fourth parameter as a negative number or a floating-point number 1760 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1761 // add assert 1762 EXPECT_NE(bitmap, nullptr); 1763 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1764 constexpr uint32_t width = 200; 1765 constexpr uint32_t height = 200; 1766 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1767 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1768 OH_Drawing_Image_Info imageInfo; 1769 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, -1, 0, 0); 1770 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 1.0f, 0, 0); 1771 // 3. Call OH_Drawing_CanvasReadPixels with the fifth parameter as a floating-point number 1772 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 1.0f, 0); 1773 // 4. Call OH_Drawing_CanvasReadPixels with the sixth parameter as a floating-point number 1774 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 1.0f); 1775 // 5. Free memory 1776 OH_Drawing_BitmapDestroy(bitmap); 1777 OH_Drawing_CanvasDestroy(canvas); 1778 } 1779 1780 /* 1781 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4004 1782 * @tc.name: testCanvasReadPixelsMaximum 1783 * @tc.desc: test for testCanvasReadPixelsMaximum. 1784 * @tc.size : SmallTest 1785 * @tc.type : Function 1786 * @tc.level : Level 3 1787 */ 1788 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsMaximum, Function | SmallTest | Level3) { 1789 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1790 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1791 // add assert 1792 EXPECT_NE(canvas, nullptr); 1793 // 2. Call OH_Drawing_CanvasReadPixels with the fourth parameter as the maximum value 0xFFFFFFFF 1794 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1795 // add assert 1796 EXPECT_NE(bitmap, nullptr); 1797 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1798 constexpr uint32_t width = 200; 1799 constexpr uint32_t height = 200; 1800 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1801 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1802 OH_Drawing_Image_Info imageInfo; 1803 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0xFFFFFFFF, 0, 0); 1804 // 3. Call OH_Drawing_CanvasReadPixels with the fifth parameter as the maximum value 0x7FFFFFFF 1805 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0x7FFFFFFF, 0); 1806 // 4. Call OH_Drawing_CanvasReadPixels with the sixth parameter as the maximum value 0x7FFFFFFF 1807 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0x7FFFFFFF); 1808 // 5. Free memory 1809 OH_Drawing_BitmapDestroy(bitmap); 1810 OH_Drawing_CanvasDestroy(canvas); 1811 } 1812 1813 /* 1814 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4005 1815 * @tc.name: testCanvasReadPixelsBoundary 1816 * @tc.desc: test for testCanvasReadPixelsBoundary. 1817 * @tc.size : SmallTest 1818 * @tc.type : Function 1819 * @tc.level : Level 0 1820 */ 1821 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsBoundary, Function | SmallTest | Level0) { 1822 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1823 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1824 // add assert 1825 EXPECT_NE(canvas, nullptr); 1826 // 2. Call OH_Drawing_CanvasReadPixels 1827 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1828 // add assert 1829 EXPECT_NE(bitmap, nullptr); 1830 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1831 constexpr uint32_t width = 4096; 1832 constexpr uint32_t height = 2160; 1833 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1834 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1835 OH_Drawing_Image_Info imageInfo; 1836 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0); 1837 // 3. Free memory 1838 OH_Drawing_BitmapDestroy(bitmap); 1839 OH_Drawing_CanvasDestroy(canvas); 1840 } 1841 1842 /* 1843 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4100 1844 * @tc.name: testCanvasReadPixelsToBitmapNormal 1845 * @tc.desc: test for testCanvasReadPixelsToBitmapNormal. 1846 * @tc.size : SmallTest 1847 * @tc.type : Function 1848 * @tc.level : Level 0 1849 */ 1850 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsToBitmapNormal, Function | SmallTest | Level0) { 1851 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1852 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1853 // add assert 1854 EXPECT_NE(canvas, nullptr); 1855 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1856 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1857 // add assert 1858 EXPECT_NE(bitmap, nullptr); 1859 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap 1860 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 1); 1861 // add assert 1862 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1863 // 4. Free memory 1864 OH_Drawing_BitmapDestroy(bitmap); 1865 OH_Drawing_CanvasDestroy(canvas); 1866 } 1867 1868 /* 1869 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4101 1870 * @tc.name: testCanvasReadPixelsToBitmapNull 1871 * @tc.desc: test for testCanvasReadPixelsToBitmapNull. 1872 * @tc.size : SmallTest 1873 * @tc.type : Function 1874 * @tc.level : Level 3 1875 */ 1876 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsToBitmapNull, Function | SmallTest | Level3) { 1877 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1878 // add assert 1879 EXPECT_NE(canvas, nullptr); 1880 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1881 // add assert 1882 EXPECT_NE(bitmap, nullptr); 1883 // 1. Call OH_Drawing_CanvasReadPixelsToBitmap with the first parameter as null 1884 OH_Drawing_CanvasReadPixelsToBitmap(nullptr, bitmap, 1, 1); 1885 // add assert 1886 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1887 OH_Drawing_ErrorCodeReset(); 1888 // 2. Call OH_Drawing_CanvasReadPixelsToBitmap with the second parameter as null 1889 OH_Drawing_CanvasReadPixelsToBitmap(canvas, nullptr, 1, 1); 1890 // add assert 1891 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1892 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter as 0 1893 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 0, 1); 1894 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter as 0 1895 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 0); 1896 // 5. Free memory 1897 OH_Drawing_BitmapDestroy(bitmap); 1898 OH_Drawing_CanvasDestroy(canvas); 1899 } 1900 1901 /* 1902 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4102 1903 * @tc.name: testCanvasReadPixelsToBitmapAbnormal 1904 * @tc.desc: test for testCanvasReadPixelsToBitmapAbnormal. 1905 * @tc.size : SmallTest 1906 * @tc.type : Function 1907 * @tc.level : Level 3 1908 */ 1909 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsToBitmapAbnormal, Function | SmallTest | Level3) { 1910 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1911 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1912 // add assert 1913 EXPECT_NE(canvas, nullptr); 1914 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1915 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1916 // add assert 1917 EXPECT_NE(bitmap, nullptr); 1918 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter as a floating-point number 1919 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1.0f, 0); 1920 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter as a floating-point number 1921 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 1.0f); 1922 // 5. Free memory 1923 OH_Drawing_BitmapDestroy(bitmap); 1924 OH_Drawing_CanvasDestroy(canvas); 1925 } 1926 1927 /* 1928 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4103 1929 * @tc.name: testCanvasReadPixelsToBitmapMaximum 1930 * @tc.desc: test for testCanvasReadPixelsToBitmapMaximum. 1931 * @tc.size : SmallTest 1932 * @tc.type : Function 1933 * @tc.level : Level 3 1934 */ 1935 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasReadPixelsToBitmapMaximum, Function | SmallTest | Level3) { 1936 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1937 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1938 // add assert 1939 EXPECT_NE(canvas, nullptr); 1940 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1941 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1942 // add assert 1943 EXPECT_NE(bitmap, nullptr); 1944 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter set to the maximum value 0x7FFFFFFF 1945 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 0x7FFFFFFF, 0); 1946 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter set to the maximum value 0x7FFFFFFF 1947 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 0x7FFFFFFF); 1948 // 5. Free memory 1949 OH_Drawing_BitmapDestroy(bitmap); 1950 OH_Drawing_CanvasDestroy(canvas); 1951 } 1952 /* 1953 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4104 1954 * @tc.name: testCanvasDrawSingleCharacter 1955 * @tc.desc: test for testCanvasDrawSingleCharacter. 1956 * @tc.size : SmallTest 1957 * @tc.type : Function 1958 * @tc.level : Level 1 1959 */ 1960 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawSingleCharacter, Function | SmallTest | Level1) 1961 { 1962 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1963 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1964 // add assert 1965 EXPECT_NE(canvas, nullptr); 1966 const char* strOne = "a"; 1967 const char* strTwo = "你好"; 1968 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1969 EXPECT_NE(font, nullptr); 1970 float x = 0.f; 1971 float y = 0.f; 1972 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strOne, font, x, y), OH_DRAWING_SUCCESS); 1973 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strTwo, font, x, y), OH_DRAWING_SUCCESS); 1974 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(nullptr, strOne, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1975 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, nullptr, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1976 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strOne, nullptr, x, y), 1977 OH_DRAWING_ERROR_INVALID_PARAMETER); 1978 const char* strThree = ""; 1979 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strThree, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1980 OH_Drawing_FontDestroy(font); 1981 OH_Drawing_CanvasDestroy(canvas); 1982 } 1983 1984 /* 1985 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4200 1986 * @tc.name: testCanvasDrawSingleCharacterNormal 1987 * @tc.desc: test for testCanvasDrawSingleCharacterNormal. 1988 * @tc.size : SmallTest 1989 * @tc.type : Function 1990 * @tc.level : Level 0 1991 */ 1992 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawSingleCharacterNormal, Function | SmallTest | Level0) { 1993 //1. OH_Drawing_CanvasCreate 1994 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1995 // add assert 1996 EXPECT_NE(canvas, nullptr); 1997 //2. OH_Drawing_BrushCreate 1998 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1999 // add assert 2000 EXPECT_NE(brush, nullptr); 2001 //3. OH_Drawing_BrushSetColor 2002 OH_Drawing_BrushSetColor(brush, 0xFFFFFFFF); 2003 //4. OH_Drawing_FontCreate 2004 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 2005 // add assert 2006 EXPECT_NE(font, nullptr); 2007 //5. OH_Drawing_FontSetTextSize 2008 const float textSize = 10.f; 2009 OH_Drawing_FontSetTextSize(font, textSize); 2010 //6. OH_Drawing_CanvasDrawSingleCharacter parameter is normal, where str is a single character,UTF-8 encoded, and 2011 // Chinese/English characters are passed 2012 float x = 0.f; 2013 float y = 0.f; 2014 const char* str = "a"; 2015 const char* str1 = "我"; 2016 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 2017 OH_Drawing_CanvasDrawSingleCharacter(canvas, str1, font, x, y); 2018 //7. OH_Drawing_CanvasDrawSingleCharacter parameters are entered normally, where str is a multi-character, UTF-8 2019 // encoded, and English/Chinese characters are in 2020 str = "abc"; 2021 str1 = "你是谁"; 2022 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 2023 OH_Drawing_CanvasDrawSingleCharacter(canvas, str1, font, x, y); 2024 //8. free memory 2025 OH_Drawing_CanvasDestroy(canvas); 2026 OH_Drawing_BrushDestroy(brush); 2027 OH_Drawing_FontDestroy(font); 2028 } 2029 2030 /* 2031 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4201 2032 * @tc.name: testCanvasDrawSingleCharacterNull 2033 * @tc.desc: test for testCanvasDrawSingleCharacterNull. 2034 * @tc.size : SmallTest 2035 * @tc.type : Function 2036 * @tc.level : Level 3 2037 */ 2038 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawSingleCharacterNull, Function | SmallTest | Level3) { 2039 //1. OH_Drawing_CanvasCreate 2040 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2041 // add assert 2042 EXPECT_NE(canvas, nullptr); 2043 //2. OH_Drawing_BrushCreate 2044 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 2045 // add assert 2046 EXPECT_NE(brush, nullptr); 2047 //3. OH_Drawing_BrushSetColor 2048 OH_Drawing_BrushSetColor(brush, 0xFFFFFFFF); 2049 //4. OH_Drawing_FontCreate 2050 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 2051 // add assert 2052 EXPECT_NE(font, nullptr); 2053 //5. OH_Drawing_FontSetTextSize 2054 const float textSize = 10.f; 2055 OH_Drawing_FontSetTextSize(font, textSize); 2056 //6. OH_Drawing_CanvasDrawSingleCharacter parameter canvas is empty 2057 float x = 0.f; 2058 float y = 0.f; 2059 const char *str = "a"; 2060 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(nullptr, str, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 2061 //7. OH_Drawing_CanvasDrawSingleCharacter parameter str is empty 2062 str = ""; 2063 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 2064 //8. OH_Drawing_CanvasDrawSingleCharacter parameter font is empty 2065 str = "a"; 2066 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, str, nullptr, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 2067 //9. OH_Drawing_CanvasDrawSingleCharacter parameter str to 0 characters 2068 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 2069 //10.free memory 2070 OH_Drawing_CanvasDestroy(canvas); 2071 OH_Drawing_BrushDestroy(brush); 2072 OH_Drawing_FontDestroy(font); 2073 } 2074 2075 /* 2076 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4300 2077 * @tc.name: testCanvasDrawPointNormal 2078 * @tc.desc: test for testCanvasDrawPointNormal. 2079 * @tc.size : SmallTest 2080 * @tc.type : Function 2081 * @tc.level : Level 0 2082 */ 2083 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawPointNormal, Function | SmallTest | Level0) { 2084 //1. OH_Drawing_CanvasCreate 2085 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2086 // add assert 2087 EXPECT_NE(canvas, nullptr); 2088 //2. OH_Drawing_Point2D create an array of points 2089 OH_Drawing_Point2D texs_one = {0.0f, 0.0f}; 2090 OH_Drawing_Point2D texs_two = {1.0f, 1.0f}; 2091 OH_Drawing_Point2D texs_three = {2.0f, 2.0f}; 2092 OH_Drawing_Point2D point_vertices[1] = {texs_one}; 2093 for (int i = 0; i < 1; i++) { 2094 OH_Drawing_CanvasDrawPoint(canvas, &point_vertices[i]); 2095 } 2096 //3. OH_Drawing_Point2D create an array of multiple points 2097 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 2098 for (int i = 0; i < 3; i++) { 2099 OH_Drawing_CanvasDrawPoint(canvas, &texs_vertices[i]); 2100 } 2101 //4. free memory 2102 OH_Drawing_CanvasDestroy(canvas); 2103 } 2104 2105 /* 2106 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4301 2107 * @tc.name: testCanvasDrawPointNull 2108 * @tc.desc: test for testCanvasDrawPointNull. 2109 * @tc.size : SmallTest 2110 * @tc.type : Function 2111 * @tc.level : Level 3 2112 */ 2113 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawPointNull, Function | SmallTest | Level3) { 2114 //1. OH_Drawing_CanvasCreate 2115 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2116 // add assert 2117 EXPECT_NE(canvas, nullptr); 2118 //2. OH_Drawing_CanvasDrawPoint the first parameter is empty 2119 const OH_Drawing_Point2D point = {0.0f, 0.0f}; 2120 // add assert 2121 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(nullptr, &point), OH_DRAWING_ERROR_INVALID_PARAMETER); 2122 //3. OH_Drawing_CanvasDrawPoint the second parameter is empty 2123 // add assert 2124 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(canvas, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 2125 //4.free memory 2126 OH_Drawing_CanvasDestroy(canvas); 2127 } 2128 2129 /* 2130 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4302 2131 * @tc.name: testCanvasDrawPointMultipleCalls 2132 * @tc.desc: test for testCanvasDrawPointMultipleCalls. 2133 * @tc.size : SmallTest 2134 * @tc.type : Function 2135 * @tc.level : Level 3 2136 */ 2137 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawPointMultipleCalls, Function | SmallTest | Level3) { 2138 //1. OH_Drawing_CanvasCreate 2139 OH_Drawing_Canvas *canvases[10]; 2140 for (int i = 0; i < 10; i++) { 2141 canvases[i]= OH_Drawing_CanvasCreate(); 2142 // add assert 2143 EXPECT_NE(canvases[i], nullptr); 2144 } 2145 //2. Call OH_Drawing_CanvasDrawPoint 10 times 2146 OH_Drawing_Point2D point1 = {0.0f, 0.0f}; 2147 for (int i = 0; i < 10; i++) { 2148 OH_Drawing_CanvasDrawPoint(canvases[i], &point1); 2149 } 2150 } 2151 2152 /* 2153 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4400 2154 * @tc.name: testCanvasDrawColorNormal 2155 * @tc.desc: test for testCanvasDrawColorNormal. 2156 * @tc.size : SmallTest 2157 * @tc.type : Function 2158 * @tc.level : Level 0 2159 */ 2160 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawColorNormal, Function | SmallTest | Level0) { 2161 //1. OH_Drawing_CanvasCreate 2162 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2163 // add assert 2164 EXPECT_NE(canvas, nullptr); 2165 //2. OH_Drawing_CanvasDrawColor enumeration traversal 2166 uint32_t color[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 2167 OH_Drawing_BlendMode blendMode[] = { 2168 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 2169 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 2170 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 2171 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 2172 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 2173 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 2174 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 2175 BLEND_MODE_LUMINOSITY, 2176 }; 2177 for (int i = 0; i < 29; i++) { 2178 for (int j = 0; j < 3; j++) { 2179 OH_Drawing_CanvasDrawColor(canvas, color[j], blendMode[i]); 2180 } 2181 } 2182 } 2183 2184 /* 2185 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4401 2186 * @tc.name: testCanvasDrawColorNull 2187 * @tc.desc: test for testCanvasDrawColorNull. 2188 * @tc.size : SmallTest 2189 * @tc.type : Function 2190 * @tc.level : Level 3 2191 */ 2192 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawColorNull, Function | SmallTest | Level3) { 2193 //1. OH_Drawing_CanvasCreate 2194 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2195 // add assert 2196 EXPECT_NE(canvas, nullptr); 2197 //2. OH_Drawing_CanvasDrawColor with the first parameter as nullptr 2198 OH_Drawing_BlendMode blendMode[] = { 2199 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 2200 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 2201 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 2202 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 2203 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 2204 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 2205 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 2206 BLEND_MODE_LUMINOSITY, 2207 }; 2208 uint32_t color = 0xFFFF0000; 2209 for (int i = 0; i < 29; i++) { 2210 // add assert 2211 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, color, blendMode[i]), OH_DRAWING_ERROR_INVALID_PARAMETER); 2212 } 2213 //3. OH_Drawing_CanvasDrawColor with the first parameter as 0 2214 for (int i = 0; i < 29; i++) { 2215 OH_Drawing_CanvasDrawColor(canvas, 0, blendMode[i]); 2216 } 2217 //4. free memory 2218 OH_Drawing_CanvasDestroy(canvas); 2219 } 2220 2221 /* 2222 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4402 2223 * @tc.name: testCanvasDrawColorMaximum 2224 * @tc.desc: test for testCanvasDrawColorMaximum. 2225 * @tc.size : SmallTest 2226 * @tc.type : Function 2227 * @tc.level : Level 3 2228 */ 2229 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawColorMaximum, Function | SmallTest | Level3) { 2230 //1. OH_Drawing_CanvasCreate 2231 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2232 // add assert 2233 EXPECT_NE(canvas, nullptr); 2234 //2. OH_Drawing_CanvasDrawColor with the second parameter set to the maximum value 2235 OH_Drawing_BlendMode blendMode[] = { 2236 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 2237 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 2238 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 2239 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 2240 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 2241 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 2242 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 2243 BLEND_MODE_LUMINOSITY, 2244 }; 2245 uint32_t color = 0x00000000; 2246 for (int i = 0; i < 29; i++) { 2247 // add assert 2248 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, color, blendMode[i]), OH_DRAWING_ERROR_INVALID_PARAMETER); 2249 } 2250 //3. free memory 2251 OH_Drawing_CanvasDestroy(canvas); 2252 } 2253 2254 /* 2255 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4403 2256 * @tc.name: testCanvasDrawColorMultipleCalls 2257 * @tc.desc: test for testCanvasDrawColorMultipleCalls. 2258 * @tc.size : SmallTest 2259 * @tc.type : Function 2260 * @tc.level : Level 3 2261 */ 2262 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasDrawColorMultipleCalls, Function | SmallTest | Level3) { 2263 //1. OH_Drawing_CanvasCreate 2264 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2265 // add assert 2266 EXPECT_NE(canvas, nullptr); 2267 //2. Call OH_Drawing_CanvasDrawColor 10 times 2268 uint32_t color = 0xFFFF0000; 2269 OH_Drawing_BlendMode blendMode[] = { 2270 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 2271 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 2272 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, 2273 }; 2274 for (int i = 0; i < 10; i++) { 2275 OH_Drawing_CanvasDrawColor(canvas, color, blendMode[i]); 2276 } 2277 //3. free memory 2278 OH_Drawing_CanvasDestroy(canvas); 2279 } 2280 2281 /* 2282 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4500 2283 * @tc.name: testCanvasIsClipEmptyNormal 2284 * @tc.desc: test for testCanvasIsClipEmptyNormal. 2285 * @tc.size : SmallTest 2286 * @tc.type : Function 2287 * @tc.level : Level 0 2288 */ 2289 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasIsClipEmptyNormal, Function | SmallTest | Level0) { 2290 //1. OH_Drawing_RectCreate 2291 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2292 // add assert 2293 EXPECT_NE(canvas, nullptr); 2294 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2295 // add assert 2296 EXPECT_NE(rect, nullptr); 2297 //2. OH_Drawing_RoundRectCreate 2298 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 2299 // add assert 2300 EXPECT_NE(roundRect, nullptr); 2301 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 2302 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2303 bool doAntiAlias[] = {true, false}; 2304 for (int i = 0; i < 2; i++) { 2305 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 2306 } 2307 //4. OH_Drawing_CanvasIsClipEmpty 2308 bool isClipEmpty[] = {true, false}; 2309 for (int i = 0; i < 2; i++) { 2310 OH_Drawing_CanvasIsClipEmpty(canvas, &isClipEmpty[i]); 2311 } 2312 //5. free memory 2313 OH_Drawing_CanvasDestroy(canvas); 2314 OH_Drawing_RectDestroy(rect); 2315 OH_Drawing_RoundRectDestroy(roundRect); 2316 } 2317 2318 /* 2319 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4501 2320 * @tc.name: testCanvasIsClipEmptyNull 2321 * @tc.desc: test for testCanvasIsClipEmptyNull. 2322 * @tc.size : SmallTest 2323 * @tc.type : Function 2324 * @tc.level : Level 3 2325 */ 2326 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasIsClipEmptyNull, Function | SmallTest | Level3) { 2327 //1. OH_Drawing_RectCreate 2328 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2329 // add assert 2330 EXPECT_NE(canvas, nullptr); 2331 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2332 // add assert 2333 EXPECT_NE(rect, nullptr); 2334 //2. OH_Drawing_RoundRectCreate 2335 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 2336 // add assert 2337 EXPECT_NE(roundRect, nullptr); 2338 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 2339 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2340 bool doAntiAlias[] = {true, false}; 2341 for (int i = 0; i < 2; i++) { 2342 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 2343 } 2344 //4. OH_Drawing_CanvasIsClipEmpty with the first parameter as null 2345 bool isClipEmpty[] = {true, false}; 2346 for (int i = 0; i < 2; i++) { 2347 // add assert 2348 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(nullptr, &isClipEmpty[i]), OH_DRAWING_ERROR_INVALID_PARAMETER); 2349 } 2350 //5. OH_Drawing_CanvasIsClipEmpty with the second parameter as null 2351 // add assert 2352 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 2353 //6. free memory 2354 OH_Drawing_CanvasDestroy(canvas); 2355 OH_Drawing_RectDestroy(rect); 2356 OH_Drawing_RoundRectDestroy(roundRect); 2357 } 2358 2359 /* 2360 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4502 2361 * @tc.name: testCanvasIsClipEmptyMultipleCalls 2362 * @tc.desc: test for testCanvasIsClipEmptyMultipleCalls. 2363 * @tc.size : SmallTest 2364 * @tc.type : Function 2365 * @tc.level : Level 3 2366 */ 2367 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasIsClipEmptyMultipleCalls, Function | SmallTest | Level3) { 2368 //1. OH_Drawing_RectCreate 2369 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2370 // add assert 2371 EXPECT_NE(canvas, nullptr); 2372 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2373 // add assert 2374 EXPECT_NE(rect, nullptr); 2375 //2. OH_Drawing_RoundRectCreate 2376 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 2377 // add assert 2378 EXPECT_NE(roundRect, nullptr); 2379 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 2380 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2381 bool doAntiAlias[] = {true, false}; 2382 for (int i = 0; i < 2; i++) { 2383 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 2384 } 2385 //4. Call OH_Drawing_CanvasIsClipEmpty 10 times 2386 bool isClipEmpty = true; 2387 OH_Drawing_Canvas *canvases[10]; 2388 for (int i = 0; i < 10; i++) { 2389 canvases[i]= OH_Drawing_CanvasCreate(); 2390 } 2391 for (int i = 0; i < 10; i++) { 2392 OH_Drawing_CanvasIsClipEmpty(canvases[i], &isClipEmpty); 2393 } 2394 //5. free memory 2395 OH_Drawing_CanvasDestroy(canvas); 2396 for (int i = 0; i < 10; i++) { 2397 OH_Drawing_CanvasDestroy(canvases[i]); 2398 } 2399 OH_Drawing_RectDestroy(rect); 2400 OH_Drawing_RoundRectDestroy(roundRect); 2401 } 2402 2403 /* 2404 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4600 2405 * @tc.name: testCanvasGetImageInfoNormal 2406 * @tc.desc: test for testCanvasGetImageInfoNormal. 2407 * @tc.size : SmallTest 2408 * @tc.type : Function 2409 * @tc.level : Level 0 2410 */ 2411 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetImageInfoNormal, Function | SmallTest | Level0) { 2412 //1. OH_Drawing_BitmapCreate 2413 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 2414 // add assert 2415 EXPECT_NE(bitmap, nullptr); 2416 //2. OH_Drawing_BitmapGetPixels 2417 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 2418 //3. OH_Drawing_BitmapBuild 2419 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2420 constexpr uint32_t width = 200; 2421 constexpr uint32_t height = 200; 2422 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2423 //4. OH_Drawing_BitmapCreateFromPixels 2424 const uint32_t bytesPerPixel = 3; 2425 const uint32_t padding = 32; 2426 const uint32_t rowBytes = width * bytesPerPixel + padding; 2427 OH_Drawing_Image_Info imageInfo; 2428 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2429 // add assert 2430 EXPECT_EQ(frompixels, (nullptr)); 2431 //5. OH_Drawing_CanvasBind 2432 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2433 // add assert 2434 EXPECT_NE(canvas, nullptr); 2435 OH_Drawing_CanvasBind(canvas, bitmap); 2436 //6. OH_Drawing_CanvasGetImageInfo 2437 OH_Drawing_CanvasGetImageInfo(canvas, &imageInfo); 2438 //7. free memory 2439 OH_Drawing_CanvasDestroy(canvas); 2440 OH_Drawing_BitmapDestroy(bitmap); 2441 OH_Drawing_BitmapDestroy(frompixels); 2442 } 2443 2444 /* 2445 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4601 2446 * @tc.name: testCanvasGetImageInfoNull 2447 * @tc.desc: test for testCanvasGetImageInfoNull. 2448 * @tc.size : SmallTest 2449 * @tc.type : Function 2450 * @tc.level : Level 3 2451 */ 2452 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetImageInfoNull, Function | SmallTest | Level3) { 2453 //1. OH_Drawing_BitmapCreate 2454 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 2455 // add assert 2456 EXPECT_NE(bitmap, nullptr); 2457 //2. OH_Drawing_BitmapGetPixels 2458 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 2459 //3. OH_Drawing_BitmapBuild 2460 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2461 constexpr uint32_t width = 200; 2462 constexpr uint32_t height = 200; 2463 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2464 //4. OH_Drawing_BitmapCreateFromPixels 2465 const uint32_t bytesPerPixel = 3; 2466 const uint32_t padding = 32; 2467 const uint32_t rowBytes = width * bytesPerPixel + padding; 2468 OH_Drawing_Image_Info imageInfo; 2469 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2470 // add assert 2471 EXPECT_EQ(frompixels, nullptr); 2472 //5. OH_Drawing_CanvasBind 2473 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2474 // add assert 2475 EXPECT_NE(canvas, nullptr); 2476 OH_Drawing_CanvasBind(canvas, bitmap); 2477 //6. OH_Drawing_CanvasGetImageInfo with the first parameter as null 2478 // add assert 2479 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(nullptr, &imageInfo), OH_DRAWING_ERROR_INVALID_PARAMETER); 2480 //7. OH_Drawing_CanvasGetImageInfo with the second parameter as null 2481 // add assert 2482 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 2483 //8. free memory 2484 OH_Drawing_CanvasDestroy(canvas); 2485 OH_Drawing_BitmapDestroy(bitmap); 2486 OH_Drawing_BitmapDestroy(frompixels); 2487 } 2488 2489 /* 2490 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4602 2491 * @tc.name: testCanvasGetImageInfoMultipleCalls 2492 * @tc.desc: test for testCanvasGetImageInfoMultipleCalls. 2493 * @tc.size : SmallTest 2494 * @tc.type : Function 2495 * @tc.level : Level 3 2496 */ 2497 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasGetImageInfoMultipleCalls, Function | SmallTest | Level3) { 2498 //1. OH_Drawing_BitmapCreate 2499 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 2500 // add assert 2501 EXPECT_NE(bitmap, nullptr); 2502 //2. OH_Drawing_BitmapGetPixels 2503 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 2504 //3. OH_Drawing_BitmapBuild 2505 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2506 constexpr uint32_t width = 200; 2507 constexpr uint32_t height = 200; 2508 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2509 //4. OH_Drawing_BitmapCreateFromPixels 2510 const uint32_t bytesPerPixel = 3; 2511 const uint32_t padding = 32; 2512 const uint32_t rowBytes = width * bytesPerPixel + padding; 2513 OH_Drawing_Image_Info imageInfo; 2514 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2515 // add assert 2516 EXPECT_EQ(frompixels, nullptr); 2517 //5. OH_Drawing_CanvasBind 2518 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2519 // add assert 2520 EXPECT_NE(canvas, nullptr); 2521 OH_Drawing_CanvasBind(canvas, bitmap); 2522 //6. Call OH_Drawing_CanvasGetImageInfo 10 times 2523 OH_Drawing_Canvas *canvases[10]; 2524 for (int i = 0; i < 10; i++) { 2525 canvases[i]= OH_Drawing_CanvasCreate(); 2526 } 2527 for (int i = 0; i < 10; i++) { 2528 OH_Drawing_CanvasGetImageInfo(canvases[i], &imageInfo); 2529 } 2530 //7. free memory 2531 OH_Drawing_CanvasDestroy(canvas); 2532 for (int i = 0; i < 10; i++) { 2533 OH_Drawing_CanvasDestroy(canvases[i]); 2534 } 2535 OH_Drawing_BitmapDestroy(bitmap); 2536 OH_Drawing_BitmapDestroy(frompixels); 2537 } 2538 2539 /* 2540 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4700 2541 * @tc.name: testCanvasClipRegionNormal 2542 * @tc.desc: test for testCanvasClipRegionNormal. 2543 * @tc.size : SmallTest 2544 * @tc.type : Function 2545 * @tc.level : Level 0 2546 */ 2547 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClipRegionNormal, Function | SmallTest | Level0) { 2548 //1. OH_Drawing_RectCreate 2549 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2550 // add assert 2551 EXPECT_NE(rect, nullptr); 2552 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2553 // add assert 2554 EXPECT_NE(canvas, nullptr); 2555 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2556 //2. OH_Drawing_RegionCreate 2557 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2558 // add assert 2559 EXPECT_NE(region, nullptr); 2560 //3. OH_Drawing_RegionSetRect 2561 OH_Drawing_RegionSetRect(region, rect); 2562 //4. OH_Drawing_CanvasClipRegion 2563 OH_Drawing_CanvasClipRegion(canvas, region, clipOp); 2564 //5. free memory 2565 OH_Drawing_CanvasDestroy(canvas); 2566 OH_Drawing_RectDestroy(rect); 2567 OH_Drawing_RegionDestroy(region); 2568 } 2569 2570 /* 2571 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4701 2572 * @tc.name: testCanvasClipRegionNull 2573 * @tc.desc: test for testCanvasClipRegionNull. 2574 * @tc.size : SmallTest 2575 * @tc.type : Function 2576 * @tc.level : Level 3 2577 */ 2578 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClipRegionNull, Function | SmallTest | Level3) { 2579 //1. OH_Drawing_RectCreate 2580 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2581 // add assert 2582 EXPECT_NE(canvas, nullptr); 2583 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2584 // add assert 2585 EXPECT_NE(rect, nullptr); 2586 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2587 //2. OH_Drawing_RegionCreate 2588 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2589 // add assert 2590 EXPECT_NE(region, nullptr); 2591 //3. OH_Drawing_RegionSetRect 2592 OH_Drawing_RegionSetRect(region, rect); 2593 //4. OH_Drawing_CanvasClipRegion with the first parameter as nullptr 2594 // add assert 2595 EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, clipOp), OH_DRAWING_ERROR_INVALID_PARAMETER); 2596 //5. OH_Drawing_CanvasClipRegion with the second parameter as nullptr 2597 // add assert 2598 EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas, nullptr, clipOp), OH_DRAWING_ERROR_INVALID_PARAMETER); 2599 //6. free memory 2600 OH_Drawing_CanvasDestroy(canvas); 2601 OH_Drawing_RectDestroy(rect); 2602 OH_Drawing_RegionDestroy(region); 2603 } 2604 2605 /* 2606 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4702 2607 * @tc.name: testCanvasClipRegionMultipleCalls 2608 * @tc.desc: test for testCanvasClipRegionMultipleCalls. 2609 * @tc.size : SmallTest 2610 * @tc.type : Function 2611 * @tc.level : Level 3 2612 */ 2613 HWTEST_F(DrawingNativeCanvasPart4Test, testCanvasClipRegionMultipleCalls, Function | SmallTest | Level3) { 2614 //1. OH_Drawing_RectCreate 2615 OH_Drawing_Canvas *canvases[10]; 2616 for (int i = 0; i < 10; i++) { 2617 canvases[i]= OH_Drawing_CanvasCreate(); 2618 // add assert 2619 EXPECT_NE(canvases[i], nullptr); 2620 } 2621 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2622 // add assert 2623 EXPECT_NE(rect, nullptr); 2624 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2625 //2. OH_Drawing_RegionCreate 2626 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2627 // add assert 2628 EXPECT_NE(region, nullptr); 2629 //3. OH_Drawing_RegionSetRect 2630 OH_Drawing_RegionSetRect(region, rect); 2631 //4. Call OH_Drawing_CanvasClipRegion 10 times 2632 for (int i = 0; i < 10; i++) { 2633 OH_Drawing_CanvasClipRegion(canvases[i], region, clipOp); 2634 } 2635 //5. free memory 2636 for (int i = 0; i < 10; i++) { 2637 OH_Drawing_CanvasDestroy(canvases[i]); 2638 } 2639 OH_Drawing_RectDestroy(rect); 2640 OH_Drawing_RegionDestroy(region); 2641 } 2642 2643 } // namespace Drawing 2644 } // namespace Rosen 2645 } // namespace OHOS