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 "DrawingNativeCanvasCommon.h" 17 #include "drawing_bitmap.h" 18 #include "drawing_brush.h" 19 #include "drawing_canvas.h" 20 #include "drawing_color.h" 21 #include "drawing_color_filter.h" 22 #include "drawing_error_code.h" 23 #include "drawing_filter.h" 24 #include "drawing_font.h" 25 #include "drawing_image.h" 26 #include "drawing_mask_filter.h" 27 #include "drawing_matrix.h" 28 #include "drawing_memory_stream.h" 29 #include "drawing_path.h" 30 #include "drawing_pen.h" 31 #include "drawing_pixel_map.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 "image/pixelmap_native.h" 41 #include "gtest/gtest.h" 42 43 using namespace testing; 44 using namespace testing::ext; 45 46 namespace OHOS { 47 namespace Rosen { 48 namespace Drawing { 49 class DrawingNativeCanvasPart2Test : public testing::Test { 50 protected: 51 // 在每个测试用例执行前调用 SetUp()52 void SetUp() override 53 { 54 // 设置代码 55 std::cout << "DrawingNativeCanvasPart2Test Setup code called before each test case." << std::endl; 56 OH_Drawing_ErrorCodeReset(); 57 std::cout << "DrawingNativeCanvasPart2Test errorCodeReset before each test case." << std::endl; 58 } TearDown()59 void TearDown() override 60 { 61 std::cout << "DrawingNativeCanvasPart2Test Setup code called after each test case." << std::endl; 62 OH_Drawing_ErrorCodeReset(); 63 std::cout << "DrawingNativeCanvasPart2Test errorCodeReset after each test case." << std::endl; 64 } 65 }; 66 /* 67 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1100 68 * @tc.name: testCanvasDrawPixelMapRectNormal 69 * @tc.desc: test for testCanvasDrawPixelMapRectNormal. 70 * @tc.size : SmallTest 71 * @tc.type : Function 72 * @tc.level : Level 0 73 */ 74 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRectNormal, TestSize.Level0) 75 { 76 // 1. OH_Drawing_CanvasCreate 77 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 78 EXPECT_NE(canvas, nullptr); 79 80 // 2. Obtain OH_Drawing_PixelMap from OH_Drawing_PixelMapGetFromNativePixelMap() 81 82 // 3. Create src and dst using OH_Drawing_RectCreate 83 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 84 EXPECT_NE(src, nullptr); 85 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 86 EXPECT_NE(dst, nullptr); 87 88 // 4. Obtain OH_Drawing_PixelMap from OH_Drawing_PixelMapGetFromOhPixelMapNative 89 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative(); 90 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 91 EXPECT_NE(drPixelMap, nullptr); 92 93 // 5. Iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct OH_Drawing_SamplingOptions for 94 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR}; 95 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE}; 96 for (int i = 0; i < 2; i++) { 97 for (int j = 0; j < 3; j++) { 98 OH_Drawing_ErrorCodeReset(); 99 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]); 100 // add assert 101 EXPECT_NE(options, nullptr); 102 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, options); 103 // add assert 104 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 105 } 106 } 107 108 // 6. Free the memory. 109 OH_Drawing_PixelMapDissolve(drPixelMap); 110 OH_Drawing_RectDestroy(src); 111 OH_Drawing_RectDestroy(dst); 112 OH_Drawing_CanvasDestroy(canvas); 113 } 114 115 /* 116 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1101 117 * @tc.name: testCanvasDrawPixelMapRectNull 118 * @tc.desc: test for testCanvasDrawPixelMapRectNull. 119 * @tc.size : SmallTest 120 * @tc.type : Function 121 * @tc.level : Level 3 122 */ 123 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRectNull, TestSize.Level3) 124 { 125 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 126 EXPECT_NE(canvas, nullptr); 127 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative(); 128 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 129 EXPECT_NE(drPixelMap, nullptr); 130 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 131 EXPECT_NE(src, nullptr); 132 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 133 EXPECT_NE(dst, nullptr); 134 OH_Drawing_SamplingOptions *sampleOptions = 135 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 136 137 // add assert 138 EXPECT_NE(sampleOptions, nullptr); 139 OH_Drawing_CanvasDrawPixelMapRect(nullptr, drPixelMap, src, dst, sampleOptions); 140 // add assert 141 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 142 OH_Drawing_ErrorCodeReset(); 143 OH_Drawing_CanvasDrawPixelMapRect(canvas, nullptr, src, dst, sampleOptions); 144 // add assert 145 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 146 OH_Drawing_ErrorCodeReset(); 147 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, nullptr, dst, sampleOptions); 148 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, nullptr, sampleOptions); 149 // add assert 150 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 151 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, nullptr); 152 OH_Drawing_PixelMapGetFromNativePixelMap(nullptr); 153 154 float rectParams[][4] = { 155 {0, 1, 1, 1}, {1, 0, 1, 1}, {1, 1, 0, 1}, {1, 1, 1, 0}, {0, 0, 0, 0}, 156 }; 157 for (int i = 0; i < sizeof(rectParams) / sizeof(rectParams[0]); ++i) { 158 OH_Drawing_Rect *src = 159 OH_Drawing_RectCreate(rectParams[i][0], rectParams[i][1], rectParams[i][2], rectParams[i][3]); 160 // add assert 161 EXPECT_NE(src, nullptr); 162 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions); 163 164 OH_Drawing_Rect *dst = 165 OH_Drawing_RectCreate(rectParams[i][0], rectParams[i][1], rectParams[i][2], rectParams[i][3]); 166 // add assert 167 EXPECT_NE(dst, nullptr); 168 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions); 169 170 OH_Drawing_RectDestroy(src); 171 OH_Drawing_RectDestroy(dst); 172 } 173 174 OH_Drawing_RectDestroy(src); 175 OH_Drawing_RectDestroy(dst); 176 OH_Drawing_SamplingOptionsDestroy(sampleOptions); 177 OH_Drawing_PixelMapDissolve(drPixelMap); 178 OH_Drawing_CanvasDestroy(canvas); 179 } 180 181 /* 182 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1102 183 * @tc.name: testCanvasDrawPixelMapRectAbnormal 184 * @tc.desc: test for testCanvasDrawPixelMapRectAbnormal. 185 * @tc.size : SmallTest 186 * @tc.type : Function 187 * @tc.level : Level 3 188 */ 189 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRectAbnormal, TestSize.Level3) 190 { 191 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 192 // add assert 193 EXPECT_NE(canvas, nullptr); 194 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative(); 195 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 196 EXPECT_NE(drPixelMap, nullptr); 197 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 198 EXPECT_NE(src, nullptr); 199 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 200 EXPECT_NE(dst, nullptr); 201 OH_Drawing_SamplingOptions *sampleOptions = 202 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 203 // add assert 204 EXPECT_NE(sampleOptions, nullptr); 205 OH_Drawing_CanvasDrawPixelMapRect(nullptr, drPixelMap, src, dst, sampleOptions); 206 // add assert 207 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 208 OH_Drawing_ErrorCodeReset(); 209 OH_Drawing_CanvasDrawPixelMapRect(canvas, nullptr, src, dst, sampleOptions); 210 // add assert 211 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 212 OH_Drawing_ErrorCodeReset(); 213 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, nullptr, dst, sampleOptions); 214 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, nullptr, sampleOptions); 215 // add assert 216 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 217 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, nullptr); 218 OH_Drawing_PixelMapGetFromNativePixelMap(nullptr); 219 OH_Drawing_RectDestroy(src); 220 OH_Drawing_RectDestroy(dst); 221 // Define parameter arrays for source and destination rectangles 222 int srcRects[][4] = { 223 {-1, 1, 1, 1}, {1, -1, 1, 1}, {1, 1, -1, 1}, {1, 1, 1, -1}, {100, 100, 100, 200}, 224 {100, 200, 200, 200}, {100, 100, 100, 100}, {200, 200, 100, 100}, {0, 0, 100, 100}, 225 }; 226 // Loop to draw the first 7 src rectangles 227 for (int i = 0; i < 8; i++) { 228 src = OH_Drawing_RectCreate(srcRects[i][0], srcRects[i][1], srcRects[i][2], srcRects[i][3]); 229 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions); 230 OH_Drawing_RectDestroy(src); 231 } 232 src = OH_Drawing_RectCreate(0, 0, 100, 100); 233 int dstRects[][4] = { 234 {100, 100, 100, 200}, 235 {100, 200, 200, 200}, 236 {100, 100, 100, 100}, 237 {200, 200, 100, 100}, 238 }; 239 // Loop to draw all dst rectangles using the last src rectangle 240 for (int i = 0; i < 4; i++) { 241 dst = OH_Drawing_RectCreate(dstRects[i][0], dstRects[i][1], dstRects[i][2], dstRects[i][3]); 242 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions); 243 OH_Drawing_RectDestroy(dst); 244 } 245 OH_Drawing_RectDestroy(src); 246 OH_Drawing_SamplingOptionsDestroy(sampleOptions); 247 OH_Drawing_PixelMapDissolve(drPixelMap); 248 OH_Drawing_CanvasDestroy(canvas); 249 } 250 251 /* 252 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1103 253 * @tc.name: testCanvasDrawPixelMapRectMaximum 254 * @tc.desc: test for testCanvasDrawPixelMapRectMaximum. 255 * @tc.size : SmallTest 256 * @tc.type : Function 257 * @tc.level : Level 3 258 */ 259 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRectMaximum, TestSize.Level3) 260 { 261 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 262 EXPECT_NE(canvas, nullptr); 263 264 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative(); 265 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 266 EXPECT_NE(drPixelMap, nullptr); 267 268 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 269 EXPECT_NE(src, nullptr); 270 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 271 EXPECT_NE(dst, nullptr); 272 273 OH_Drawing_SamplingOptions *sampleOptions = 274 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 275 // add assert 276 EXPECT_NE(sampleOptions, nullptr); 277 278 // 2 279 OH_Drawing_Rect *src1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 280 // add assert 281 EXPECT_NE(src1, nullptr); 282 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src1, dst, sampleOptions); 283 // 3 284 OH_Drawing_Rect *src2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 285 // add assert 286 EXPECT_NE(src2, nullptr); 287 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src2, dst, sampleOptions); 288 // 4 289 OH_Drawing_Rect *dst1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 290 // add assert 291 EXPECT_NE(dst1, nullptr); 292 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst1, sampleOptions); 293 // 5 294 OH_Drawing_Rect *dst2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 295 // add assert 296 EXPECT_NE(dst2, nullptr); 297 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst2, sampleOptions); 298 // 6 299 OH_Drawing_RectDestroy(src1); 300 OH_Drawing_RectDestroy(src2); 301 OH_Drawing_RectDestroy(dst1); 302 OH_Drawing_RectDestroy(dst2); 303 OH_Drawing_RectDestroy(src); 304 OH_Drawing_RectDestroy(dst); 305 OH_Drawing_SamplingOptionsDestroy(sampleOptions); 306 OH_Drawing_PixelMapDissolve(drPixelMap); 307 OH_Drawing_CanvasDestroy(canvas); 308 } 309 310 /* 311 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1103 312 * @tc.name: testCanvasDrawPixelMapRect4KBoundary 313 * @tc.desc: test for testCanvasDrawPixelMapRect4KBoundary. 314 * @tc.size : SmallTest 315 * @tc.type : Function 316 * @tc.level : Level 3 317 */ 318 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRect4KBoundary, TestSize.Level3) 319 { 320 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 321 EXPECT_NE(canvas, nullptr); 322 323 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative4KBoundary(); 324 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 325 EXPECT_NE(drPixelMap, nullptr); 326 327 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 328 EXPECT_NE(src, nullptr); 329 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 330 EXPECT_NE(dst, nullptr); 331 332 OH_Drawing_SamplingOptions *sampleOptions = 333 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 334 // add assert 335 EXPECT_NE(sampleOptions, nullptr); 336 // 2 337 OH_Drawing_Rect *src1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 338 // add assert 339 EXPECT_NE(src1, nullptr); 340 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src1, dst, sampleOptions); 341 // 3 342 OH_Drawing_Rect *src2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 343 // add assert 344 EXPECT_NE(src2, nullptr); 345 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src2, dst, sampleOptions); 346 // 4 347 OH_Drawing_Rect *dst1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 348 // add assert 349 EXPECT_NE(dst1, nullptr); 350 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst1, sampleOptions); 351 // 5 352 OH_Drawing_Rect *dst2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 353 // add assert 354 EXPECT_NE(dst2, nullptr); 355 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst2, sampleOptions); 356 // 6 357 OH_Drawing_RectDestroy(src1); 358 OH_Drawing_RectDestroy(src2); 359 OH_Drawing_RectDestroy(dst1); 360 OH_Drawing_RectDestroy(dst2); 361 OH_Drawing_RectDestroy(src); 362 OH_Drawing_RectDestroy(dst); 363 OH_Drawing_SamplingOptionsDestroy(sampleOptions); 364 OH_Drawing_PixelMapDissolve(drPixelMap); 365 OH_Drawing_CanvasDestroy(canvas); 366 } 367 368 /* 369 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1104 370 * @tc.name: testCanvasDrawPixelMapRectInputDestroyed 371 * @tc.desc: test for testCanvasDrawPixelMapRectInputDestroyed. 372 * @tc.size : SmallTest 373 * @tc.type : Function 374 * @tc.level : Level 3 375 */ 376 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRectInputDestroyed, TestSize.Level3) 377 { 378 // Deprecated 379 } 380 381 /* 382 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1200 383 * @tc.name: testCanvasDrawBackgroundNormal 384 * @tc.desc: test for testCanvasDrawBackgroundNormal. 385 * @tc.size : SmallTest 386 * @tc.type : Function 387 * @tc.level : Level 0 388 */ 389 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBackgroundNormal, TestSize.Level0) 390 { 391 // 1. OH_Drawing_CanvasCreate 392 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 393 EXPECT_NE(canvas, nullptr); 394 395 // 2. OH_Drawing_BrushCreate 396 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 397 EXPECT_NE(brush, nullptr); 398 399 // 3. OH_Drawing_CanvasDrawBackground 400 OH_Drawing_CanvasDrawBackground(canvas, brush); 401 // add assert 402 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 403 404 // 4. Free the memory. 405 OH_Drawing_BrushDestroy(brush); 406 OH_Drawing_CanvasDestroy(canvas); 407 } 408 409 /* 410 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1201 411 * @tc.name: testCanvasDrawBackgroundNull 412 * @tc.desc: test for testCanvasDrawBackgroundNull. 413 * @tc.size : SmallTest 414 * @tc.type : Function 415 * @tc.level : Level 3 416 */ 417 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBackgroundNull, TestSize.Level3) 418 { 419 // 1. OH_Drawing_CanvasCreate 420 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 421 EXPECT_NE(canvas, nullptr); 422 423 // 2. OH_Drawing_BrushCreate 424 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 425 EXPECT_NE(brush, nullptr); 426 427 // 3. Pass an empty value as the first argument for OH_Drawing_CanvasDrawBackground. 428 OH_Drawing_CanvasDrawBackground(nullptr, brush); 429 // add assert 430 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 431 OH_Drawing_ErrorCodeReset(); 432 433 // 4. Pass an empty value as the second argument for OH_Drawing_CanvasDrawBackground. 434 OH_Drawing_CanvasDrawBackground(canvas, nullptr); 435 // add assert 436 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 437 438 // 5. Free the memory. 439 OH_Drawing_BrushDestroy(brush); 440 OH_Drawing_CanvasDestroy(canvas); 441 } 442 443 /* 444 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1202 445 * @tc.name: testCanvasDrawBackgroundInputDestroyed 446 * @tc.desc: test for testCanvasDrawBackgroundInputDestroyed. 447 * @tc.size : SmallTest 448 * @tc.type : Function 449 * @tc.level : Level 3 450 */ 451 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBackgroundInputDestroyed, TestSize.Level3) 452 { 453 // Deprecated 454 } 455 456 /* 457 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1203 458 * @tc.name: testCanvasDrawBackgroundMultipleCalls 459 * @tc.desc: test for testCanvasDrawBackgroundMultipleCalls. 460 * @tc.size : SmallTest 461 * @tc.type : Function 462 * @tc.level : Level 3 463 */ 464 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBackgroundMultipleCalls, TestSize.Level3) 465 { 466 // 1. OH_Drawing_CanvasCreate 467 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 468 EXPECT_NE(canvas, nullptr); 469 470 // 2. OH_Drawing_BrushCreate 471 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 472 EXPECT_NE(brush, nullptr); 473 474 // 3. OH_Drawing_CanvasDrawBackground, 10 times. 475 for (int i = 0; i < 10; i++) { 476 OH_Drawing_CanvasDrawBackground(canvas, brush); 477 } 478 479 // 4. Free the memory. 480 OH_Drawing_BrushDestroy(brush); 481 OH_Drawing_CanvasDestroy(canvas); 482 } 483 484 /* 485 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1300 486 * @tc.name: testCanvasDrawRegionNormal 487 * @tc.desc: test for testCanvasDrawRegionNormal. 488 * @tc.size : SmallTest 489 * @tc.type : Function 490 * @tc.level : Level 0 491 */ 492 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRegionNormal, TestSize.Level0) 493 { 494 // 1. OH_Drawing_CanvasCreate 495 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 496 EXPECT_NE(canvas, nullptr); 497 498 // 2. OH_Drawing_RegionCreate 499 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 500 EXPECT_NE(region, nullptr); 501 502 // 3. OH_Drawing_RegionSetRect 503 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 504 // add assert 505 EXPECT_NE(rect, nullptr); 506 507 OH_Drawing_RegionSetRect(region, rect); 508 509 // 4. OH_Drawing_CanvasDrawRegion 510 OH_Drawing_CanvasDrawRegion(canvas, region); 511 // add assert 512 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 513 514 // 5. Free the memory. 515 OH_Drawing_RectDestroy(rect); 516 OH_Drawing_RegionDestroy(region); 517 OH_Drawing_CanvasDestroy(canvas); 518 } 519 520 /* 521 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1301 522 * @tc.name: testCanvasDrawRegionNull 523 * @tc.desc: test for testCanvasDrawRegionNull. 524 * @tc.size : SmallTest 525 * @tc.type : Function 526 * @tc.level : Level 3 527 */ 528 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRegionNull, TestSize.Level3) 529 { 530 // 1. OH_Drawing_CanvasCreate 531 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 532 EXPECT_NE(canvas, nullptr); 533 534 // 2. OH_Drawing_RegionCreate 535 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 536 EXPECT_NE(region, nullptr); 537 538 // 3. OH_Drawing_CanvasDrawRegion, first parameter is nullptr 539 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 540 // add assert 541 EXPECT_NE(rect, nullptr); 542 OH_Drawing_RegionSetRect(region, rect); 543 OH_Drawing_CanvasDrawRegion(nullptr, region); 544 // add assert 545 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 546 OH_Drawing_ErrorCodeReset(); 547 // 4. OH_Drawing_CanvasDrawRegion, second parameter is nullptr 548 OH_Drawing_CanvasDrawRegion(canvas, nullptr); 549 // add assert 550 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 551 552 // 5. OH_Drawing_CanvasDrawRegion, region is empty 553 OH_Drawing_Region *region2 = OH_Drawing_RegionCreate(); 554 // add assert 555 EXPECT_NE(region2, nullptr); 556 OH_Drawing_CanvasDrawRegion(canvas, region2); 557 558 // 6. Free the memory. 559 OH_Drawing_RectDestroy(rect); 560 OH_Drawing_RegionDestroy(region); 561 OH_Drawing_RegionDestroy(region2); 562 OH_Drawing_CanvasDestroy(canvas); 563 } 564 565 /* 566 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1302 567 * @tc.name: testCanvasDrawRegionInputDestroyed 568 * @tc.desc: test for testCanvasDrawRegionInputDestroyed. 569 * @tc.size : SmallTest 570 * @tc.type : Function 571 * @tc.level : Level 3 572 */ 573 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRegionInputDestroyed, TestSize.Level3) 574 { 575 // Deprecated 576 } 577 578 /* 579 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1400 580 * @tc.name: testCanvasDrawPointsNormal 581 * @tc.desc: test for testCanvasDrawPointsNormal. 582 * @tc.size : SmallTest 583 * @tc.type : Function 584 * @tc.level : Level 0 585 */ 586 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsNormal, TestSize.Level0) 587 { 588 // 1. OH_Drawing_CanvasCreate 589 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 590 EXPECT_NE(canvas, nullptr); 591 592 // 2. OH_Drawing_Point2D creates an array of points. 593 OH_Drawing_Point2D point = {250, 500}; 594 OH_Drawing_Point2D points1[1] = {point}; 595 596 // 3. OH_Drawing_CanvasDrawPoints iterates through the enum values OH_Drawing_PointMode, with count set to the 597 // length of the corresponding value. 598 OH_Drawing_PointMode modeArray[3] = {POINT_MODE_POINTS, POINT_MODE_LINES, POINT_MODE_POLYGON}; 599 for (int i = 0; i < 3; i++) { 600 OH_Drawing_ErrorCodeReset(); 601 OH_Drawing_CanvasDrawPoints(canvas, modeArray[i], 1, points1); 602 // add assert 603 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 604 } 605 606 // 4. OH_Drawing_Point2D creates an array of multiple points. 607 OH_Drawing_Point2D pointOne = {250, 500}; 608 OH_Drawing_Point2D pointTwo = {200, 500}; 609 OH_Drawing_Point2D pointThree = {500, 700}; 610 OH_Drawing_Point2D points2[3] = {pointOne, pointTwo, pointThree}; 611 612 // 5. OH_Drawing_CanvasDrawPoints iterates through the enum values OH_Drawing_PointMode, with count set to the 613 // length of the corresponding value. 614 for (int i = 0; i < 3; i++) { 615 OH_Drawing_ErrorCodeReset(); 616 OH_Drawing_CanvasDrawPoints(canvas, modeArray[i], 3, points2); 617 // add assert 618 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 619 } 620 621 // 6. Free the memory. 622 OH_Drawing_CanvasDestroy(canvas); 623 } 624 625 /* 626 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1401 627 * @tc.name: testCanvasDrawPointsNull 628 * @tc.desc: test for testCanvasDrawPointsNull. 629 * @tc.size : SmallTest 630 * @tc.type : Function 631 * @tc.level : Level 3 632 */ 633 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsNull, TestSize.Level3) 634 { 635 // 1. OH_Drawing_CanvasCreate 636 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 637 EXPECT_NE(canvas, nullptr); 638 639 OH_Drawing_Point2D pointOne = {250, 500}; 640 OH_Drawing_Point2D pointTwo = {200, 500}; 641 OH_Drawing_Point2D pointThree = {500, 700}; 642 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree}; 643 OH_Drawing_Point2D pointsEmpty[0] = {}; 644 645 // 2. Pass an empty value as the first argument for OH_Drawing_CanvasDrawPoints. 646 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_LINES, 3, points); 647 // add assert 648 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 649 650 // 3. Set the third argument of OH_Drawing_CanvasDrawPoints to 0. 651 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 0, points); 652 653 // 4. Pass an empty array as the fourth argument for OH_Drawing_CanvasDrawPoints. 654 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 3, pointsEmpty); 655 656 // 5. Free the memory. 657 OH_Drawing_CanvasDestroy(canvas); 658 } 659 660 /* 661 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1402 662 * @tc.name: testCanvasDrawPointsAbnormal 663 * @tc.desc: test for testCanvasDrawPointsAbnormal. 664 * @tc.size : SmallTest 665 * @tc.type : Function 666 * @tc.level : Level 3 667 */ 668 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsAbnormal, TestSize.Level3) 669 { 670 // 1. OH_Drawing_CanvasCreate 671 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 672 EXPECT_NE(canvas, nullptr); 673 674 // 2. Pass a negative value for the count parameter in OH_Drawing_CanvasDrawPoints. 675 OH_Drawing_Point2D pointOne = {250, 500}; 676 OH_Drawing_Point2D pointTwo = {200, 500}; 677 OH_Drawing_Point2D pointThree = {500, 700}; 678 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree}; 679 680 if (0) { 681 // todo cpp crash 682 // libc++abi: terminating due to uncaught exception of type std::bad_alloc: std::bad_alloc 683 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, -1, points); 684 } 685 686 // 3. Pass a floating-point value for the count parameter in OH_Drawing_CanvasDrawPoints. 687 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1.0f, points); 688 689 // 4. Set the x-coordinate of the point in OH_Drawing_Point2D parameter to a negative number in 690 // OH_Drawing_CanvasDrawPoints. 691 OH_Drawing_Point2D point1 = {-250, 500}; 692 OH_Drawing_Point2D points1[1] = {point1}; 693 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points1); 694 695 // 5. Set the y-coordinate of the point in OH_Drawing_Point2D parameter to a negative number in 696 // OH_Drawing_CanvasDrawPoints. 697 OH_Drawing_Point2D point2 = {250, -500}; 698 OH_Drawing_Point2D points2[1] = {point2}; 699 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2); 700 701 // 6. Set both the x and y coordinates of the point in OH_Drawing_Point2D parameter to negative numbers in 702 // OH_Drawing_CanvasDrawPoints. 703 OH_Drawing_Point2D point3 = {-250, -500}; 704 OH_Drawing_Point2D points3[1] = {point3}; 705 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points3); 706 707 // 7. Free the memory. 708 OH_Drawing_CanvasDestroy(canvas); 709 } 710 711 /* 712 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1403 713 * @tc.name: testCanvasDrawPointsMismatch 714 * @tc.desc: test for testCanvasDrawPointsMismatch. 715 * @tc.size : SmallTest 716 * @tc.type : Function 717 * @tc.level : Level 3 718 */ 719 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsMismatch, TestSize.Level3) 720 { 721 // 1. OH_Drawing_CanvasCreate 722 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 723 EXPECT_NE(canvas, nullptr); 724 725 // 2. Pass an array of OH_Drawing_Point2D with a length of 1 and pass 2 as the count parameter in 726 // OH_Drawing_CanvasDrawPoints. 727 OH_Drawing_Point2D pointOne = {250, 500}; 728 OH_Drawing_Point2D points1[1] = {pointOne}; 729 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 2, points1); 730 731 // 3. Pass an array of OH_Drawing_Point2D with a length of 3 and pass 1 as the count parameter in 732 // OH_Drawing_CanvasDrawPoints. 733 OH_Drawing_Point2D pointOne1 = {250, 500}; 734 OH_Drawing_Point2D pointTwo1 = {200, 500}; 735 OH_Drawing_Point2D pointThree1 = {500, 700}; 736 OH_Drawing_Point2D points2[3] = {pointOne1, pointTwo1, pointThree1}; 737 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2); 738 739 // 4. Free the memory. 740 OH_Drawing_CanvasDestroy(canvas); 741 } 742 743 /* 744 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1404 745 * @tc.name: testCanvasDrawPointsMaximum 746 * @tc.desc: test for testCanvasDrawPointsMaximum. 747 * @tc.size : SmallTest 748 * @tc.type : Function 749 * @tc.level : Level 3 750 */ 751 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsMaximum, TestSize.Level3) 752 { 753 // 1. OH_Drawing_CanvasCreate 754 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 755 EXPECT_NE(canvas, nullptr); 756 757 // 2. Pass an extremely large value for the count parameter in OH_Drawing_CanvasDrawPoints. 758 OH_Drawing_Point2D pointOne = {250, 500}; 759 OH_Drawing_Point2D pointTwo = {200, 500}; 760 OH_Drawing_Point2D pointThree = {500, 700}; 761 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree}; 762 if (0) { 763 // todo cpp crash 764 // libc++abi: terminating due to uncaught exception of type std::bad_alloc: std::bad_alloc 765 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, INT32_MAX, points); 766 } 767 768 // 3. Set the x-coordinate of the point in OH_Drawing_Point2D parameter to an extremely large value in 769 // OH_Drawing_CanvasDrawPoints. 770 OH_Drawing_Point2D point1 = {INT32_MAX, 500}; 771 OH_Drawing_Point2D points1[1] = {point1}; 772 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points1); 773 774 // 4. Set the y-coordinate of the point in OH_Drawing_Point2D parameter to an extremely large value in 775 // OH_Drawing_CanvasDrawPoints. 776 OH_Drawing_Point2D point2 = {250, INT32_MAX}; 777 OH_Drawing_Point2D points2[1] = {point2}; 778 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2); 779 780 // 5. Free the memory. 781 OH_Drawing_CanvasDestroy(canvas); 782 } 783 784 /* 785 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1405 786 * @tc.name: testCanvasDrawPointsInputDestroyed 787 * @tc.desc: test for testCanvasDrawPointsInputDestroyed. 788 * @tc.size : SmallTest 789 * @tc.type : Function 790 * @tc.level : Level 3 791 */ 792 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPointsInputDestroyed, TestSize.Level3) 793 { 794 // Deprecated 795 } 796 797 /* 798 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1500 799 * @tc.name: testCanvasDrawBitmapNormal 800 * @tc.desc: test for testCanvasDrawBitmapNormal. 801 * @tc.size : SmallTest 802 * @tc.type : Function 803 * @tc.level : Level 0 804 */ 805 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapNormal, TestSize.Level0) 806 { 807 // 1. OH_Drawing_CanvasCreate 808 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 809 EXPECT_NE(canvas, nullptr); 810 811 // 2. OH_Drawing_BitmapCreate 812 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 813 EXPECT_NE(bitmap, nullptr); 814 815 // 3. OH_Drawing_CanvasDrawBitmap 816 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 817 // add assert 818 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 819 820 // 4. OH_Drawing_BitmapCreateFromPixels, iterate through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat to 821 // construct OH_Drawing_Image_Info. 822 OH_Drawing_ColorFormat formats[] = { 823 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 824 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 825 }; 826 827 OH_Drawing_AlphaFormat alphaFormats[] = { 828 ALPHA_FORMAT_UNKNOWN, 829 ALPHA_FORMAT_OPAQUE, 830 ALPHA_FORMAT_PREMUL, 831 ALPHA_FORMAT_UNPREMUL, 832 }; 833 834 for (int i = 0; i < 6; i++) { 835 for (int j = 0; j < 4; j++) { 836 OH_Drawing_ErrorCodeReset(); 837 int width = 500; 838 int height = 500; 839 int rowBytes = width * height * 4; 840 OH_Drawing_Image_Info imageInfo = {width, height, formats[i], alphaFormats[j]}; 841 OH_Drawing_BitmapFormat cFormat{formats[i], alphaFormats[j]}; 842 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 843 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 844 // add assert 845 EXPECT_EQ(pixels, nullptr); 846 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 847 // add assert 848 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 849 // 5. OH_Drawing_CanvasDrawBitmap 850 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 851 OH_Drawing_BitmapDestroy(bitmap); 852 } 853 } 854 855 // 6. OH_Drawing_BitmapCreateFromPixels, initialize the Bitmap with rowBytes greater than the image. 856 int width = 500; 857 int height = 500; 858 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 859 int rowBytes = 600 * 600 * 4; 860 void *pixels = new int[width * height]; 861 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 862 863 // 7. OH_Drawing_CanvasDrawBitmap 864 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 865 866 // 8. Free the memory. 867 OH_Drawing_BitmapDestroy(bitmap); 868 OH_Drawing_CanvasDestroy(canvas); 869 } 870 871 /* 872 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1501 873 * @tc.name: testCanvasDrawBitmapNull 874 * @tc.desc: test for testCanvasDrawBitmapNull. 875 * @tc.size : SmallTest 876 * @tc.type : Function 877 * @tc.level : Level 3 878 */ 879 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapNull, TestSize.Level3) 880 { 881 // 1. OH_Drawing_CanvasCreate 882 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 883 EXPECT_NE(canvas, nullptr); 884 885 // 2. OH_Drawing_BitmapCreate 886 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 887 EXPECT_NE(bitmap, nullptr); 888 889 // 3. The first parameter in OH_Drawing_CanvasDrawBitmap is empty. 890 OH_Drawing_CanvasDrawBitmap(nullptr, bitmap, 0, 0); 891 // add assert 892 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 893 OH_Drawing_ErrorCodeReset(); 894 895 // 4. The second parameter in OH_Drawing_CanvasDrawBitmap is empty. 896 OH_Drawing_CanvasDrawBitmap(canvas, nullptr, 0, 0); 897 // add assert 898 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 899 900 // 5. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels 901 // as 47*48. 902 int width = 48; 903 int height = 48; 904 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 905 int rowBytes = width * height * 4; 906 void *pixels = new int[47 * 48]; 907 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 908 909 // 6. OH_Drawing_CanvasDrawBitmap 910 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 911 OH_Drawing_BitmapDestroy(bitmap); 912 913 // 7. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels 914 // as 48*47. 915 width = 48; 916 height = 48; 917 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 918 rowBytes = width * height * 4; 919 pixels = new int[48 * 47]; 920 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 921 922 // 8. OH_Drawing_CanvasDrawBitmap 923 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 924 OH_Drawing_BitmapDestroy(bitmap); 925 926 // 9. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, allocate memory for pixels as 927 // 48*48, and set rowBytes as 47. 928 width = 48; 929 height = 48; 930 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 931 rowBytes = 47; 932 pixels = new int[48 * 48]; 933 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 934 935 // 10. OH_Drawing_CanvasDrawBitmap 936 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 937 938 // 11. The third parameter in OH_Drawing_CanvasDrawBitmap is 0. 939 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 940 941 // 12. The fourth parameter in OH_Drawing_CanvasDrawBitmap is 0. 942 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 943 944 // 13. Free the memory. 945 OH_Drawing_BitmapDestroy(bitmap); 946 OH_Drawing_CanvasDestroy(canvas); 947 } 948 949 /* 950 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1502 951 * @tc.name: testCanvasDrawBitmapAbnormal 952 * @tc.desc: test for testCanvasDrawBitmapAbnormal. 953 * @tc.size : SmallTest 954 * @tc.type : Function 955 * @tc.level : Level 3 956 */ 957 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapAbnormal, TestSize.Level3) 958 { 959 // 1. OH_Drawing_CanvasCreate 960 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 961 EXPECT_NE(canvas, nullptr); 962 963 // 2. OH_Drawing_BitmapCreate 964 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 965 EXPECT_NE(bitmap, nullptr); 966 967 // 3. The x-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is negative. 968 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, -1, 0); 969 970 // 4. The y-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is negative. 971 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, -1); 972 973 // 5. Free the memory. 974 OH_Drawing_BitmapDestroy(bitmap); 975 OH_Drawing_CanvasDestroy(canvas); 976 } 977 978 /* 979 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1503 980 * @tc.name: testCanvasDrawBitmapMaximum 981 * @tc.desc: test for testCanvasDrawBitmapMaximum. 982 * @tc.size : SmallTest 983 * @tc.type : Function 984 * @tc.level : Level 3 985 */ 986 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapMaximum, TestSize.Level3) 987 { 988 // 1. OH_Drawing_CanvasCreate 989 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 990 EXPECT_NE(canvas, nullptr); 991 992 // 2. OH_Drawing_BitmapCreate 993 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 994 EXPECT_NE(bitmap, nullptr); 995 996 // 3. The x-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is set to a very 997 // large value. 998 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, FLT_MAX, 0); 999 1000 // 4. The y-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is set to a very 1001 // large value. 1002 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, FLT_MAX); 1003 1004 // 5. Free the memory. 1005 OH_Drawing_BitmapDestroy(bitmap); 1006 OH_Drawing_CanvasDestroy(canvas); 1007 } 1008 1009 /* 1010 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1504 1011 * @tc.name: testCanvasDrawBitmapInputDestroyed 1012 * @tc.desc: test for testCanvasDrawBitmapInputDestroyed. 1013 * @tc.size : SmallTest 1014 * @tc.type : Function 1015 * @tc.level : Level 3 1016 */ 1017 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapInputDestroyed, TestSize.Level3) 1018 { 1019 // Deprecated 1020 } 1021 1022 /* 1023 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1505 1024 * @tc.name: testCanvasDrawBitmapBoundary 1025 * @tc.desc: test for testCanvasDrawBitmapBoundary. 1026 * @tc.size : SmallTest 1027 * @tc.type : Function 1028 * @tc.level : Level 0 1029 */ 1030 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapBoundary, TestSize.Level0) 1031 { 1032 // 1. OH_Drawing_CanvasCreate 1033 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1034 EXPECT_NE(canvas, nullptr); 1035 1036 // 2. OH_Drawing_BitmapCreate 1037 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1038 EXPECT_NE(bitmap, nullptr); 1039 1040 // 3. OH_Drawing_CanvasDrawBitmap 1041 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1042 1043 // 4. OH_Drawing_BitmapCreateFromPixels, iterate through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat to 1044 // construct OH_Drawing_Image_Info. 1045 OH_Drawing_ColorFormat formats[] = { 1046 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 1047 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 1048 }; 1049 1050 OH_Drawing_AlphaFormat alphaFormats[] = { 1051 ALPHA_FORMAT_UNKNOWN, 1052 ALPHA_FORMAT_OPAQUE, 1053 ALPHA_FORMAT_PREMUL, 1054 ALPHA_FORMAT_UNPREMUL, 1055 }; 1056 1057 int width = 4096; 1058 int height = 2160; 1059 for (int i = 0; i < 6; i++) { 1060 for (int j = 0; j < 4; j++) { 1061 int rowBytes = width * height * 4; 1062 OH_Drawing_Image_Info imageInfo = {width, height, formats[i], alphaFormats[j]}; 1063 OH_Drawing_BitmapFormat cFormat{formats[i], alphaFormats[j]}; 1064 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1065 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1066 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1067 // 5. OH_Drawing_CanvasDrawBitmap 1068 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1069 OH_Drawing_BitmapDestroy(bitmap); 1070 } 1071 } 1072 1073 // 6. OH_Drawing_BitmapCreateFromPixels, initialize the Bitmap with rowBytes greater than the image. 1074 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1075 int rowBytes = 600 * 600 * 4; 1076 void *pixels = new int[width * height]; 1077 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1078 1079 // 7. OH_Drawing_CanvasDrawBitmap 1080 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1081 1082 // 8. Free the memory. 1083 OH_Drawing_BitmapDestroy(bitmap); 1084 OH_Drawing_CanvasDestroy(canvas); 1085 } 1086 1087 /* 1088 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1600 1089 * @tc.name: testCanvasDrawBitmapRectNormal 1090 * @tc.desc: test for testCanvasDrawBitmapRectNormal. 1091 * @tc.size : SmallTest 1092 * @tc.type : Function 1093 * @tc.level : Level 0 1094 */ 1095 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectNormal, TestSize.Level0) 1096 { 1097 // 1. OH_Drawing_CanvasCreate 1098 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1099 EXPECT_NE(canvas, nullptr); 1100 // 2. OH_Drawing_BitmapCreate 1101 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1102 EXPECT_NE(bitmap, nullptr); 1103 // 3. OH_Drawing_RectCreate src and dst 1104 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 1105 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 1106 // 4. OH_Drawing_CanvasDrawBitmap 1107 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1108 // 5. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct 1109 // OH_Drawing_SamplingOptions 1110 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR}; 1111 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE}; 1112 for (int i = 0; i < 2; i++) { 1113 for (int j = 0; j < 3; j++) { 1114 OH_Drawing_ErrorCodeReset(); 1115 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]); 1116 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1117 // add assert 1118 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1119 OH_Drawing_SamplingOptionsDestroy(options); 1120 } 1121 } 1122 // 6. OH_Drawing_CanvasDrawBitmap 1123 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1124 OH_Drawing_BitmapDestroy(bitmap); 1125 // 7. OH_Drawing_BitmapCreateFromPixels, initialize Bitmap with a rowBytes larger than the image 1126 int width = 500; 1127 int height = 500; 1128 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1129 int rowBytes = 600 * 600 * 4; 1130 void *pixels = new int[width * height]; 1131 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1132 // 8. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct 1133 // OH_Drawing_SamplingOptions 1134 for (int i = 0; i < 2; i++) { 1135 for (int j = 0; j < 3; j++) { 1136 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]); 1137 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1138 OH_Drawing_SamplingOptionsDestroy(options); 1139 } 1140 } 1141 // 9. CanvasDrawBitmapRect with src parameter set to nullptr 1142 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR); 1143 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, nullptr, dst, options); 1144 // add assert 1145 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1146 // 10. Free memory 1147 OH_Drawing_RectDestroy(src); 1148 OH_Drawing_RectDestroy(dst); 1149 OH_Drawing_BitmapDestroy(bitmap); 1150 OH_Drawing_CanvasDestroy(canvas); 1151 OH_Drawing_SamplingOptionsDestroy(options); 1152 } 1153 1154 /* 1155 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1601 1156 * @tc.name: testCanvasDrawBitmapRectNull 1157 * @tc.desc: test for testCanvasDrawBitmapRectNull. 1158 * @tc.size : SmallTest 1159 * @tc.type : Function 1160 * @tc.level : Level 3 1161 */ 1162 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectNull, TestSize.Level3) 1163 { 1164 // 1. OH_Drawing_CanvasCreate 1165 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1166 EXPECT_NE(canvas, nullptr); 1167 1168 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate 1169 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1170 EXPECT_NE(bitmap, nullptr); 1171 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR); 1172 1173 // 3. OH_Drawing_CanvasDrawBitmapRect with the first parameter set to nullptr 1174 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200); 1175 EXPECT_NE(src, nullptr); 1176 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 1177 EXPECT_NE(dst, nullptr); 1178 OH_Drawing_CanvasDrawBitmapRect(nullptr, bitmap, src, dst, options); 1179 // add assert 1180 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1181 OH_Drawing_ErrorCodeReset(); 1182 1183 // 4. OH_Drawing_CanvasDrawBitmapRect with the second parameter set to nullptr 1184 OH_Drawing_CanvasDrawBitmapRect(canvas, nullptr, src, dst, options); 1185 // add assert 1186 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1187 1188 // 5. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels 1189 // as 47*48. 1190 int width = 48; 1191 int height = 48; 1192 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1193 int rowBytes = width * height * 4; 1194 void *pixels = new int[47 * 48]; 1195 OH_Drawing_BitmapDestroy(bitmap); 1196 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1197 1198 // 6. OH_Drawing_CanvasDrawBitmapRect 1199 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1200 1201 // 7. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels 1202 // as 48*47. 1203 width = 48; 1204 height = 48; 1205 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1206 rowBytes = width * height * 4; 1207 pixels = new int[48 * 47]; 1208 OH_Drawing_BitmapDestroy(bitmap); 1209 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1210 1211 // 8. OH_Drawing_CanvasDrawBitmapRect 1212 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1213 1214 // 9. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, allocate memory for pixels as 1215 // 48*48, and set rowBytes as 47. 1216 width = 48; 1217 height = 48; 1218 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1219 rowBytes = 47; 1220 pixels = new int[48 * 48]; 1221 OH_Drawing_BitmapDestroy(bitmap); 1222 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1223 1224 // 10. OH_Drawing_CanvasDrawBitmapRect 1225 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1226 1227 // 11. OH_Drawing_CanvasDrawBitmapRect with the fourth parameter set to nullptr 1228 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, nullptr); 1229 1230 // 12. OH_Drawing_CanvasDrawBitmapRect with the fifth parameter set to nullptr 1231 // error: no matching function for call to 'OH_Drawing_CanvasDrawBitmapRect' 1232 1233 // 13. Free memory 1234 OH_Drawing_CanvasDestroy(canvas); 1235 OH_Drawing_BitmapDestroy(bitmap); 1236 OH_Drawing_RectDestroy(src); 1237 OH_Drawing_RectDestroy(dst); 1238 OH_Drawing_SamplingOptionsDestroy(options); 1239 } 1240 1241 /* 1242 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1602 1243 * @tc.name: testCanvasDrawBitmapRectAbnormal 1244 * @tc.desc: test for testCanvasDrawBitmapRectAbnormal. 1245 * @tc.size : SmallTest 1246 * @tc.type : Function 1247 * @tc.level : Level 3 1248 */ 1249 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectAbnormal, TestSize.Level3) 1250 { 1251 // 1. OH_Drawing_CanvasCreate 1252 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1253 EXPECT_NE(canvas, nullptr); 1254 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate 1255 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1256 EXPECT_NE(bitmap, nullptr); 1257 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR); 1258 // 3. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect created with negative values for left, top, right, bottom 1259 OH_Drawing_Rect *src = OH_Drawing_RectCreate(-100, -100, -50, -50); 1260 EXPECT_NE(src, nullptr); 1261 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(-100, -100, -50, -50); 1262 EXPECT_NE(dst, nullptr); 1263 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1264 // 4. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with the top-left coordinate equal to the 1265 // bottom-right coordinate 1266 src = OH_Drawing_RectCreate(100, 100, 100, 100); 1267 EXPECT_NE(src, nullptr); 1268 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1269 // 5. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with the top-left coordinate greater than the 1270 // bottom-right coordinate 1271 src = OH_Drawing_RectCreate(200, 200, 100, 100); 1272 EXPECT_NE(src, nullptr); 1273 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1274 // 6. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate equal to the 1275 // bottom-right coordinate 1276 dst = OH_Drawing_RectCreate(100, 100, 100, 100); 1277 EXPECT_NE(dst, nullptr); 1278 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1279 // 7. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate greater than the 1280 // bottom-right coordinate 1281 dst = OH_Drawing_RectCreate(200, 200, 100, 100); 1282 EXPECT_NE(dst, nullptr); 1283 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1284 // 8. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate equal to the 1285 // bottom-right coordinate 1286 dst = OH_Drawing_RectCreate(100, 100, 100, 100); 1287 EXPECT_NE(dst, nullptr); 1288 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1289 // 9. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate greater than the 1290 // bottom-right coordinate 1291 dst = OH_Drawing_RectCreate(200, 200, 100, 100); 1292 EXPECT_NE(dst, nullptr); 1293 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1294 // 10. Free memory 1295 OH_Drawing_CanvasDestroy(canvas); 1296 OH_Drawing_BitmapDestroy(bitmap); 1297 OH_Drawing_RectDestroy(src); 1298 OH_Drawing_RectDestroy(dst); 1299 OH_Drawing_SamplingOptionsDestroy(options); 1300 } 1301 1302 /* 1303 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1603 1304 * @tc.name: testCanvasDrawBitmapRectMaximum 1305 * @tc.desc: test for testCanvasDrawBitmapRectMaximum. 1306 * @tc.size : SmallTest 1307 * @tc.type : Function 1308 * @tc.level : Level 3 1309 */ 1310 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectMaximum, TestSize.Level3) 1311 { 1312 // 1. OH_Drawing_CanvasCreate 1313 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1314 EXPECT_NE(canvas, nullptr); 1315 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate 1316 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1317 EXPECT_NE(bitmap, nullptr); 1318 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR); 1319 // 3. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with maximum values for the top-left 1320 // coordinate 1321 OH_Drawing_Rect *src = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 200, 200); 1322 EXPECT_NE(src, nullptr); 1323 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200); 1324 EXPECT_NE(dst, nullptr); 1325 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1326 // 4. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with maximum values for the top-right 1327 // coordinate 1328 src = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 1329 EXPECT_NE(src, nullptr); 1330 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1331 // 5. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with maximum values for the top-left 1332 // coordinate 1333 dst = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 200, 200); 1334 EXPECT_NE(dst, nullptr); 1335 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1336 // 6. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with maximum values for the top-right 1337 // coordinate 1338 dst = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 1339 EXPECT_NE(dst, nullptr); 1340 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1341 // 7. Free memory 1342 OH_Drawing_CanvasDestroy(canvas); 1343 OH_Drawing_BitmapDestroy(bitmap); 1344 OH_Drawing_RectDestroy(src); 1345 OH_Drawing_RectDestroy(dst); 1346 OH_Drawing_SamplingOptionsDestroy(options); 1347 } 1348 1349 /* 1350 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1604 1351 * @tc.name: testCanvasDrawBitmapRectInputDestroyed 1352 * @tc.desc: test for testCanvasDrawBitmapRectInputDestroyed. 1353 * @tc.size : SmallTest 1354 * @tc.type : Function 1355 * @tc.level : Level 3 1356 */ 1357 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectInputDestroyed, TestSize.Level3) 1358 { 1359 // Deprecated 1360 } 1361 1362 /* 1363 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1605 1364 * @tc.name: testCanvasDrawBitmapRectBoundary 1365 * @tc.desc: test for testCanvasDrawBitmapRectBoundary. 1366 * @tc.size : SmallTest 1367 * @tc.type : Function 1368 * @tc.level : Level 0 1369 */ 1370 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawBitmapRectBoundary, TestSize.Level0) 1371 { 1372 // 1. OH_Drawing_CanvasCreate 1373 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1374 EXPECT_NE(canvas, nullptr); 1375 // 2. OH_Drawing_BitmapCreate 1376 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1377 EXPECT_NE(bitmap, nullptr); 1378 // 3. OH_Drawing_RectCreate src and dst 1379 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 1380 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 1381 // 4. OH_Drawing_CanvasDrawBitmap 1382 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1383 // 5. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct 1384 // OH_Drawing_SamplingOptions 1385 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR}; 1386 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE}; 1387 for (int i = 0; i < 2; i++) { 1388 for (int j = 0; j < 3; j++) { 1389 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]); 1390 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1391 OH_Drawing_SamplingOptionsDestroy(options); 1392 } 1393 } 1394 // 6. OH_Drawing_CanvasDrawBitmap 1395 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0); 1396 OH_Drawing_BitmapDestroy(bitmap); 1397 // 7. OH_Drawing_BitmapCreateFromPixels, initialize Bitmap with a rowBytes larger than the image 1398 int width = 4096; 1399 int height = 2160; 1400 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN}; 1401 int rowBytes = 600 * 600 * 4; 1402 void *pixels = new int[width * height]; 1403 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 1404 // 8. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct 1405 // OH_Drawing_SamplingOptions 1406 for (int i = 0; i < 2; i++) { 1407 for (int j = 0; j < 3; j++) { 1408 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]); 1409 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options); 1410 OH_Drawing_SamplingOptionsDestroy(options); 1411 } 1412 } 1413 // 9. CanvasDrawBitmapRect with src parameter set to nullptr 1414 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR); 1415 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, nullptr, dst, options); 1416 // 10. Free memory 1417 OH_Drawing_RectDestroy(src); 1418 OH_Drawing_RectDestroy(dst); 1419 OH_Drawing_BitmapDestroy(bitmap); 1420 OH_Drawing_CanvasDestroy(canvas); 1421 OH_Drawing_SamplingOptionsDestroy(options); 1422 } 1423 1424 /* 1425 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1700 1426 * @tc.name: testCanvasDrawRectNormal 1427 * @tc.desc: test for testCanvasDrawRectNormal. 1428 * @tc.size : SmallTest 1429 * @tc.type : Function 1430 * @tc.level : Level 0 1431 */ 1432 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRectNormal, TestSize.Level0) 1433 { 1434 // 1. OH_Drawing_CanvasCreate 1435 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1436 EXPECT_NE(canvas, nullptr); 1437 // 2. OH_Drawing_RectCreate 1438 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 1439 EXPECT_NE(rect, nullptr); 1440 // 3. OH_Drawing_CanvasDrawRect 1441 OH_Drawing_CanvasDrawRect(canvas, rect); 1442 // 4. Free memory 1443 OH_Drawing_CanvasDestroy(canvas); 1444 OH_Drawing_RectDestroy(rect); 1445 } 1446 1447 /* 1448 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1701 1449 * @tc.name: testCanvasDrawRectNull 1450 * @tc.desc: test for testCanvasDrawRectNull. 1451 * @tc.size : SmallTest 1452 * @tc.type : Function 1453 * @tc.level : Level 3 1454 */ 1455 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRectNull, TestSize.Level3) 1456 { 1457 // 1. OH_Drawing_CanvasCreate 1458 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1459 EXPECT_NE(canvas, nullptr); 1460 // 2. OH_Drawing_RectCreate 1461 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 1462 EXPECT_NE(rect, nullptr); 1463 // 3. OH_Drawing_CanvasDrawRect with the first parameter being null 1464 OH_Drawing_CanvasDrawRect(canvas, nullptr); 1465 // add assert 1466 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1467 OH_Drawing_ErrorCodeReset(); 1468 // 4. OH_Drawing_CanvasDrawRect with the second parameter being null 1469 OH_Drawing_CanvasDrawRect(nullptr, rect); 1470 // add assert 1471 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1472 // 5. OH_Drawing_CanvasDrawRect with the second parameter OH_Drawing_Rect created with left, top, right, bottom 1473 // respectively set to 0 1474 rect = OH_Drawing_RectCreate(0, 200, 200, 200); 1475 OH_Drawing_CanvasDrawRect(canvas, rect); 1476 rect = OH_Drawing_RectCreate(200, 0, 200, 200); 1477 OH_Drawing_CanvasDrawRect(canvas, rect); 1478 rect = OH_Drawing_RectCreate(200, 200, 0, 200); 1479 OH_Drawing_CanvasDrawRect(canvas, rect); 1480 rect = OH_Drawing_RectCreate(200, 200, 200, 0); 1481 OH_Drawing_CanvasDrawRect(canvas, rect); 1482 // 6. OH_Drawing_CanvasDrawRect with the second parameter OH_Drawing_Rect created with all values set to 0 1483 rect = OH_Drawing_RectCreate(0, 0, 0, 0); 1484 EXPECT_NE(rect, nullptr); 1485 OH_Drawing_CanvasDrawRect(canvas, rect); 1486 // 7. Free memory 1487 OH_Drawing_CanvasDestroy(canvas); 1488 OH_Drawing_RectDestroy(rect); 1489 } 1490 1491 /* 1492 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1702 1493 * @tc.name: testCanvasDrawRectAbnormal 1494 * @tc.desc: test for testCanvasDrawRectAbnormal. 1495 * @tc.size : SmallTest 1496 * @tc.type : Function 1497 * @tc.level : Level 3 1498 */ 1499 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRectAbnormal, TestSize.Level3) 1500 { 1501 // 1. OH_Drawing_CanvasCreate 1502 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1503 EXPECT_NE(canvas, nullptr); 1504 1505 // 2. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with left, top, right, bottom being negative numbers 1506 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-100, 100, 50, 50); 1507 // add assert 1508 EXPECT_NE(rect, nullptr); 1509 OH_Drawing_CanvasDrawRect(canvas, rect); 1510 rect = OH_Drawing_RectCreate(100, -100, 50, 50); 1511 // add assert 1512 EXPECT_NE(rect, nullptr); 1513 OH_Drawing_CanvasDrawRect(canvas, rect); 1514 rect = OH_Drawing_RectCreate(100, 100, -50, 50); 1515 // add assert 1516 EXPECT_NE(rect, nullptr); 1517 OH_Drawing_CanvasDrawRect(canvas, rect); 1518 rect = OH_Drawing_RectCreate(100, 100, 50, -50); 1519 // add assert 1520 EXPECT_NE(rect, nullptr); 1521 OH_Drawing_CanvasDrawRect(canvas, rect); 1522 1523 // 3. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate equal to the bottom-right 1524 // coordinate 1525 rect = OH_Drawing_RectCreate(100, 100, 100, 100); 1526 // add assert 1527 EXPECT_NE(rect, nullptr); 1528 OH_Drawing_CanvasDrawRect(canvas, rect); 1529 1530 rect = OH_Drawing_RectCreate(200, 200, 200, 200); 1531 // add assert 1532 EXPECT_NE(rect, nullptr); 1533 OH_Drawing_CanvasDrawRect(canvas, rect); 1534 1535 // 4. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate equal to the bottom-right 1536 // coordinate 1537 rect = OH_Drawing_RectCreate(200, 200, 200, 200); 1538 // add assert 1539 EXPECT_NE(rect, nullptr); 1540 OH_Drawing_CanvasDrawRect(canvas, rect); 1541 1542 // 5. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate greater than the 1543 // bottom-right coordinate 1544 rect = OH_Drawing_RectCreate(200, 200, 100, 100); 1545 // add assert 1546 EXPECT_NE(rect, nullptr); 1547 OH_Drawing_CanvasDrawRect(canvas, rect); 1548 1549 // 6. Free memory 1550 OH_Drawing_CanvasDestroy(canvas); 1551 OH_Drawing_RectDestroy(rect); 1552 } 1553 1554 /* 1555 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1703 1556 * @tc.name: testCanvasDrawRectMaximum 1557 * @tc.desc: test for testCanvasDrawRectMaximum. 1558 * @tc.size : SmallTest 1559 * @tc.type : Function 1560 * @tc.level : Level 3 1561 */ 1562 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRectMaximum, TestSize.Level3) 1563 { 1564 // 1. OH_Drawing_CanvasCreate 1565 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1566 EXPECT_NE(canvas, nullptr); 1567 1568 // 2. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with left, top, right, bottom set to maximum values 1569 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 200, 200, 200); 1570 // add assert 1571 EXPECT_NE(rect, nullptr); 1572 OH_Drawing_CanvasDrawRect(canvas, rect); 1573 rect = OH_Drawing_RectCreate(200, FLT_MAX, 200, 200); 1574 // add assert 1575 EXPECT_NE(rect, nullptr); 1576 OH_Drawing_CanvasDrawRect(canvas, rect); 1577 rect = OH_Drawing_RectCreate(200, 200, FLT_MAX, 200); 1578 // add assert 1579 EXPECT_NE(rect, nullptr); 1580 OH_Drawing_CanvasDrawRect(canvas, rect); 1581 rect = OH_Drawing_RectCreate(200, 200, 200, FLT_MAX); 1582 // add assert 1583 EXPECT_NE(rect, nullptr); 1584 OH_Drawing_CanvasDrawRect(canvas, rect); 1585 1586 // 3. Free memory 1587 OH_Drawing_CanvasDestroy(canvas); 1588 } 1589 1590 /* 1591 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1704 1592 * @tc.name: testCanvasDrawRectInputDestroyed 1593 * @tc.desc: test for testCanvasDrawRectInputDestroyed. 1594 * @tc.size : SmallTest 1595 * @tc.type : Function 1596 * @tc.level : Level 3 1597 */ 1598 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawRectInputDestroyed, TestSize.Level3) 1599 { 1600 // Deprecated 1601 } 1602 1603 /* 1604 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1800 1605 * @tc.name: testCanvasDrawCircleNormal 1606 * @tc.desc: test for testCanvasDrawCircleNormal. 1607 * @tc.size : SmallTest 1608 * @tc.type : Function 1609 * @tc.level : Level 0 1610 */ 1611 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawCircleNormal, TestSize.Level0) 1612 { 1613 // 1. OH_Drawing_CanvasCreate 1614 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1615 EXPECT_NE(canvas, nullptr); 1616 // 2. OH_Drawing_PointCreate 1617 OH_Drawing_Point *center = OH_Drawing_PointCreate(100, 100); 1618 EXPECT_NE(center, nullptr); 1619 // 3. OH_Drawing_CanvasDrawCircle 1620 OH_Drawing_CanvasDrawCircle(canvas, center, 50); 1621 // add assert 1622 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1623 // 4. Free memory 1624 OH_Drawing_CanvasDestroy(canvas); 1625 OH_Drawing_PointDestroy(center); 1626 } 1627 1628 /* 1629 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1801 1630 * @tc.name: testCanvasDrawCircleNull 1631 * @tc.desc: test for testCanvasDrawCircleNull. 1632 * @tc.size : SmallTest 1633 * @tc.type : Function 1634 * @tc.level : Level 3 1635 */ 1636 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawCircleNull, TestSize.Level3) 1637 { 1638 // 1. OH_Drawing_CanvasCreate 1639 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1640 EXPECT_NE(canvas, nullptr); 1641 // 2. OH_Drawing_PointCreate 1642 OH_Drawing_Point *center = OH_Drawing_PointCreate(100, 100); 1643 EXPECT_NE(center, nullptr); 1644 // 3. OH_Drawing_CanvasDrawCircle with the first parameter being null 1645 OH_Drawing_CanvasDrawCircle(nullptr, center, 50); 1646 // add assert 1647 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1648 OH_Drawing_ErrorCodeReset(); 1649 // 4. OH_Drawing_CanvasDrawCircle with the second parameter being null 1650 OH_Drawing_CanvasDrawCircle(canvas, nullptr, 50); 1651 // add assert 1652 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1653 // 5. OH_Drawing_CanvasDrawCircle with the third parameter being 0 1654 OH_Drawing_CanvasDrawCircle(canvas, center, 0); 1655 // add assert 1656 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE); 1657 // 6. Free memory 1658 OH_Drawing_CanvasDestroy(canvas); 1659 OH_Drawing_PointDestroy(center); 1660 } 1661 1662 /* 1663 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1802 1664 * @tc.name: testCanvasDrawCircleAbnormal 1665 * @tc.desc: test for testCanvasDrawCircleAbnormal. 1666 * @tc.size : SmallTest 1667 * @tc.type : Function 1668 * @tc.level : Level 3 1669 */ 1670 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawCircleAbnormal, TestSize.Level3) 1671 { 1672 // 1. OH_Drawing_CanvasCreate 1673 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1674 EXPECT_NE(canvas, nullptr); 1675 // 2. OH_Drawing_PointCreate with x parameter being negative 1676 OH_Drawing_Point *center = OH_Drawing_PointCreate(-100, 100); 1677 // add assert 1678 EXPECT_NE(center, nullptr); 1679 // 3. OH_Drawing_CanvasDrawCircle 1680 OH_Drawing_CanvasDrawCircle(canvas, center, 50); 1681 // 4. OH_Drawing_PointCreate with y parameter being negative 1682 center = OH_Drawing_PointCreate(100, -100); 1683 // add assert 1684 EXPECT_NE(center, nullptr); 1685 OH_Drawing_CanvasDrawCircle(canvas, center, 50); 1686 // 5. OH_Drawing_CanvasDrawCircle with radius parameter being negative 1687 OH_Drawing_CanvasDrawCircle(canvas, center, -50); 1688 // 6. Free memory 1689 OH_Drawing_CanvasDestroy(canvas); 1690 OH_Drawing_PointDestroy(center); 1691 } 1692 1693 /* 1694 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1803 1695 * @tc.name: testCanvasDrawCircleMaximum 1696 * @tc.desc: test for testCanvasDrawCircleMaximum. 1697 * @tc.size : SmallTest 1698 * @tc.type : Function 1699 * @tc.level : Level 3 1700 */ 1701 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawCircleMaximum, TestSize.Level3) 1702 { 1703 // 1. OH_Drawing_CanvasCreate 1704 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1705 EXPECT_NE(canvas, nullptr); 1706 // 2. OH_Drawing_PointCreate with x parameter set to the maximum value 1707 OH_Drawing_Point *center = OH_Drawing_PointCreate(FLT_MAX, 100); 1708 EXPECT_NE(center, nullptr); 1709 // 3. OH_Drawing_CanvasDrawCircle 1710 OH_Drawing_CanvasDrawCircle(canvas, center, 50); 1711 // 4. OH_Drawing_PointCreate with y parameter set to the maximum value 1712 center = OH_Drawing_PointCreate(100, FLT_MAX); 1713 EXPECT_NE(center, nullptr); 1714 // 5. OH_Drawing_CanvasDrawCircle 1715 OH_Drawing_CanvasDrawCircle(canvas, center, 50); 1716 // 6. OH_Drawing_CanvasDrawCircle with radius parameter set to the maximum value 1717 OH_Drawing_CanvasDrawCircle(canvas, center, FLT_MAX); 1718 // 7. Free memory 1719 OH_Drawing_CanvasDestroy(canvas); 1720 OH_Drawing_PointDestroy(center); 1721 } 1722 1723 /* 1724 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1804 1725 * @tc.name: testCanvasDrawCircleInputDestroyed 1726 * @tc.desc: test for testCanvasDrawCircleInputDestroyed. 1727 * @tc.size : SmallTest 1728 * @tc.type : Function 1729 * @tc.level : Level 3 1730 */ 1731 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawCircleInputDestroyed, TestSize.Level3) 1732 { 1733 // Deprecated 1734 } 1735 1736 /* 1737 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4BYTEALIGNMENT 1738 * @tc.name: testCanvasDrawPixelMapRect4ByteAlignment 1739 * @tc.desc: test for Canvas Draw PixelMap Rect 4ByteAlignment. 1740 * @tc.size : SmallTest 1741 * @tc.type : Function 1742 * @tc.level : Level 3 1743 */ 1744 HWTEST_F(DrawingNativeCanvasPart2Test, testCanvasDrawPixelMapRect4ByteAlignment, TestSize.Level3) 1745 { 1746 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1747 EXPECT_NE(canvas, nullptr); 1748 1749 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative_4ByteAlignment(); 1750 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap); 1751 EXPECT_NE(drPixelMap, nullptr); 1752 1753 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100); 1754 EXPECT_NE(src, nullptr); 1755 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100); 1756 EXPECT_NE(dst, nullptr); 1757 1758 OH_Drawing_SamplingOptions *sampleOptions = 1759 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 1760 // 2 1761 OH_Drawing_Rect *src1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 1762 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src1, dst, sampleOptions); 1763 // 3 1764 OH_Drawing_Rect *src2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 1765 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src2, dst, sampleOptions); 1766 // 4 1767 OH_Drawing_Rect *dst1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100); 1768 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst1, sampleOptions); 1769 // 5 1770 OH_Drawing_Rect *dst2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX); 1771 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst2, sampleOptions); 1772 // 6 1773 OH_Drawing_RectDestroy(src1); 1774 OH_Drawing_RectDestroy(src2); 1775 OH_Drawing_RectDestroy(dst1); 1776 OH_Drawing_RectDestroy(dst2); 1777 OH_Drawing_RectDestroy(src); 1778 OH_Drawing_RectDestroy(dst); 1779 OH_Drawing_SamplingOptionsDestroy(sampleOptions); 1780 OH_Drawing_PixelMapDissolve(drPixelMap); 1781 OH_Drawing_CanvasDestroy(canvas); 1782 } 1783 } // namespace Drawing 1784 } // namespace Rosen 1785 } // namespace OHOS