1 /* 2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "gtest/gtest.h" 17 18 #include "drawing_bitmap.h" 19 #include "drawing_brush.h" 20 #include "drawing_canvas.h" 21 #include "drawing_color.h" 22 #include "drawing_color_filter.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_point.h" 32 #include "drawing_rect.h" 33 #include "drawing_region.h" 34 #include "drawing_round_rect.h" 35 #include "drawing_sampling_options.h" 36 #include "drawing_shader_effect.h" 37 #include "drawing_text_blob.h" 38 #include "drawing_typeface.h" 39 40 using namespace testing; 41 using namespace testing::ext; 42 43 namespace OHOS { 44 namespace Rosen { 45 namespace Drawing { 46 class DrawingNativeBitmapTest : public testing::Test { 47 protected: 48 // 在每个测试用例执行前调用 SetUp()49 void SetUp() override 50 { 51 // 设置代码 52 std::cout << "DrawingNativeBitmapTest Setup code called before each test case." << std::endl; 53 OH_Drawing_ErrorCodeReset(); 54 std::cout << "DrawingNativeBitmapTest errorCodeReset before each test case." << std::endl; 55 } TearDown()56 void TearDown() override 57 { 58 std::cout << "DrawingNativeBitmapTest Setup code called after each test case." << std::endl; 59 OH_Drawing_ErrorCodeReset(); 60 std::cout << "DrawingNativeBitmapTest errorCodeReset after each test case." << std::endl; 61 } 62 }; 63 64 /* 65 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0100 66 * @tc.name: testBitmapDestroyNormal 67 * @tc.desc: test for testBitmapDestroyNormal. 68 * @tc.size : SmallTest 69 * @tc.type : Function 70 * @tc.level : Level 0 71 */ 72 HWTEST_F(DrawingNativeBitmapTest, testBitmapDestroyNormal, TestSize.Level0) { 73 // step 1 74 OH_Drawing_Bitmap *cBitmap = OH_Drawing_BitmapCreate(); 75 EXPECT_NE(cBitmap, nullptr); 76 // step 2 77 OH_Drawing_BitmapDestroy(cBitmap); 78 } 79 80 /* 81 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0101 82 * @tc.name: testBitmapDestroyNull 83 * @tc.desc: test for testBitmapDestroyNull. 84 * @tc.size : SmallTest 85 * @tc.type : Function 86 * @tc.level : Level 3 87 */ 88 HWTEST_F(DrawingNativeBitmapTest, testBitmapDestroyNull, TestSize.Level3) { 89 OH_Drawing_BitmapDestroy(nullptr); 90 // add assert 91 EXPECT_TRUE(true); 92 } 93 94 /* 95 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0200 96 * @tc.name: testBitmapCreateFromPixelsNormal 97 * @tc.desc: test for testBitmapCreateFromPixelsNormal. 98 * @tc.size : SmallTest 99 * @tc.type : Function 100 * @tc.level : Level 0 101 */ 102 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsNormal, TestSize.Level0) { 103 // 1. Construct OH_Drawing_Image_Info by iterating through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat 104 OH_Drawing_ColorFormat formats[] = { 105 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 106 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 107 }; 108 OH_Drawing_AlphaFormat alphaFormats[] = { 109 ALPHA_FORMAT_UNKNOWN, 110 ALPHA_FORMAT_OPAQUE, 111 ALPHA_FORMAT_PREMUL, 112 ALPHA_FORMAT_UNPREMUL, 113 }; 114 for (OH_Drawing_ColorFormat format : formats) { 115 for (OH_Drawing_AlphaFormat alphaFormat : alphaFormats) { 116 int width = 100; 117 int height = 100; 118 int rowBytes = width * 4; 119 OH_Drawing_Bitmap *bitmap1 = OH_Drawing_BitmapCreate(); 120 EXPECT_NE(bitmap1, nullptr); 121 OH_Drawing_BitmapFormat cFormat{format, alphaFormat}; 122 OH_Drawing_BitmapBuild(bitmap1, width, height, &cFormat); 123 void *pixels = OH_Drawing_BitmapGetPixels(bitmap1); 124 if (pixels != nullptr) { 125 OH_Drawing_Image_Info imageInfo; 126 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 127 // 2. OH_Drawing_BitmapCreateFromPixels 128 // Initialize the Bitmap with matching image information and call OH_Drawing_BitmapGet related 129 // interfaces Verify that the parameters match the initialization parameters 130 uint32_t height_ = OH_Drawing_BitmapGetHeight(bitmap); 131 uint32_t width_ = OH_Drawing_BitmapGetWidth(bitmap); 132 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(bitmap); 133 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 134 EXPECT_TRUE(height_ == height || height_ == 0); 135 EXPECT_TRUE(width_ == width || width_ == 0); 136 EXPECT_TRUE(colorFormat_ == format || colorFormat_ == 0); 137 EXPECT_TRUE(alphaFormat_ == alphaFormat || alphaFormat_ == 0); 138 // 3. OH_Drawing_BitmapCreateFromPixels 139 // Initialize the Bitmap with rowBytes larger than the image, call OH_Drawing_BitmapGet related 140 // interfaces (OH_Drawing_BitmapGetHeight, OH_Drawing_BitmapGetWidth), Verify that the parameters match 141 // the initialization parameters 142 int rowBytes2 = width * 4 + 1; 143 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes2); 144 height_ = OH_Drawing_BitmapGetHeight(bitmap); 145 width_ = OH_Drawing_BitmapGetWidth(bitmap); 146 EXPECT_TRUE(height_ == height || height_ == 0); 147 EXPECT_TRUE(width_ == width || width_ == 0); 148 // 4. Free memory 149 OH_Drawing_BitmapDestroy(bitmap); 150 } 151 } 152 } 153 } 154 155 /* 156 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0201 157 * @tc.name: testBitmapCreateFromPixelsNull 158 * @tc.desc: test for testBitmapCreateFromPixelsNull. 159 * @tc.size : SmallTest 160 * @tc.type : Function 161 * @tc.level : Level 3 162 */ 163 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsNull, TestSize.Level3) { 164 int width = 100; 165 int height = 100; 166 int rowBytes = width * 4; 167 uint8_t *pixels = new uint8_t[width * height * 4]; 168 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_ALPHA_8, ALPHA_FORMAT_UNKNOWN}; 169 // 1. OH_Drawing_BitmapCreateFromPixels the first parameter OH_Drawing_Image_Info is empty 170 OH_Drawing_Bitmap *bitmap1 = OH_Drawing_BitmapCreateFromPixels(nullptr, pixels, rowBytes); 171 EXPECT_EQ(bitmap1, nullptr); 172 // 2. OH_Drawing_BitmapCreateFromPixels the second parameter pixels is empty 173 OH_Drawing_Bitmap *bitmap2 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, nullptr, rowBytes); 174 EXPECT_EQ(bitmap2, nullptr); 175 // 3. OH_Drawing_BitmapCreateFromPixels the third parameter rowBytes is 0 176 OH_Drawing_Bitmap *bitmap3 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, 0); 177 EXPECT_EQ(bitmap3, nullptr); 178 // 4. OH_Drawing_BitmapCreateFromPixels the width of the first parameter OH_Drawing_Image_Info is 0 179 imageInfo.width = 0; 180 OH_Drawing_Bitmap *bitmap4 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 181 EXPECT_EQ(bitmap4, nullptr); 182 // 5. OH_Drawing_BitmapCreateFromPixels the height of the first parameter OH_Drawing_Image_Info is 0 183 imageInfo.width = width; 184 imageInfo.height = 0; 185 OH_Drawing_Bitmap *bitmap5 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 186 EXPECT_EQ(bitmap5, nullptr); 187 // 6. Free memory 188 OH_Drawing_BitmapDestroy(bitmap1); 189 OH_Drawing_BitmapDestroy(bitmap2); 190 OH_Drawing_BitmapDestroy(bitmap3); 191 OH_Drawing_BitmapDestroy(bitmap4); 192 OH_Drawing_BitmapDestroy(bitmap5); 193 delete[] pixels; 194 } 195 196 /* 197 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0202 198 * @tc.name: testBitmapCreateFromPixelsMismatch 199 * @tc.desc: test for testBitmapCreateFromPixelsMismatch. 200 * @tc.size : SmallTest 201 * @tc.type : Function 202 * @tc.level : Level 3 203 */ 204 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsMismatch, TestSize.Level3) { 205 int width = 48; 206 int height = 48; 207 int rowBytes = width * 4; 208 uint8_t *pixels = new uint8_t[width * height * 4]; 209 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_ALPHA_8, ALPHA_FORMAT_UNKNOWN}; 210 // 1. OH_Drawing_BitmapCreateFromPixels initializes a 48*48 image, but the memory allocated for pixels is 47*48 211 uint8_t *pixels1 = new uint8_t[47 * height * 4]; 212 OH_Drawing_Bitmap *bitmap1 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels1, rowBytes); 213 EXPECT_EQ(bitmap1, nullptr); 214 // 2. OH_Drawing_BitmapCreateFromPixels initializes a 48*48 image, but the memory allocated for pixels is 48*47 215 uint8_t *pixels2 = new uint8_t[width * 47 * 4]; 216 OH_Drawing_Bitmap *bitmap2 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels2, rowBytes); 217 EXPECT_EQ(bitmap2, nullptr); 218 // 3. OH_Drawing_BitmapCreateFromPixels initializes a 48*48 image, but the memory allocated for pixels is 48*48 and 219 // rowBytes is 47 220 rowBytes = 47; 221 uint8_t *pixels3 = new uint8_t[width * height * 4]; 222 OH_Drawing_Bitmap *bitmap3 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels3, rowBytes); 223 EXPECT_EQ(bitmap3, nullptr); 224 // 4. Free memory 225 OH_Drawing_BitmapDestroy(bitmap1); 226 OH_Drawing_BitmapDestroy(bitmap2); 227 OH_Drawing_BitmapDestroy(bitmap3); 228 delete[] pixels; 229 delete[] pixels1; 230 delete[] pixels2; 231 delete[] pixels3; 232 } 233 234 /* 235 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0203 236 * @tc.name: testBitmapCreateFromPixelsAbnormal 237 * @tc.desc: test for testBitmapCreateFromPixelsAbnormal. 238 * @tc.size : SmallTest 239 * @tc.type : Function 240 * @tc.level : Level 3 241 */ 242 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsAbnormal, TestSize.Level3) { 243 int width = 48; 244 int height = 48; 245 int rowBytes = width * 4; 246 uint8_t *pixels = new uint8_t[width * height * 4]; 247 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_ALPHA_8, ALPHA_FORMAT_UNKNOWN}; 248 // 1. After constructing OH_Drawing_Image_Info, modify the byte value to an abnormal value 249 imageInfo.width = -1; 250 // 2. OH_Drawing_BitmapCreateFromPixels 251 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 252 EXPECT_EQ(bitmap, nullptr); 253 // 3. Free memory 254 OH_Drawing_BitmapDestroy(bitmap); 255 delete[] pixels; 256 } 257 258 /* 259 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0204 260 * @tc.name: testBitmapCreateFromPixelsVeryBig 261 * @tc.desc: test for testBitmapCreateFromPixelsVeryBig. 262 * @tc.size : SmallTest 263 * @tc.type : Function 264 * @tc.level : Level 3 265 */ 266 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsVeryBig, TestSize.Level3) { 267 // 1. Construct OH_Drawing_Image_Info by iterating through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat 268 OH_Drawing_ColorFormat formats[] = { 269 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 270 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 271 }; 272 OH_Drawing_AlphaFormat alphaFormats[] = { 273 ALPHA_FORMAT_UNKNOWN, 274 ALPHA_FORMAT_OPAQUE, 275 ALPHA_FORMAT_PREMUL, 276 ALPHA_FORMAT_UNPREMUL, 277 }; 278 for (OH_Drawing_ColorFormat format : formats) { 279 for (OH_Drawing_AlphaFormat alphaFormat : alphaFormats) { 280 int width = 1000000; 281 int height = 1000000; 282 int rowBytes = width * 4; 283 OH_Drawing_Bitmap *bitmap1 = OH_Drawing_BitmapCreate(); 284 EXPECT_NE(bitmap1, nullptr); 285 OH_Drawing_BitmapFormat cFormat{format, alphaFormat}; 286 OH_Drawing_BitmapBuild(bitmap1, width, height, &cFormat); 287 void *pixels = OH_Drawing_BitmapGetPixels(bitmap1); 288 if (pixels != nullptr) { 289 OH_Drawing_Image_Info imageInfo; 290 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 291 // 2. OH_Drawing_BitmapCreateFromPixels 292 // Initialize the Bitmap with matching image information and call OH_Drawing_BitmapGet related 293 // interfaces Verify that the parameters match the initialization parameters 294 uint32_t height_ = OH_Drawing_BitmapGetHeight(bitmap); 295 uint32_t width_ = OH_Drawing_BitmapGetWidth(bitmap); 296 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(bitmap); 297 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 298 EXPECT_TRUE(height_ == height || height_ == 0); 299 EXPECT_TRUE(width_ == width || width_ == 0); 300 EXPECT_TRUE(colorFormat_ == format || colorFormat_ == 0); 301 EXPECT_TRUE(alphaFormat_ == alphaFormat || alphaFormat_ == 0); 302 // 3. OH_Drawing_BitmapCreateFromPixels 303 // Initialize the Bitmap with rowBytes larger than the image, call OH_Drawing_BitmapGet related 304 // interfaces (OH_Drawing_BitmapGetHeight, OH_Drawing_BitmapGetWidth), Verify that the parameters match 305 // the initialization parameters 306 int rowBytes2 = width * 4 + 1; 307 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes2); 308 height_ = OH_Drawing_BitmapGetHeight(bitmap); 309 width_ = OH_Drawing_BitmapGetWidth(bitmap); 310 EXPECT_TRUE(height_ == height || height_ == 0); 311 EXPECT_TRUE(width_ == width || width_ == 0); 312 // 4. Free memory 313 OH_Drawing_BitmapDestroy(bitmap); 314 } 315 } 316 } 317 } 318 319 /* 320 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0205 321 * @tc.name: testBitmapCreateFromPixelsBoundary 322 * @tc.desc: test for testBitmapCreateFromPixelsBoundary. 323 * @tc.size : SmallTest 324 * @tc.type : Function 325 * @tc.level : Level 3 326 */ 327 HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsBoundary, TestSize.Level0) { 328 // 1. Construct OH_Drawing_Image_Info by iterating through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat 329 OH_Drawing_ColorFormat formats[] = { 330 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 331 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 332 }; 333 OH_Drawing_AlphaFormat alphaFormats[] = { 334 ALPHA_FORMAT_UNKNOWN, 335 ALPHA_FORMAT_OPAQUE, 336 ALPHA_FORMAT_PREMUL, 337 ALPHA_FORMAT_UNPREMUL, 338 }; 339 for (OH_Drawing_ColorFormat format : formats) { 340 for (OH_Drawing_AlphaFormat alphaFormat : alphaFormats) { 341 // 4K screen resolutionp 342 int width = 4096; 343 int height = 2160; 344 int rowBytes = width * 4; 345 OH_Drawing_Bitmap *bitmap1 = OH_Drawing_BitmapCreate(); 346 EXPECT_NE(bitmap1, nullptr); 347 OH_Drawing_BitmapFormat cFormat{format, alphaFormat}; 348 OH_Drawing_BitmapBuild(bitmap1, width, height, &cFormat); 349 void *pixels = OH_Drawing_BitmapGetPixels(bitmap1); 350 if (pixels != nullptr) { 351 OH_Drawing_Image_Info imageInfo; 352 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 353 // 2. OH_Drawing_BitmapCreateFromPixels 354 // Initialize the Bitmap with matching image information and call OH_Drawing_BitmapGet related 355 // interfaces Verify that the parameters match the initialization parameters 356 uint32_t height_ = OH_Drawing_BitmapGetHeight(bitmap); 357 uint32_t width_ = OH_Drawing_BitmapGetWidth(bitmap); 358 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(bitmap); 359 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 360 EXPECT_TRUE(height_ == height || height_ == 0); 361 EXPECT_TRUE(width_ == width || width_ == 0); 362 EXPECT_TRUE(colorFormat_ == format || colorFormat_ == 0); 363 EXPECT_TRUE(alphaFormat_ == alphaFormat || alphaFormat_ == 0); 364 // 3. OH_Drawing_BitmapCreateFromPixels 365 // Initialize the Bitmap with rowBytes larger than the image, call OH_Drawing_BitmapGet related 366 // interfaces (OH_Drawing_BitmapGetHeight, OH_Drawing_BitmapGetWidth), Verify that the parameters match 367 // the initialization parameters 368 int rowBytes2 = width * 4 + 1; 369 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes2); 370 height_ = OH_Drawing_BitmapGetHeight(bitmap); 371 width_ = OH_Drawing_BitmapGetWidth(bitmap); 372 EXPECT_TRUE(height_ == height || height_ == 0); 373 EXPECT_TRUE(width_ == width || width_ == 0); 374 // 4. Free memory 375 OH_Drawing_BitmapDestroy(bitmap); 376 } 377 } 378 } 379 } 380 381 /* 382 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0300 383 * @tc.name: testBitmapBuildNormal 384 * @tc.desc: test for testBitmapBuildNormal. 385 * @tc.size : SmallTest 386 * @tc.type : Function 387 * @tc.level : Level 0 388 */ 389 HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildNormal, TestSize.Level0) { 390 const unsigned int width = 500; 391 const unsigned int height = 500; 392 OH_Drawing_ColorFormat formats[] = { 393 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 394 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 395 }; 396 397 OH_Drawing_AlphaFormat alphaFormats[] = { 398 ALPHA_FORMAT_UNKNOWN, 399 ALPHA_FORMAT_OPAQUE, 400 ALPHA_FORMAT_PREMUL, 401 ALPHA_FORMAT_UNPREMUL, 402 }; 403 OH_Drawing_AlphaFormat alphaFormat_; 404 405 // step 1 406 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 407 408 // step 2 409 for (int i = 1; i < 4; i++) { 410 OH_Drawing_BitmapFormat bitmapFormat = {formats[3], alphaFormats[i]}; 411 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 412 if (bitmap == nullptr) { 413 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 414 EXPECT_EQ(alphaFormat_, alphaFormats[0]); 415 } else { 416 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 417 EXPECT_EQ(alphaFormat_, alphaFormats[i]); 418 } 419 } 420 421 // step 3 422 OH_Drawing_BitmapDestroy(bitmap); 423 } 424 425 /* 426 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0301 427 * @tc.name: testBitmapBuildNull 428 * @tc.desc: test for testBitmapBuildNull. 429 * @tc.size : SmallTest 430 * @tc.type : Function 431 * @tc.level : Level 3 432 */ 433 HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildNull, TestSize.Level3) { 434 const unsigned int width = 500; 435 const unsigned int height = 500; 436 437 OH_Drawing_ColorFormat formats[] = { 438 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 439 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 440 }; 441 442 OH_Drawing_AlphaFormat alphaFormats[] = { 443 ALPHA_FORMAT_UNKNOWN, 444 ALPHA_FORMAT_OPAQUE, 445 ALPHA_FORMAT_PREMUL, 446 ALPHA_FORMAT_UNPREMUL, 447 }; 448 449 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 450 // add assert 451 EXPECT_NE(bitmap, nullptr); 452 OH_Drawing_BitmapFormat bitmapFormat = {formats[3], alphaFormats[0]}; 453 454 OH_Drawing_BitmapBuild(bitmap, 0, height, &bitmapFormat); 455 // add assert 456 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 457 OH_Drawing_BitmapBuild(bitmap, width, 0, &bitmapFormat); 458 // add assert 459 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 460 OH_Drawing_BitmapBuild(bitmap, width, height, nullptr); 461 // add assert 462 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 463 OH_Drawing_BitmapDestroy(bitmap); 464 } 465 466 /* 467 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0302 468 * @tc.name: testBitmapBuildMultipleCalls 469 * @tc.desc: test for testBitmapBuildMultipleCalls. 470 * @tc.size : SmallTest 471 * @tc.type : Function 472 * @tc.level : Level 3 473 */ 474 HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildMultipleCalls, TestSize.Level3) { 475 const unsigned int width = 500; 476 const unsigned int height = 500; 477 OH_Drawing_ColorFormat formats[] = { 478 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 479 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 480 }; 481 482 OH_Drawing_AlphaFormat alphaFormats[] = { 483 ALPHA_FORMAT_UNKNOWN, 484 ALPHA_FORMAT_OPAQUE, 485 ALPHA_FORMAT_PREMUL, 486 ALPHA_FORMAT_UNPREMUL, 487 }; 488 OH_Drawing_AlphaFormat alphaFormat_; 489 490 // step 1 491 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 492 493 // step 2 494 for (int i = 1; i < 4; i++) { 495 OH_Drawing_BitmapFormat bitmapFormat = {formats[3], alphaFormats[i]}; 496 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 497 if (bitmap == nullptr) { 498 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 499 EXPECT_EQ(alphaFormat_, alphaFormats[0]); 500 } 501 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 502 EXPECT_EQ(alphaFormat_, alphaFormats[i]); 503 } 504 505 // step 3 506 OH_Drawing_BitmapDestroy(bitmap); 507 508 // step 4 509 OH_Drawing_Image_Info imageInfo; 510 OH_Drawing_Bitmap *bitmap2 = OH_Drawing_BitmapCreate(); 511 EXPECT_NE(bitmap2, nullptr); 512 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 513 OH_Drawing_BitmapBuild(bitmap2, width, height, &cFormat); 514 void *pixels = OH_Drawing_BitmapGetPixels(bitmap2); 515 EXPECT_NE(pixels, nullptr); 516 uint32_t rowBytes = width * height * 4; 517 OH_Drawing_Bitmap *bitmap3 = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 518 519 // step 5 520 for (int i = 1; i < 4; i++) { 521 OH_Drawing_BitmapFormat bitmapFormat = {formats[3], alphaFormats[i]}; 522 OH_Drawing_BitmapBuild(bitmap3, width, height, &bitmapFormat); 523 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap3); 524 EXPECT_EQ(alphaFormat_, alphaFormats[i]); 525 } 526 } 527 528 /* 529 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0303 530 * @tc.name: testBitmapBuildBoundary 531 * @tc.desc: test for testBitmapBuildBoundary. 532 * @tc.size : SmallTest 533 * @tc.type : Function 534 * @tc.level : Level 0 535 */ 536 HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildBoundary, TestSize.Level0) { 537 // 4K screen resolutionp 538 const unsigned int width = 4096; 539 const unsigned int height = 2160; 540 OH_Drawing_ColorFormat formats[] = { 541 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565, 542 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888, 543 }; 544 545 OH_Drawing_AlphaFormat alphaFormats[] = { 546 ALPHA_FORMAT_UNKNOWN, 547 ALPHA_FORMAT_OPAQUE, 548 ALPHA_FORMAT_PREMUL, 549 ALPHA_FORMAT_UNPREMUL, 550 }; 551 OH_Drawing_AlphaFormat alphaFormat_; 552 553 // step 1 554 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 555 556 // step 2 557 for (int i = 1; i < 4; i++) { 558 OH_Drawing_BitmapFormat bitmapFormat = {formats[3], alphaFormats[i]}; 559 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 560 if (bitmap == nullptr) { 561 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 562 EXPECT_EQ(alphaFormat_, alphaFormats[0]); 563 } else { 564 alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(bitmap); 565 EXPECT_EQ(alphaFormat_, alphaFormats[i]); 566 } 567 } 568 569 // step 3 570 OH_Drawing_BitmapDestroy(bitmap); 571 } 572 573 /* 574 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0400 575 * @tc.name: testBitmapGetXXNormal 576 * @tc.desc: test for testBitmapGetXXNormal. 577 * @tc.size : SmallTest 578 * @tc.type : Function 579 * @tc.level : Level 0 580 */ 581 HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXNormal, TestSize.Level0) { 582 OH_Drawing_Bitmap *cBitmap = OH_Drawing_BitmapCreate(); 583 EXPECT_NE(cBitmap, nullptr); 584 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 585 uint32_t width = 100; 586 uint32_t height = 100; 587 OH_Drawing_BitmapBuild(cBitmap, width, height, &cFormat); 588 589 OH_Drawing_Image_Info imageInfo1{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 590 void *pixels1 = new uint32_t[width * height]; 591 592 // step 1 593 bool res = OH_Drawing_BitmapReadPixels(cBitmap, &imageInfo1, pixels1, width * 4, 0, 0); 594 EXPECT_EQ(res, true); 595 596 // step 2 597 uint32_t w = OH_Drawing_BitmapGetWidth(cBitmap); 598 EXPECT_EQ(w, 100); 599 600 // step 3 601 uint32_t h = OH_Drawing_BitmapGetHeight(cBitmap); 602 EXPECT_EQ(h, 100); 603 604 // step 5 605 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(cBitmap); 606 EXPECT_EQ(colorFormat_, COLOR_FORMAT_RGBA_8888); 607 608 // step 5 609 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(cBitmap); 610 EXPECT_EQ(alphaFormat_, ALPHA_FORMAT_OPAQUE); 611 612 // step 6 613 void *pixels = OH_Drawing_BitmapGetPixels(cBitmap); 614 EXPECT_NE(pixels, nullptr); 615 616 // step 7 617 OH_Drawing_Image_Info *imageInfo = new OH_Drawing_Image_Info(); 618 OH_Drawing_BitmapGetImageInfo(cBitmap, imageInfo); 619 EXPECT_EQ(width, imageInfo->width); 620 EXPECT_EQ(height, imageInfo->height); 621 622 // step 8 623 OH_Drawing_BitmapDestroy(cBitmap); 624 } 625 626 /* 627 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0401 628 * @tc.name: testBitmapGetXXNull 629 * @tc.desc: test for testBitmapGetXXNull. 630 * @tc.size : SmallTest 631 * @tc.type : Function 632 * @tc.level : Level 3 633 */ 634 HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXNull, TestSize.Level3) { 635 OH_Drawing_Bitmap *cBitmap = OH_Drawing_BitmapCreate(); 636 EXPECT_NE(cBitmap, nullptr); 637 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 638 uint32_t width = 100; 639 uint32_t height = 100; 640 OH_Drawing_BitmapBuild(cBitmap, width, height, &cFormat); 641 642 // step 1 643 uint32_t w = OH_Drawing_BitmapGetWidth(nullptr); 644 EXPECT_EQ(w, 0); 645 646 // step 2 647 uint32_t h = OH_Drawing_BitmapGetHeight(nullptr); 648 EXPECT_EQ(h, 0); 649 650 // step 3 651 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(nullptr); 652 EXPECT_EQ(colorFormat_, 0); 653 654 // step 4 655 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(nullptr); 656 EXPECT_EQ(alphaFormat_, 0); 657 658 // step 5 659 void *pixels = OH_Drawing_BitmapGetPixels(nullptr); 660 EXPECT_EQ(pixels, nullptr); 661 662 // step 6 663 OH_Drawing_Image_Info *imageInfo = new OH_Drawing_Image_Info(); 664 OH_Drawing_BitmapGetImageInfo(nullptr, imageInfo); 665 // add assert 666 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 667 OH_Drawing_ErrorCodeReset(); 668 OH_Drawing_BitmapGetImageInfo(cBitmap, nullptr); 669 // add assert 670 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 671 672 OH_Drawing_BitmapDestroy(cBitmap); 673 } 674 675 /* 676 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0402 677 * @tc.name: testBitmapGetXXInputDestroyed 678 * @tc.desc: test for testBitmapGetXXInputDestroyed. 679 * @tc.size : SmallTest 680 * @tc.type : Function 681 * @tc.level : Level 3 682 */ 683 HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXInputDestroyed, TestSize.Level3) { 684 // Deprecated 685 } 686 687 /* 688 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0403 689 * @tc.name: testBitmapGetXXBoundary 690 * @tc.desc: test for testBitmapGetXXBoundary. 691 * @tc.size : SmallTest 692 * @tc.type : Function 693 * @tc.level : Level 0 694 */ 695 HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXBoundary, TestSize.Level0) { 696 OH_Drawing_Bitmap *cBitmap = OH_Drawing_BitmapCreate(); 697 EXPECT_NE(cBitmap, nullptr); 698 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 699 uint32_t width = 4096; 700 uint32_t height = 2160; 701 OH_Drawing_BitmapBuild(cBitmap, width, height, &cFormat); 702 703 OH_Drawing_Image_Info imageInfo1{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 704 void *pixels1 = new uint32_t[width * height]; 705 706 // step 1 707 bool res = OH_Drawing_BitmapReadPixels(cBitmap, &imageInfo1, pixels1, width * 4, 0, 0); 708 EXPECT_EQ(res, true); 709 710 // step 2 711 uint32_t w = OH_Drawing_BitmapGetWidth(cBitmap); 712 EXPECT_EQ(w, width); 713 714 // step 3 715 uint32_t h = OH_Drawing_BitmapGetHeight(cBitmap); 716 EXPECT_EQ(h, height); 717 718 // step 5 719 OH_Drawing_ColorFormat colorFormat_ = OH_Drawing_BitmapGetColorFormat(cBitmap); 720 EXPECT_EQ(colorFormat_, COLOR_FORMAT_RGBA_8888); 721 722 // step 5 723 OH_Drawing_AlphaFormat alphaFormat_ = OH_Drawing_BitmapGetAlphaFormat(cBitmap); 724 EXPECT_EQ(alphaFormat_, ALPHA_FORMAT_OPAQUE); 725 726 // step 6 727 void *pixels = OH_Drawing_BitmapGetPixels(cBitmap); 728 EXPECT_NE(pixels, nullptr); 729 730 // step 7 731 OH_Drawing_Image_Info *imageInfo = new OH_Drawing_Image_Info(); 732 OH_Drawing_BitmapGetImageInfo(cBitmap, imageInfo); 733 // add assert 734 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 735 EXPECT_EQ(width, imageInfo->width); 736 EXPECT_EQ(height, imageInfo->height); 737 738 // step 8 739 OH_Drawing_BitmapDestroy(cBitmap); 740 } 741 742 /* 743 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0500 744 * @tc.name: testBitmapReadPixelsNormal 745 * @tc.desc: test for OH_Drawing_BitmapBuild. 746 * @tc.size : SmallTest 747 * @tc.type : Function 748 * @tc.level : Level 0 749 */ 750 HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsNormal, TestSize.Level0) { 751 const unsigned int width = 500; 752 const unsigned int height = 500; 753 754 // step 1 755 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 756 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 757 758 // step 2 759 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 760 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 761 void *pixels = new uint32_t[width * height]; 762 763 // step 3 764 bool res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, width * 4, 0, 0); 765 EXPECT_EQ(res, true); 766 767 // step 4 768 // don't know how to test 769 770 // step 5 771 OH_Drawing_BitmapDestroy(bitmap); 772 } 773 774 /* 775 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0501 776 * @tc.name: testBitmapReadPixelsNull 777 * @tc.desc: test for testBitmapReadPixelsNull. 778 * @tc.size : SmallTest 779 * @tc.type : Function 780 * @tc.level : Level 3 781 */ 782 HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsNull, TestSize.Level3) { 783 const unsigned int width = 500; 784 const unsigned int height = 500; 785 786 // step 1 787 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 788 // add assert 789 EXPECT_NE(bitmap, nullptr); 790 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 791 792 // step 2 793 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 794 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 795 void *pixels = new uint32_t[width * height]; 796 797 // step 3 798 bool res = OH_Drawing_BitmapReadPixels(nullptr, &imageInfo, pixels, width * 4, 0, 0); 799 EXPECT_EQ(res, false); 800 801 // step 4 802 res = OH_Drawing_BitmapReadPixels(bitmap, nullptr, pixels, width * 4, 0, 0); 803 EXPECT_EQ(res, false); 804 805 // step 5 806 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, nullptr, width * 4, 0, 0); 807 EXPECT_EQ(res, false); 808 809 // step 6 810 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, 0, 0, 0); 811 EXPECT_EQ(res, false); 812 813 // step 7 814 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, width * 4, 0, 1); 815 EXPECT_EQ(res, true); 816 817 // step 8 818 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, width * 4, 1, 0); 819 EXPECT_EQ(res, true); 820 821 // step 9 822 OH_Drawing_BitmapDestroy(bitmap); 823 } 824 825 /* 826 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0502 827 * @tc.name: testBitmapReadPixelsInputDestroyed 828 * @tc.desc: test for testBitmapReadPixelsInputDestroyed. 829 * @tc.size : SmallTest 830 * @tc.type : Function 831 * @tc.level : Level 3 832 */ 833 HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsInputDestroyed, TestSize.Level3) { 834 // Deprecated 835 } 836 837 /* 838 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0503 839 * @tc.name: testBitmapReadPixelsMismatch 840 * @tc.desc: test for testBitmapReadPixelsMismatch. 841 * @tc.size : SmallTest 842 * @tc.type : Function 843 * @tc.level : Level 3 844 */ 845 HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsMismatch, TestSize.Level3) { 846 // step 1 847 const unsigned int width = 500; 848 const unsigned int height = 500; 849 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 850 // add assert 851 EXPECT_NE(bitmap, nullptr); 852 853 // step 2 854 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 855 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 856 857 // step 3 858 OH_Drawing_Image_Info imageInfo{1, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 859 void *pixels = new uint32_t[width * height]; 860 bool res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, width * 4, 0, 0); 861 EXPECT_EQ(res, true); 862 863 // step 4 864 OH_Drawing_Image_Info imageInfo2{width, 1, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 865 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo2, pixels, width * 4, 0, 0); 866 EXPECT_EQ(res, true); 867 868 // step 5 869 // OH_Drawing_BitmapReadPixels OH_Drawing_Image_Info color type mismatch 870 // compile error, skip case 871 872 // step 6 873 // OH_Drawing_BitmapReadPixels OH_Drawing_Image_Info alpha type mismatch 874 // compile error, skip case 875 876 // step 7 877 OH_Drawing_Image_Info imageInfo4{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 878 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo4, pixels, width * 3, 0, 0); 879 EXPECT_EQ(res, false); 880 881 // step 8 882 OH_Drawing_Image_Info imageInfo5{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 883 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo5, pixels, width * 4, 1000, 0); 884 EXPECT_EQ(res, false); 885 886 // step 9 887 OH_Drawing_Image_Info imageInfo6{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 888 res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo6, pixels, width * 4, 0, 1000); 889 EXPECT_EQ(res, false); 890 } 891 892 /* 893 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_BITMAP_0504 894 * @tc.name: testBitmapReadPixelsBoundary 895 * @tc.desc: test for OH_Drawing_BitmapBuild. 896 * @tc.size : SmallTest 897 * @tc.type : Function 898 * @tc.level : Level 0 899 */ 900 HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsBoundary, TestSize.Level0) { 901 const unsigned int width = 4096; 902 const unsigned int height = 2160; 903 904 // step 1 905 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 906 // add assert 907 EXPECT_NE(bitmap, nullptr); 908 OH_Drawing_BitmapFormat bitmapFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 909 910 // step 2 911 OH_Drawing_BitmapBuild(bitmap, width, height, &bitmapFormat); 912 OH_Drawing_Image_Info imageInfo{width, height, COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_UNPREMUL}; 913 void *pixels = new uint32_t[width * height]; 914 915 // step 3 916 bool res = OH_Drawing_BitmapReadPixels(bitmap, &imageInfo, pixels, width * 4, 0, 0); 917 EXPECT_EQ(res, true); 918 919 // step 4 920 // don't know how to test 921 922 // step 5 923 OH_Drawing_BitmapDestroy(bitmap); 924 } 925 926 } // namespace Drawing 927 } // namespace Rosen 928 } // namespace OHOS