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 "drawing_bitmap.h" 17 #include "drawing_error_code.h" 18 #include "drawing_image.h" 19 #include "gtest/gtest.h" 20 #include <cstdlib> 21 #include <ctime> 22 23 using namespace testing; 24 using namespace testing::ext; 25 26 namespace OHOS { 27 namespace Rosen { 28 namespace Drawing { 29 class DrawingNativeImageTest : public testing::Test { 30 protected: 31 // 在每个测试用例执行前调用 SetUp()32 void SetUp() override 33 { 34 // 设置代码 35 std::cout << "DrawingNativeImageTest Setup code called before each test case." << std::endl; 36 OH_Drawing_ErrorCodeReset(); 37 std::cout << "DrawingNativeImageTest errorCodeReset before each test case." << std::endl; 38 } TearDown()39 void TearDown() override 40 { 41 std::cout << "DrawingNativeImageTest Setup code called after each test case." << std::endl; 42 OH_Drawing_ErrorCodeReset(); 43 std::cout << "DrawingNativeImageTest errorCodeReset after each test case." << std::endl; 44 } 45 }; 46 47 /* 48 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0100 49 * @tc.name: testImageCreateDestroyNormal 50 * @tc.desc: Test for creating and destroying an image object with normal parameters. 51 * @tc.size : SmallTest 52 * @tc.type : Function 53 * @tc.level : Level 0 54 */ 55 HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyNormal, Function | SmallTest | Level0) { 56 // 1. OH_Drawing_ImageCreate 57 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 58 // add assert 59 EXPECT_NE(image, nullptr); 60 // 2. OH_Drawing_ImageDestroy 61 OH_Drawing_ImageDestroy(image); 62 } 63 64 /* 65 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0101 66 * @tc.name: testImageCreateDestroyNULL 67 * @tc.desc: Test for destroying an image object with a NULL parameter. 68 * @tc.size : SmallTest 69 * @tc.type : Function 70 * @tc.level : Level 3 71 */ 72 HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyNULL, Function | SmallTest | Level3) { 73 // 1. OH_Drawing_ImageDestroy with a NULL parameter 74 OH_Drawing_ImageDestroy(nullptr); 75 // add assert 76 EXPECT_TRUE(true); 77 } 78 79 /* 80 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0102 81 * @tc.name: testImageCreateDestroyMultipleCalls 82 * @tc.desc: Test for multiple calls of creating and destroying an image object. 83 * @tc.size : SmallTest 84 * @tc.type : Function 85 * @tc.level : Level 3 86 */ 87 HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyMultipleCalls, Function | SmallTest | Level3) { 88 // 1. Call OH_Drawing_ImageCreate and OH_Drawing_ImageDestroy 10 times 89 for (int i = 0; i < 10; i++) { 90 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 91 // add assert 92 EXPECT_NE(image, nullptr); 93 OH_Drawing_ImageDestroy(image); 94 } 95 // 2. Call OH_Drawing_ImageCreate 10 times continuously 96 OH_Drawing_Image *images[10]; 97 for (int i = 0; i < 10; i++) { 98 images[i] = OH_Drawing_ImageCreate(); 99 // add assert 100 EXPECT_NE(images[i], nullptr); 101 } 102 // 3. Call OH_Drawing_ImageDestroy 10 times continuously 103 for (int i = 0; i < 10; i++) { 104 OH_Drawing_ImageDestroy(images[i]); 105 } 106 } 107 108 /* 109 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0200 110 * @tc.name: testImageBuildFromBitmapNormal 111 * @tc.desc: Test for building an image from a bitmap with normal parameters. 112 * @tc.size : SmallTest 113 * @tc.type : Function 114 * @tc.level : Level 0 115 */ 116 HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapNormal, Function | SmallTest | Level0) { 117 // 1. OH_Drawing_ImageCreate 118 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 119 // add assert 120 EXPECT_NE(image, nullptr); 121 // 2. OH_Drawing_BitmapCreate 122 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 123 // 3. OH_Drawing_ImageBuildFromBitmap successfully constructs the image content 124 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 125 // add assert 126 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 127 EXPECT_NE(bitmap, nullptr); 128 // 4. OH_Drawing_ImageBuildFromBitmap fails to construct the image content 129 OH_Drawing_ImageBuildFromBitmap(image, nullptr); 130 // add assert 131 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 132 // 5. Free memory 133 OH_Drawing_ImageDestroy(image); 134 OH_Drawing_BitmapDestroy(bitmap); 135 } 136 137 /* 138 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0201 139 * @tc.name: testImageBuildFromBitmapNULL 140 * @tc.desc: Test for building an image from a bitmap with NULL parameters. 141 * @tc.size : SmallTest 142 * @tc.type : Function 143 * @tc.level : Level 3 144 */ 145 HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapNULL, Function | SmallTest | Level3) { 146 // 1. OH_Drawing_ImageCreate 147 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 148 // add assert 149 EXPECT_NE(image, nullptr); 150 // 2. OH_Drawing_BitmapCreate 151 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 152 // add assert 153 EXPECT_NE(bitmap, nullptr); 154 // 3. OH_Drawing_ImageBuildFromBitmap with a null parameter, check the error code with OH_Drawing_ErrorCodeGet 155 OH_Drawing_ImageBuildFromBitmap(nullptr, bitmap); 156 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 157 OH_Drawing_ErrorCodeReset(); 158 // 4. OH_Drawing_ImageBuildFromBitmap with a null parameter, check the error code with OH_Drawing_ErrorCodeGet 159 OH_Drawing_ImageBuildFromBitmap(image, nullptr); 160 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 161 // 5. Free memory 162 OH_Drawing_ImageDestroy(image); 163 OH_Drawing_BitmapDestroy(bitmap); 164 } 165 166 /* 167 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0202 168 * @tc.name: testImageBuildFromBitmapMultipleCalls 169 * @tc.desc: Test for multiple calls of building an image from a bitmap. 170 * @tc.size : SmallTest 171 * @tc.type : Function 172 * @tc.level : Level 3 173 */ 174 HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapMultipleCalls, Function | SmallTest | Level3) { 175 for (int i = 0; i < 10; i++) { 176 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 177 // add assert 178 EXPECT_NE(image, nullptr); 179 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 180 // add assert 181 EXPECT_NE(bitmap, nullptr); 182 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 183 uint32_t width = 200 + i * 10; 184 uint32_t height = 200 + i * 10; 185 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 186 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 187 OH_Drawing_ImageDestroy(image); 188 OH_Drawing_BitmapDestroy(bitmap); 189 } 190 } 191 192 /* 193 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0203 194 * @tc.name: testImageBuildFromBitmapMultipleCallsBoundary 195 * @tc.desc: Test for multiple calls of building an boundary value image from a bitmap. 196 * @tc.size : SmallTest 197 * @tc.type : Function 198 * @tc.level : Level 3 199 */ 200 HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapMultipleCallsBoundary, Function | SmallTest | Level3) { 201 for (int i = 0; i < 10; i++) { 202 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 203 // add assert 204 EXPECT_NE(image, nullptr); 205 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 206 // add assert 207 EXPECT_NE(bitmap, nullptr); 208 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 209 uint32_t width = 4096; 210 uint32_t height = 2160; 211 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 212 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 213 OH_Drawing_ImageDestroy(image); 214 OH_Drawing_BitmapDestroy(bitmap); 215 } 216 } 217 218 /* 219 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0300 220 * @tc.name: testImageGetWidthHeightNormal 221 * @tc.desc: Test for getting width and height of an image with normal parameters. 222 * @tc.size : SmallTest 223 * @tc.type : Function 224 * @tc.level : Level 0 225 */ 226 HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightNormal, Function | SmallTest | Level0) { 227 // 1. OH_Drawing_ImageCreate 228 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 229 // add assert 230 EXPECT_NE(image, nullptr); 231 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 232 // add assert 233 EXPECT_NE(bitmap, nullptr); 234 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 235 constexpr uint32_t width = 200; 236 constexpr uint32_t height = 200; 237 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 238 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 239 // 2. OH_Drawing_ImageGetWidth 240 int32_t width_ = OH_Drawing_ImageGetWidth(image); 241 EXPECT_EQ(width_, 200); 242 // 3. OH_Drawing_ImageGetHeight 243 int32_t height_ = OH_Drawing_ImageGetHeight(image); 244 EXPECT_EQ(height_, 200); 245 // 4. Free memory 246 OH_Drawing_ImageDestroy(image); 247 OH_Drawing_BitmapDestroy(bitmap); 248 } 249 250 /* 251 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0301 252 * @tc.name: testImageGetWidthHeightNULL 253 * @tc.desc: Test for getting width and height of an image with NULL parameters. 254 * @tc.size : SmallTest 255 * @tc.type : Function 256 * @tc.level : Level 3 257 */ 258 HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightNULL, Function | SmallTest | Level3) { 259 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 260 // add assert 261 EXPECT_NE(image, nullptr); 262 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 263 // add assert 264 EXPECT_NE(bitmap, nullptr); 265 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 266 uint32_t width = 200; 267 uint32_t height = 200; 268 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 269 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 270 // 1. OH_Drawing_ImageGetWidth with a null parameter, check the error code with OH_Drawing_ErrorCodeGet 271 OH_Drawing_ImageGetWidth(nullptr); 272 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 273 OH_Drawing_ErrorCodeReset(); 274 // 2. OH_Drawing_ImageGetHeight with a null parameter, check the error code with OH_Drawing_ErrorCodeGet 275 OH_Drawing_ImageGetHeight(nullptr); 276 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 277 } 278 279 /* 280 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0302 281 * @tc.name: testImageGetWidthHeightMultipleCalls 282 * @tc.desc: Test for multiple calls of getting width and height of an image. 283 * @tc.size : SmallTest 284 * @tc.type : Function 285 * @tc.level : Level 3 286 */ 287 HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightMultipleCalls, Function | SmallTest | Level3) { 288 for (int i = 0; i < 10; i++) { 289 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 290 // add assert 291 EXPECT_NE(image, nullptr); 292 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 293 // add assert 294 EXPECT_NE(bitmap, nullptr); 295 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 296 uint32_t width = 200 + i * 10; 297 uint32_t height = 200 + i * 10; 298 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 299 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 300 int32_t width_ = OH_Drawing_ImageGetWidth(image); 301 EXPECT_EQ(width_, 200 + i * 10); 302 int32_t height_ = OH_Drawing_ImageGetHeight(image); 303 EXPECT_EQ(height_, 200 + i * 10); 304 OH_Drawing_ImageDestroy(image); 305 OH_Drawing_BitmapDestroy(bitmap); 306 } 307 } 308 309 /* 310 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0302 311 * @tc.name: testImageGetWidthHeightMultipleCallsBoundary 312 * @tc.desc: Test for multiple calls of getting width and height of an boundary value image. 313 * @tc.size : SmallTest 314 * @tc.type : Function 315 * @tc.level : Level 3 316 */ 317 HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightMultipleCallsBoundary, Function | SmallTest | Level3) { 318 for (int i = 0; i < 10; i++) { 319 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 320 // add assert 321 EXPECT_NE(image, nullptr); 322 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 323 // add assert 324 EXPECT_NE(bitmap, nullptr); 325 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 326 uint32_t width = 4096; 327 uint32_t height = 2160; 328 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 329 EXPECT_NE(bitmap, nullptr); 330 OH_Drawing_ImageBuildFromBitmap(image, bitmap); 331 EXPECT_NE(image, nullptr); 332 int32_t width_ = OH_Drawing_ImageGetWidth(image); 333 EXPECT_EQ(width_, 4096); 334 int32_t height_ = OH_Drawing_ImageGetHeight(image); 335 EXPECT_EQ(height_, 2160); 336 OH_Drawing_ImageDestroy(image); 337 OH_Drawing_BitmapDestroy(bitmap); 338 } 339 } 340 341 /* 342 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0400 343 * @tc.name: testImageGetImageInfoNormal 344 * @tc.desc: Test for getting image info with normal parameters. 345 * @tc.size : SmallTest 346 * @tc.type : Function 347 * @tc.level : Level 0 348 */ 349 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoNormal, Function | SmallTest | Level0) { 350 OH_Drawing_ColorFormat cfs[] = { 351 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 352 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 353 }; 354 OH_Drawing_AlphaFormat afs[] = { 355 ALPHA_FORMAT_UNKNOWN, 356 ALPHA_FORMAT_OPAQUE, 357 ALPHA_FORMAT_PREMUL, 358 ALPHA_FORMAT_UNPREMUL, 359 }; 360 for (OH_Drawing_ColorFormat cf : cfs) { 361 for (OH_Drawing_AlphaFormat af : afs) { 362 OH_Drawing_ErrorCodeReset(); 363 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 364 // add assert 365 EXPECT_NE(image, nullptr); 366 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 367 // add assert 368 EXPECT_NE(bitmap, nullptr); 369 OH_Drawing_BitmapFormat cFormat{cf, af}; 370 uint32_t width = 400; 371 uint32_t height = 400; 372 OH_Drawing_Image_Info imageInfo; 373 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 374 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 375 // add assert 376 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 377 OH_Drawing_ImageDestroy(image); 378 OH_Drawing_BitmapDestroy(bitmap); 379 } 380 } 381 } 382 383 /* 384 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0401 385 * @tc.name: testImageGetImageInfoNULL 386 * @tc.desc: Test for getting image info with NULL parameters. 387 * @tc.size : SmallTest 388 * @tc.type : Function 389 * @tc.level : Level 3 390 */ 391 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoNULL, Function | SmallTest | Level3) { 392 // 1. OH_Drawing_ImageCreate 393 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 394 // add assert 395 EXPECT_NE(image, nullptr); 396 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 397 // add assert 398 EXPECT_NE(bitmap, nullptr); 399 // 2. OH_Drawing_Image_Info 400 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 401 uint32_t width = 400; 402 uint32_t height = 400; 403 OH_Drawing_Image_Info imageInfo; 404 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 405 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 406 // 3. OH_Drawing_ImageGetImageInfo with a null parameter, check the error code with OH_Drawing_ErrorCodeGet 407 OH_Drawing_ImageGetImageInfo(nullptr, &imageInfo); 408 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 409 // 4. Free memory 410 OH_Drawing_ImageDestroy(image); 411 OH_Drawing_BitmapDestroy(bitmap); 412 } 413 414 /* 415 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0402 416 * @tc.name: testImageGetImageInfoMultipleCalls 417 * @tc.desc: Test for multiple calls of getting image info. 418 * @tc.size : SmallTest 419 * @tc.type : Function 420 * @tc.level : Level 3 421 */ 422 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoMultipleCalls, Function | SmallTest | Level3) { 423 OH_Drawing_ColorFormat cf[] = { 424 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 425 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 426 }; 427 OH_Drawing_AlphaFormat af[] = { 428 ALPHA_FORMAT_UNKNOWN, 429 ALPHA_FORMAT_OPAQUE, 430 ALPHA_FORMAT_PREMUL, 431 ALPHA_FORMAT_UNPREMUL, 432 }; 433 for (int i = 0; i < 10; i++) { 434 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 435 // add assert 436 EXPECT_NE(image, nullptr); 437 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 438 // add assert 439 EXPECT_NE(bitmap, nullptr); 440 srand(static_cast<unsigned int>(time(0))); 441 OH_Drawing_BitmapFormat cFormat{cf[rand() % 5 + 1], af[rand() % 3 + 1]}; 442 uint32_t width = rand() % 100 + 1; 443 uint32_t height = rand() % 100 + 1; 444 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 445 OH_Drawing_Image_Info imageInfo; 446 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 447 OH_Drawing_ImageDestroy(image); 448 OH_Drawing_BitmapDestroy(bitmap); 449 } 450 } 451 452 /* 453 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0403 454 * @tc.name: testImageGetImageInfoAbnormal 455 * @tc.desc: Test for getting image info with abnormal parameters. 456 * @tc.size : SmallTest 457 * @tc.type : Function 458 * @tc.level : Level 3 459 */ 460 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoAbnormal, Function | SmallTest | Level3) { 461 // 1. OH_Drawing_ImageCreate 462 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 463 // add assert 464 EXPECT_NE(image, nullptr); 465 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 466 // add assert 467 EXPECT_NE(bitmap, nullptr); 468 // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=-400 and height=-400 469 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 470 uint32_t width = -400; 471 uint32_t height = -400; 472 OH_Drawing_Image_Info imageInfo; 473 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 474 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 475 // 3. Free memory 476 OH_Drawing_ImageDestroy(image); 477 OH_Drawing_BitmapDestroy(bitmap); 478 } 479 480 /* 481 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0404 482 * @tc.name: testImageGetImageInfoMaximum 483 * @tc.desc: Test for getting image info with maximum values. 484 * @tc.size : SmallTest 485 * @tc.type : Function 486 * @tc.level : Level 3 487 */ 488 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoMaximum, Function | SmallTest | Level3) { 489 // 1. OH_Drawing_ImageCreate 490 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 491 // add assert 492 EXPECT_NE(image, nullptr); 493 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 494 // add assert 495 EXPECT_NE(bitmap, nullptr); 496 // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=maximum value and height=maximum value 497 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 498 uint32_t width = UINT32_MAX; 499 uint32_t height = UINT32_MAX; 500 OH_Drawing_Image_Info imageInfo; 501 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 502 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 503 // 3. Free memory 504 OH_Drawing_ImageDestroy(image); 505 OH_Drawing_BitmapDestroy(bitmap); 506 } 507 508 /* 509 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0405 510 * @tc.name: testImageGetImageInfoBoundary 511 * @tc.desc: Test for getting image info with Boundary value. 512 * @tc.size : SmallTest 513 * @tc.type : Function 514 * @tc.level : Level 3 515 */ 516 HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoBoundary, Function | SmallTest | Level3) { 517 // 1. OH_Drawing_ImageCreate 518 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 519 // add assert 520 EXPECT_NE(image, nullptr); 521 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 522 // add assert 523 EXPECT_NE(bitmap, nullptr); 524 // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=maximum value and height=maximum value 525 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 526 uint32_t width = 4096; 527 uint32_t height = 2160; 528 OH_Drawing_Image_Info imageInfo; 529 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 530 EXPECT_NE(bitmap, nullptr); 531 OH_Drawing_ImageGetImageInfo(image, &imageInfo); 532 EXPECT_NE(image, nullptr); 533 // 3. Free memory 534 OH_Drawing_ImageDestroy(image); 535 OH_Drawing_BitmapDestroy(bitmap); 536 } 537 538 } // namespace Drawing 539 } // namespace Rosen 540 } // namespace OHOS