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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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 /* 643 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5300 644 * @tc.name: testCanvasCreateWithPixelMapNormal 645 * @tc.desc: test for testCanvasCreateWithPixelMapNormal 646 * @tc.size : SmallTest 647 * @tc.type : Function 648 * @tc.level : Level 2 649 */ 650 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasCreateWithPixelMapNormal, Function | SmallTest | Level2) 651 { 652 uint32_t imageWidth = 500; 653 uint32_t imageHeight = 500; 654 OH_Pixelmap_InitializationOptions* createOps = nullptr; 655 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 656 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 657 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 658 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 659 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 660 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 661 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 662 void* bitmapAddr = malloc(bufferSize); 663 if (bitmapAddr == nullptr) { 664 return; 665 } 666 for (int i = 0; i < imageWidth * imageHeight; i++) { 667 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 668 } 669 OH_PixelmapNative* pixelMapNative = nullptr; 670 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 671 OH_Drawing_SamplingOptions* samplingOptions = 672 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 673 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 674 OH_Drawing_Canvas* offScreenCanvas = OH_Drawing_CanvasCreateWithPixelMap(pixelMap); 675 EXPECT_NE(offScreenCanvas, nullptr); 676 OH_Drawing_CanvasDestroy(offScreenCanvas); 677 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 678 OH_Drawing_PixelMapDissolve(pixelMap); 679 OH_PixelmapNative_Release(pixelMapNative); 680 OH_PixelmapInitializationOptions_Release(createOps); 681 free(bitmapAddr); 682 } 683 684 /* 685 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5301 686 * @tc.name: testCanvasCreateWithPixelMapNull 687 * @tc.desc: test for testCanvasCreateWithPixelMapNull 688 * @tc.size : SmallTest 689 * @tc.type : Function 690 * @tc.level : Level 3 691 */ 692 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasCreateWithPixelMapNull, Function | SmallTest | Level3) 693 { 694 uint32_t imageWidth = 500; 695 uint32_t imageHeight = 500; 696 OH_Pixelmap_InitializationOptions* createOps = nullptr; 697 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 698 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 699 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 700 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 701 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 702 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 703 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 704 void* bitmapAddr = malloc(bufferSize); 705 if (bitmapAddr == nullptr) { 706 return; 707 } 708 for (int i = 0; i < imageWidth * imageHeight; i++) { 709 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 710 } 711 OH_PixelmapNative* pixelMapNative = nullptr; 712 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 713 OH_Drawing_SamplingOptions* samplingOptions = 714 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 715 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 716 OH_Drawing_Canvas* offScreenCanvas = OH_Drawing_CanvasCreateWithPixelMap(nullptr); 717 EXPECT_EQ(offScreenCanvas, nullptr); 718 OH_Drawing_CanvasDestroy(offScreenCanvas); 719 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 720 OH_Drawing_PixelMapDissolve(pixelMap); 721 OH_PixelmapNative_Release(pixelMapNative); 722 OH_PixelmapInitializationOptions_Release(createOps); 723 free(bitmapAddr); 724 } 725 726 /* 727 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5302 728 * @tc.name: testCanvasCreateWithPixelMapMultipleCalls 729 * @tc.desc: test for testCanvasCreateWithPixelMapMultipleCalls 730 * @tc.size : SmallTest 731 * @tc.type : Function 732 * @tc.level : Level 3 733 */ 734 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasCreateWithPixelMapMultipleCalls, Function | SmallTest | Level3) 735 { 736 uint32_t imageWidth = 500; 737 uint32_t imageHeight = 500; 738 OH_Pixelmap_InitializationOptions* createOps = nullptr; 739 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 740 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 741 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 742 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 743 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 744 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 745 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 746 void* bitmapAddr = malloc(bufferSize); 747 if (bitmapAddr == nullptr) { 748 return; 749 } 750 for (int i = 0; i < imageWidth * imageHeight; i++) { 751 ((uint32_t*)bitmapAddr)[i] = DRAW_COLORBLUE; 752 } 753 OH_PixelmapNative* pixelMapNative = nullptr; 754 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)bitmapAddr, bufferSize, createOps, &pixelMapNative); 755 OH_Drawing_SamplingOptions* samplingOptions = 756 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 757 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 758 for (int i = 0; i < 10; i++) { 759 OH_Drawing_Canvas* offScreenCanvas = OH_Drawing_CanvasCreateWithPixelMap(pixelMap); 760 EXPECT_NE(offScreenCanvas, nullptr); 761 OH_Drawing_CanvasDestroy(offScreenCanvas); 762 } 763 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 764 OH_Drawing_PixelMapDissolve(pixelMap); 765 OH_PixelmapNative_Release(pixelMapNative); 766 OH_PixelmapInitializationOptions_Release(createOps); 767 free(bitmapAddr); 768 } 769 770 /* 771 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5400 772 * @tc.name: testCanvasDrawPixelMapRectConstraintNormal 773 * @tc.desc: test for testCanvasDrawPixelMapRectConstraintNormal 774 * @tc.size : SmallTest 775 * @tc.type : Function 776 * @tc.level : Level 2 777 */ 778 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapRectConstraintNormal, Function | SmallTest | Level2) 779 { 780 uint32_t imageWidth = 200; 781 uint32_t imageHeight = 200; 782 OH_Pixelmap_InitializationOptions* createOps = nullptr; 783 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 784 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 785 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 786 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 787 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 788 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 789 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 790 void* buffer = malloc(bufferSize); 791 if (buffer == nullptr) { 792 return; 793 } 794 for (int i = 0; i < imageWidth * imageHeight; i++) { 795 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 796 } 797 OH_PixelmapNative* pixelMapNative = nullptr; 798 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 799 OH_Drawing_SamplingOptions* samplingOptions = 800 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 801 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 802 // 1. The interface of OH_Drawing_CanvasDrawPixelMapRectConstraint is called normally. 803 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 804 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200); 805 EXPECT_NE(src, nullptr); 806 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 807 EXPECT_NE(dst, nullptr); 808 OH_Drawing_ErrorCode errorCode; 809 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 810 canvas, pixelMap, src, dst, samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 811 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 812 // 2. Destroy objects. 813 OH_Drawing_CanvasDestroy(canvas); 814 OH_Drawing_RectDestroy(src); 815 OH_Drawing_RectDestroy(dst); 816 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 817 OH_Drawing_PixelMapDissolve(pixelMap); 818 OH_PixelmapNative_Release(pixelMapNative); 819 OH_PixelmapInitializationOptions_Release(createOps); 820 free(buffer); 821 } 822 823 /* 824 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5401 825 * @tc.name: testCanvasDrawPixelMapRectConstraintNull 826 * @tc.desc: test for testCanvasDrawPixelMapRectConstraintNull 827 * @tc.size : SmallTest 828 * @tc.type : Function 829 * @tc.level : Level 3 830 */ 831 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapRectConstraintNull, Function | SmallTest | Level3) 832 { 833 uint32_t imageWidth = 200; 834 uint32_t imageHeight = 200; 835 OH_Pixelmap_InitializationOptions* createOps = nullptr; 836 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 837 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 838 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 839 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 840 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 841 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 842 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 843 void* buffer = malloc(bufferSize); 844 if (buffer == nullptr) { return; } 845 for (int i = 0; i < imageWidth * imageHeight; i++) { ((uint32_t*)buffer)[i] = 0xFFFF00FF; } 846 OH_PixelmapNative* pixelMapNative = nullptr; 847 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 848 OH_Drawing_SamplingOptions* samplingOptions = 849 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 850 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 851 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 852 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200); 853 EXPECT_NE(src, nullptr); 854 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 855 EXPECT_NE(dst, nullptr); 856 OH_Drawing_ErrorCode errorCode; 857 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 858 nullptr, pixelMap, src, dst, samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 859 EXPECT_EQ(errorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 860 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 861 canvas, nullptr, src, dst, samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 862 EXPECT_EQ(errorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 863 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 864 canvas, pixelMap, nullptr, dst, samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 865 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 866 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 867 canvas, pixelMap, src, nullptr, samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 868 EXPECT_EQ(errorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 869 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 870 canvas, pixelMap, src, dst, nullptr, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT); 871 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 872 OH_Drawing_CanvasDestroy(canvas); 873 OH_Drawing_RectDestroy(src); 874 OH_Drawing_RectDestroy(dst); 875 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 876 OH_Drawing_PixelMapDissolve(pixelMap); 877 OH_PixelmapNative_Release(pixelMapNative); 878 OH_PixelmapInitializationOptions_Release(createOps); 879 free(buffer); 880 } 881 882 /* 883 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5402 884 * @tc.name: testCanvasDrawPixelMapRectConstraintAbnormal 885 * @tc.desc: test for testCanvasDrawPixelMapRectConstraintAbnormal 886 * @tc.size : SmallTest 887 * @tc.type : Function 888 * @tc.level : Level 3 889 */ 890 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapRectConstraintAbnormal, Function | SmallTest | Level3) 891 { 892 uint32_t imageWidth = 200; 893 uint32_t imageHeight = 200; 894 OH_Pixelmap_InitializationOptions* createOps = nullptr; 895 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 896 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 897 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 898 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 899 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 900 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 901 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 902 void* buffer = malloc(bufferSize); 903 if (buffer == nullptr) { 904 return; 905 } 906 for (int i = 0; i < imageWidth * imageHeight; i++) { 907 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 908 } 909 OH_PixelmapNative* pixelMapNative = nullptr; 910 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 911 OH_Drawing_SamplingOptions* samplingOptions = 912 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 913 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 914 // 1. The last parameter of the verification interface passes an enumeration value that is out of range. 915 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 916 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200); 917 EXPECT_NE(src, nullptr); 918 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 919 EXPECT_NE(dst, nullptr); 920 OH_Drawing_ErrorCode errorCode; 921 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 922 canvas, pixelMap, src, dst, samplingOptions, static_cast<OH_Drawing_SrcRectConstraint>(3)); 923 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 924 // 2. Destroy objects. 925 OH_Drawing_CanvasDestroy(canvas); 926 OH_Drawing_RectDestroy(src); 927 OH_Drawing_RectDestroy(dst); 928 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 929 OH_Drawing_PixelMapDissolve(pixelMap); 930 OH_PixelmapNative_Release(pixelMapNative); 931 OH_PixelmapInitializationOptions_Release(createOps); 932 free(buffer); 933 } 934 935 /* 936 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_5403 937 * @tc.name: testCanvasDrawPixelMapRectConstraintMultiCalls 938 * @tc.desc: test for testCanvasDrawPixelMapRectConstraintMultiCalls 939 * @tc.size : SmallTest 940 * @tc.type : Function 941 * @tc.level : Level 3 942 */ 943 HWTEST_F(DrawingNativeCanvasPart5Test, testCanvasDrawPixelMapRectConstraintMultiCalls, Function | SmallTest | Level3) 944 { 945 uint32_t imageWidth = 200; 946 uint32_t imageHeight = 200; 947 OH_Pixelmap_InitializationOptions* createOps = nullptr; 948 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 949 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 950 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 951 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 952 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 953 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 954 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 955 void* buffer = malloc(bufferSize); 956 if (buffer == nullptr) { 957 return; 958 } 959 for (int i = 0; i < imageWidth * imageHeight; i++) { 960 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 961 } 962 OH_PixelmapNative* pixelMapNative = nullptr; 963 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 964 OH_Drawing_SamplingOptions* samplingOptions = 965 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 966 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 967 // 1. The interface of OH_Drawing_ShaderEffectCreatePixelMapShader is called 10 times. 968 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 969 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200); 970 EXPECT_NE(src, nullptr); 971 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 972 EXPECT_NE(dst, nullptr); 973 OH_Drawing_ErrorCode errorCode; 974 for (int i = 0; i < 10; i++) { 975 errorCode = OH_Drawing_CanvasDrawPixelMapRectConstraint( 976 canvas, pixelMap, src, dst, samplingOptions, OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT); 977 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 978 } 979 // 2. Destroy objects. 980 OH_Drawing_CanvasDestroy(canvas); 981 OH_Drawing_RectDestroy(src); 982 OH_Drawing_RectDestroy(dst); 983 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 984 OH_Drawing_PixelMapDissolve(pixelMap); 985 OH_PixelmapNative_Release(pixelMapNative); 986 OH_PixelmapInitializationOptions_Release(createOps); 987 free(buffer); 988 } 989 } // namespace Drawing 990 } // namespace Rosen 991 } // namespace OHOS