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