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 #include "drawing_pixel_map.h" 41 #include "image/pixelmap_native.h" 42 43 #define DRAW_COLORBLUE 0xFF0000FF 44 45 using namespace testing; 46 using namespace testing::ext; 47 48 namespace OHOS { 49 namespace Rosen { 50 namespace Drawing { 51 class DrawingNativeCanvasPart5Test : public testing::Test { 52 protected: 53 // 在每个测试用例执行前调用 SetUp()54 void SetUp() override 55 { 56 // 设置代码 57 std::cout << "DrawingNativeCanvasPart5Test Setup code called before each test case." << std::endl; 58 OH_Drawing_ErrorCodeReset(); 59 std::cout << "DrawingNativeCanvasPart5Test errorCodeReset before each test case." << std::endl; 60 } TearDown()61 void TearDown() override 62 { 63 std::cout << "DrawingNativeCanvasPart5Test Setup code called after each test case." << std::endl; 64 OH_Drawing_ErrorCodeReset(); 65 std::cout << "DrawingNativeCanvasPart5Test errorCodeReset after each test case." << std::endl; 66 } 67 }; 68 69 /* 70 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4800 71 * @tc.name: testCanvasQuickRejectPathNull 72 * @tc.desc: test for testCanvasQuickRejectPathNull. 73 * @tc.size : SmallTest 74 * @tc.type : Function 75 * @tc.level : Level 3 76 */ 77 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectPathNull, TestSize.Level3) 78 { 79 // OH_Drawing_CanvasCreate 80 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 81 EXPECT_NE(canvas, nullptr); 82 // OH_Drawing_PathCreate 83 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 84 EXPECT_NE(path, nullptr); 85 bool quickReject = false; 86 87 // canvas参数传nullptr 88 auto result1 = OH_Drawing_CanvasQuickRejectPath(nullptr, path, &quickReject); 89 EXPECT_EQ(result1, OH_DRAWING_ERROR_INVALID_PARAMETER); 90 91 // path参数传nullptr 92 auto result2 = OH_Drawing_CanvasQuickRejectPath(canvas, nullptr, &quickReject); 93 EXPECT_EQ(result2, OH_DRAWING_ERROR_INVALID_PARAMETER); 94 95 // quickReject参数传nullptr 96 auto result3 = OH_Drawing_CanvasQuickRejectPath(canvas, path, nullptr); 97 EXPECT_EQ(result3, OH_DRAWING_ERROR_INVALID_PARAMETER); 98 99 // 调用销毁函数销毁指针 100 OH_Drawing_PathDestroy(path); 101 OH_Drawing_CanvasDestroy(canvas); 102 } 103 104 /* 105 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4801 106 * @tc.name: testCanvasQuickRejectPathNormal 107 * @tc.desc: test for testCanvasQuickRejectPathNormal. 108 * @tc.size : SmallTest 109 * @tc.type : Function 110 * @tc.level : Level 1 111 */ 112 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectPathNormal, TestSize.Level1) 113 { 114 // OH_Drawing_CanvasCreate 115 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 116 EXPECT_NE(canvas, nullptr); 117 // OH_Drawing_PathCreate 118 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 119 EXPECT_NE(path, nullptr); 120 bool quickReject = false; 121 122 // 正常传参，path部分在画布内 123 OH_Drawing_PathAddRect(path, -100, 100, 200, 300, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 124 auto result1 = OH_Drawing_CanvasQuickRejectPath(canvas, path, &quickReject); 125 // add assert 126 EXPECT_EQ(result1, OH_DRAWING_SUCCESS); 127 128 // 正常传参，path在画布外 129 OH_Drawing_PathAddRect(path, -100, 100, -200, 300, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 130 auto result2 = OH_Drawing_CanvasQuickRejectPath(canvas, path, &quickReject); 131 // add assert 132 EXPECT_EQ(result2, OH_DRAWING_SUCCESS); 133 134 // 正常传参，path只有一个顶点与画布相接 135 OH_Drawing_PathAddRect(path, -100, -100, 0, 0, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 136 auto result3 = OH_Drawing_CanvasQuickRejectPath(canvas, path, &quickReject); 137 // add assert 138 EXPECT_EQ(result3, OH_DRAWING_SUCCESS); 139 140 // 调用销毁函数销毁指针 141 OH_Drawing_PathDestroy(path); 142 OH_Drawing_CanvasDestroy(canvas); 143 } 144 145 /* 146 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4802 147 * @tc.name: testCanvasQuickRejectPathCalls 148 * @tc.desc: test for testCanvasQuickRejectPathCalls. 149 * @tc.size : SmallTest 150 * @tc.type : Function 151 * @tc.level : Level 2 152 */ 153 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectPathCalls, TestSize.Level2) 154 { 155 // OH_Drawing_CanvasCreate 156 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 157 EXPECT_NE(canvas, nullptr); 158 // OH_Drawing_PathCreate 159 OH_Drawing_Path* path = OH_Drawing_PathCreate(); 160 EXPECT_NE(path, nullptr); 161 bool quickReject = false; 162 163 // 正常传参，path在画布内，调用1000次 164 for (int i = 0; i < 1000; ++i) { 165 OH_Drawing_PathAddRect(path, 100, 100, 200, 200, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 166 auto result = OH_Drawing_CanvasQuickRejectPath(canvas, path, &quickReject); 167 // add assert 168 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 169 } 170 171 // 调用销毁函数销毁指针 172 OH_Drawing_PathDestroy(path); 173 OH_Drawing_CanvasDestroy(canvas); 174 } 175 176 /* 177 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4900 178 * @tc.name: testCanvasQuickRejectRectNull 179 * @tc.desc: test for testCanvasQuickRejectRectNull. 180 * @tc.size : SmallTest 181 * @tc.type : Function 182 * @tc.level : Level 3 183 */ 184 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectRectNull, TestSize.Level3) 185 { 186 // OH_Drawing_CanvasCreate 187 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 188 EXPECT_NE(canvas, nullptr); 189 // OH_Drawing_RectCreate 190 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 100, 100); 191 EXPECT_NE(rect, nullptr); 192 bool quickReject = false; 193 194 // canvas参数传nullptr 195 auto result1 = OH_Drawing_CanvasQuickRejectRect(nullptr, rect, &quickReject); 196 EXPECT_EQ(result1, OH_DRAWING_ERROR_INVALID_PARAMETER); 197 198 // rect参数传nullptr 199 auto result2 = OH_Drawing_CanvasQuickRejectRect(canvas, nullptr, &quickReject); 200 EXPECT_EQ(result2, OH_DRAWING_ERROR_INVALID_PARAMETER); 201 202 // quickReject参数传nullptr 203 auto result3 = OH_Drawing_CanvasQuickRejectRect(canvas, rect, nullptr); 204 EXPECT_EQ(result3, OH_DRAWING_ERROR_INVALID_PARAMETER); 205 206 // 调用销毁函数销毁指针 207 OH_Drawing_RectDestroy(rect); 208 OH_Drawing_CanvasDestroy(canvas); 209 } 210 211 /* 212 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4901 213 * @tc.name: testCanvasQuickRejectRectNormal 214 * @tc.desc: test for testCanvasQuickRejectRectNormal. 215 * @tc.size : SmallTest 216 * @tc.type : Function 217 * @tc.level : Level 1 218 */ 219 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectRectNormal, TestSize.Level1) 220 { 221 // OH_Drawing_CanvasCreate 222 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 223 EXPECT_NE(canvas, nullptr); 224 bool quickReject = false; 225 226 // 正常传参，rect部分在画布内 227 OH_Drawing_Rect* rect1 = OH_Drawing_RectCreate(-100, 0, 300, 200); 228 EXPECT_NE(rect1, nullptr); 229 auto result1 = OH_Drawing_CanvasQuickRejectRect(canvas, rect1, &quickReject); 230 EXPECT_EQ(result1, OH_DRAWING_SUCCESS); 231 232 // 正常传参，rect在画布外 233 OH_Drawing_Rect* rect2 = OH_Drawing_RectCreate(-100, -100, -200, -200); 234 EXPECT_NE(rect2, nullptr); 235 auto result2 = OH_Drawing_CanvasQuickRejectRect(canvas, rect2, &quickReject); 236 EXPECT_EQ(result2, OH_DRAWING_SUCCESS); 237 238 // 正常传参，rect比画布大包含画布 239 OH_Drawing_Rect* rect3 = OH_Drawing_RectCreate(-20, -20, 999999, 999999); 240 EXPECT_NE(rect3, nullptr); 241 auto result3 = OH_Drawing_CanvasQuickRejectRect(canvas, rect3, &quickReject); 242 EXPECT_EQ(result3, OH_DRAWING_SUCCESS); 243 244 // 调用销毁函数销毁指针 245 OH_Drawing_RectDestroy(rect1); 246 OH_Drawing_RectDestroy(rect2); 247 OH_Drawing_RectDestroy(rect3); 248 OH_Drawing_CanvasDestroy(canvas); 249 } 250 251 /* 252 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4902 253 * @tc.name: testCanvasQuickRejectRectCalls 254 * @tc.desc: test for testCanvasQuickRejectRectCalls. 255 * @tc.size : SmallTest 256 * @tc.type : Function 257 * @tc.level : Level 2 258 */ 259 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasQuickRejectRectCalls, TestSize.Level2) 260 { 261 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 262 EXPECT_NE(canvas, nullptr); 263 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 100, 200, 200); 264 bool quickReject = false; 265 266 // 正常传参，rect在画布内，调用1000次 267 for (int i = 0; i < 1000; ++i) { 268 auto result = OH_Drawing_CanvasQuickRejectRect(canvas, rect, &quickReject); 269 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 270 } 271 272 // 调用销毁函数销毁指针 273 OH_Drawing_RectDestroy(rect); 274 OH_Drawing_CanvasDestroy(canvas); 275 } 276 277 /* 278 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5000 279 * @tc.name: testCanvasDrawArcWithCenterNull 280 * @tc.desc: test for testCanvasDrawArcWithCenterNull. 281 * @tc.size : SmallTest 282 * @tc.type : Function 283 * @tc.level : Level 3 284 */ 285 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawArcWithCenterNull, TestSize.Level3) 286 { 287 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 288 EXPECT_NE(canvas, nullptr); 289 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 100, 100); 290 EXPECT_NE(rect, nullptr); 291 292 // canvas参数传nullptr 293 auto result = OH_Drawing_CanvasDrawArcWithCenter(nullptr, rect, 0, 180, false); 294 EXPECT_EQ(result, OH_DRAWING_ERROR_INVALID_PARAMETER); 295 296 // rect参数传nullptr 297 result = OH_Drawing_CanvasDrawArcWithCenter(canvas, nullptr, 0, 180, false); 298 EXPECT_EQ(result, OH_DRAWING_ERROR_INVALID_PARAMETER); 299 300 // 调用销毁函数销毁指针 301 OH_Drawing_RectDestroy(rect); 302 OH_Drawing_CanvasDestroy(canvas); 303 } 304 305 /* 306 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5001 307 * @tc.name: testCanvasDrawArcWithCenterNormal 308 * @tc.desc: test for testCanvasDrawArcWithCenterNormal. 309 * @tc.size : SmallTest 310 * @tc.type : Function 311 * @tc.level : Level 1 312 */ 313 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawArcWithCenterNormal, TestSize.Level1) 314 { 315 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 316 EXPECT_NE(canvas, nullptr); 317 318 // 正常传参，useCenter参数传true 319 OH_Drawing_Rect* rect1 = OH_Drawing_RectCreate(0, 0, 100, 100); 320 EXPECT_NE(rect1, nullptr); 321 auto result1 = OH_Drawing_CanvasDrawArcWithCenter(canvas, rect1, 0, 180, true); 322 EXPECT_EQ(result1, OH_DRAWING_SUCCESS); 323 324 // 正常传参，useCenter参数传true，起始角度小于0，扫描角度大于360 325 OH_Drawing_Rect* rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 326 EXPECT_NE(rect2, nullptr); 327 auto result2 = OH_Drawing_CanvasDrawArcWithCenter(canvas, rect2, -10.0, 650, true); 328 EXPECT_EQ(result2, OH_DRAWING_SUCCESS); 329 330 // 正常传参，useCenter参数传false，起始角度大于0，扫描角度小于0 331 OH_Drawing_Rect* rect3 = OH_Drawing_RectCreate(0, 0, 100, 100); 332 EXPECT_NE(rect3, nullptr); 333 auto result3 = OH_Drawing_CanvasDrawArcWithCenter(canvas, rect3, 66, -120, false); 334 EXPECT_EQ(result3, OH_DRAWING_SUCCESS); 335 336 // 调用销毁函数销毁指针 337 OH_Drawing_RectDestroy(rect1); 338 OH_Drawing_RectDestroy(rect2); 339 OH_Drawing_RectDestroy(rect3); 340 OH_Drawing_CanvasDestroy(canvas); 341 } 342 343 /* 344 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5002 345 * @tc.name: testCanvasDrawArcWithCenterCalls 346 * @tc.desc: test for testCanvasDrawArcWithCenterCalls. 347 * @tc.size : SmallTest 348 * @tc.type : Function 349 * @tc.level : Level 2 350 */ 351 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawArcWithCenterCalls, TestSize.Level2) 352 { 353 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 354 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 100, 300, 300); 355 356 // 正常传参，rect在画布内，调用1000次 357 for (int i = 0; i < 1000; ++i) { 358 auto result = OH_Drawing_CanvasDrawArcWithCenter(canvas, rect, 0, 180, true); 359 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 360 } 361 362 // 调用销毁函数销毁指针 363 OH_Drawing_RectDestroy(rect); 364 OH_Drawing_CanvasDestroy(canvas); 365 } 366 367 /* 368 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5100 369 * @tc.name: testCanvasDrawNestedRoundRectNull 370 * @tc.desc: test for testCanvasDrawNestedRoundRectNull. 371 * @tc.size : SmallTest 372 * @tc.type : Function 373 * @tc.level : Level 3 374 */ 375 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawNestedRoundRectNull, TestSize.Level3) 376 { 377 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 378 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200); 379 OH_Drawing_RoundRect* outer = OH_Drawing_RoundRectCreate(rect, 10, 10); 380 OH_Drawing_Rect* rect1 = OH_Drawing_RectCreate(50, 50, 100, 100); 381 OH_Drawing_RoundRect* inner = OH_Drawing_RoundRectCreate(rect1, 10, 10); 382 383 // canvas参数传nullptr 384 auto result = OH_Drawing_CanvasDrawNestedRoundRect(nullptr, outer, inner); 385 EXPECT_EQ(result, OH_DRAWING_ERROR_INVALID_PARAMETER); 386 387 // outer参数传nullptr 388 result = OH_Drawing_CanvasDrawNestedRoundRect(canvas, nullptr, inner); 389 EXPECT_EQ(result, OH_DRAWING_ERROR_INVALID_PARAMETER); 390 391 // inner参数传nullptr 392 result = OH_Drawing_CanvasDrawNestedRoundRect(canvas, outer, nullptr); 393 EXPECT_EQ(result, OH_DRAWING_ERROR_INVALID_PARAMETER); 394 395 // 调用销毁函数销毁指针 396 OH_Drawing_RoundRectDestroy(inner); 397 OH_Drawing_RectDestroy(rect1); 398 OH_Drawing_RoundRectDestroy(outer); 399 OH_Drawing_RectDestroy(rect); 400 OH_Drawing_CanvasDestroy(canvas); 401 } 402 403 /* 404 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5101 405 * @tc.name: testCanvasDrawNestedRoundRectNormal 406 * @tc.desc: test for testCanvasDrawNestedRoundRectNormal. 407 * @tc.size : SmallTest 408 * @tc.type : Function 409 * @tc.level : Level 1 410 */ 411 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawNestedRoundRectNormal, TestSize.Level1) 412 { 413 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 414 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200); 415 OH_Drawing_RoundRect* outer = OH_Drawing_RoundRectCreate(rect, 10, 10); 416 OH_Drawing_Rect* rect1 = OH_Drawing_RectCreate(50, 50, 100, 100); 417 OH_Drawing_RoundRect* inner = OH_Drawing_RoundRectCreate(rect1, 10, 10); 418 419 // 正常传参，outer>inner 420 auto result1 = OH_Drawing_CanvasDrawNestedRoundRect(canvas, outer, inner); 421 EXPECT_EQ(result1, OH_DRAWING_SUCCESS); 422 423 // 正常传参，outer<inner 424 rect = OH_Drawing_RectCreate(50, 50, 100, 100); 425 outer = OH_Drawing_RoundRectCreate(rect, 10, 10); 426 rect1 = OH_Drawing_RectCreate(0, 0, 200, 200); 427 inner = OH_Drawing_RoundRectCreate(rect1, 10, 10); 428 auto result2 = OH_Drawing_CanvasDrawNestedRoundRect(canvas, outer, inner); 429 EXPECT_EQ(result2, OH_DRAWING_SUCCESS); 430 431 // 调用销毁函数销毁指针 432 OH_Drawing_RoundRectDestroy(inner); 433 OH_Drawing_RectDestroy(rect1); 434 OH_Drawing_RoundRectDestroy(outer); 435 OH_Drawing_RectDestroy(rect); 436 OH_Drawing_CanvasDestroy(canvas); 437 } 438 439 /* 440 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5102 441 * @tc.name: testCanvasDrawNestedRoundRectCalls 442 * @tc.desc: test for testCanvasDrawNestedRoundRectCalls. 443 * @tc.size : SmallTest 444 * @tc.type : Function 445 * @tc.level : Level 2 446 */ 447 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawNestedRoundRectCalls, TestSize.Level2) 448 { 449 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 450 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200); 451 OH_Drawing_RoundRect* outer = OH_Drawing_RoundRectCreate(rect, 10, 10); 452 OH_Drawing_Rect* rect1 = OH_Drawing_RectCreate(50, 50, 100, 100); 453 OH_Drawing_RoundRect* inner = OH_Drawing_RoundRectCreate(rect1, 10, 10); 454 455 // 正常传参，rect在画布内，调用1000次 456 for (int i = 0; i < 1000; ++i) { 457 auto result = OH_Drawing_CanvasDrawNestedRoundRect(canvas, outer, inner); 458 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 459 } 460 461 // 调用销毁函数销毁指针 462 OH_Drawing_RoundRectDestroy(inner); 463 OH_Drawing_RectDestroy(rect1); 464 OH_Drawing_RoundRectDestroy(outer); 465 OH_Drawing_RectDestroy(rect); 466 OH_Drawing_CanvasDestroy(canvas); 467 } 468 469 /* 470 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5200 471 * @tc.name: testCanvasDrawPixelMapNineNull 472 * @tc.desc: test for testCanvasDrawPixelMapNineNull. 473 * @tc.size : SmallTest 474 * @tc.type : Function 475 * @tc.level : Level 3 476 */ 477 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapNineNull, TestSize.Level3) 478 { 479 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 480 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 481 OH_Pixelmap_InitializationOptions* createOps = nullptr; 482 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 483 int32_t imageWidth = 100; 484 int32_t imageHeight = 100; 485 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 486 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 487 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 488 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 489 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 490 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 491 void* bitmapAddr = malloc(bufferSize); 492 if (bitmapAddr == nullptr) { 493 return; 494 } 495 for (int i = 0; i < imageWidth * imageHeight; i++) { 496 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 497 } 498 OH_PixelmapNative* pixelMapNative = nullptr; 499 OH_Drawing_SamplingOptions* samplingOptions = 500 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 501 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 502 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 503 OH_Drawing_Rect* center = OH_Drawing_RectCreate(0, 0, 100, 100); 504 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 200, 200); 505 506 auto result1 = OH_Drawing_CanvasDrawPixelMapNine(nullptr, pixelMap, center, dstRect, 507 OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 508 EXPECT_EQ(result1, OH_DRAWING_ERROR_INVALID_PARAMETER); 509 auto result2 = OH_Drawing_CanvasDrawPixelMapNine(canvas, nullptr, center, dstRect, 510 OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 511 EXPECT_EQ(result2, OH_DRAWING_ERROR_INVALID_PARAMETER); 512 auto result3 = OH_Drawing_CanvasDrawPixelMapNine(canvas, pixelMap, nullptr, dstRect, 513 OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 514 EXPECT_EQ(result3, OH_DRAWING_SUCCESS); 515 auto result4 = OH_Drawing_CanvasDrawPixelMapNine(canvas, pixelMap, center, nullptr, 516 OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 517 EXPECT_EQ(result4, OH_DRAWING_ERROR_INVALID_PARAMETER); 518 // 调用销毁函数销毁指针 519 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 520 OH_PixelmapNative_Release(pixelMapNative); 521 free(bitmapAddr); 522 OH_PixelmapInitializationOptions_Release(createOps); 523 OH_Drawing_CanvasDetachPen(canvas); 524 OH_Drawing_CanvasDetachBrush(canvas); 525 OH_Drawing_RectDestroy(dstRect); 526 OH_Drawing_RectDestroy(center); 527 OH_Drawing_CanvasDestroy(canvas); 528 } 529 530 /* 531 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5201 532 * @tc.name: testCanvasDrawPixelMapNineNormal 533 * @tc.desc: test for testCanvasDrawPixelMapNineNormal. 534 * @tc.size : SmallTest 535 * @tc.type : Function 536 * @tc.level : Level 1 537 */ 538 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapNineNormal, TestSize.Level1) 539 { 540 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 541 EXPECT_NE(canvas, nullptr); 542 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 543 OH_Pixelmap_InitializationOptions* createOps = nullptr; 544 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 545 int32_t imageWidth = 100; 546 int32_t imageHeight = 100; 547 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 548 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 549 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 550 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 551 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 552 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 553 void* bitmapAddr = malloc(bufferSize); 554 if (bitmapAddr == nullptr) { 555 return; 556 } 557 for (int i = 0; i < imageWidth * imageHeight; i++) { 558 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 559 } 560 OH_PixelmapNative* pixelMapNative = nullptr; 561 OH_Drawing_SamplingOptions* samplingOptions = 562 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 563 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 564 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 565 OH_Drawing_Rect* center = OH_Drawing_RectCreate(0, 0, 100, 100); 566 EXPECT_NE(center, nullptr); 567 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 200, 200); 568 EXPECT_NE(dstRect, nullptr); 569 // 正常传参 570 auto result = OH_Drawing_CanvasDrawPixelMapNine(canvas, pixelMap, center, dstRect, 571 OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 572 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 573 // 调用销毁函数销毁指针 574 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 575 OH_PixelmapNative_Release(pixelMapNative); 576 free(bitmapAddr); 577 OH_PixelmapInitializationOptions_Release(createOps); 578 OH_Drawing_CanvasDetachPen(canvas); 579 OH_Drawing_CanvasDetachBrush(canvas); 580 OH_Drawing_RectDestroy(dstRect); 581 OH_Drawing_RectDestroy(center); 582 OH_Drawing_CanvasDestroy(canvas); 583 } 584 585 /* 586 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5202 587 * @tc.name: testCanvasDrawPixelMapNineCalls 588 * @tc.desc: test for testCanvasDrawPixelMapNineCalls. 589 * @tc.size : SmallTest 590 * @tc.type : Function 591 * @tc.level : Level 2 592 */ 593 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapNineCalls, TestSize.Level2) 594 { 595 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 596 EXPECT_NE(canvas, nullptr); 597 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 598 OH_Pixelmap_InitializationOptions* createOps = nullptr; 599 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 600 int32_t imageWidth = 100; 601 int32_t imageHeight = 100; 602 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 603 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 604 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 605 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 606 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 607 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 608 void* bitmapAddr = malloc(bufferSize); 609 if (bitmapAddr == nullptr) { 610 return; 611 } 612 for (int i = 0; i < imageWidth * imageHeight; i++) { 613 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 614 } 615 OH_PixelmapNative* pixelMapNative = nullptr; 616 OH_Drawing_SamplingOptions* samplingOptions = 617 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 618 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 619 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 620 OH_Drawing_Rect* center = OH_Drawing_RectCreate(0, 0, 100, 100); 621 EXPECT_NE(center, nullptr); 622 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 200, 200); 623 EXPECT_NE(dstRect, nullptr); 624 // 正常传参，调用1000次 625 for (int i = 0; i < 1000; ++i) { 626 auto result = OH_Drawing_CanvasDrawPixelMapNine(canvas, pixelMap, center, 627 dstRect, OH_Drawing_FilterMode::FILTER_MODE_NEAREST); 628 EXPECT_EQ(result, OH_DRAWING_SUCCESS); 629 } 630 // 调用销毁函数销毁指针 631 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 632 OH_PixelmapNative_Release(pixelMapNative); 633 free(bitmapAddr); 634 OH_PixelmapInitializationOptions_Release(createOps); 635 OH_Drawing_CanvasDetachPen(canvas); 636 OH_Drawing_CanvasDetachBrush(canvas); 637 OH_Drawing_RectDestroy(dstRect); 638 OH_Drawing_RectDestroy(center); 639 OH_Drawing_CanvasDestroy(canvas); 640 } 641 642 } // namespace Drawing 643 } // namespace Rosen 644 } // namespace OHOS