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
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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapDestroyNormal, TestSize.Level0)56 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapDestroyNull, TestSize.Level3)72 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsNormal, TestSize.Level0)82 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsNull, TestSize.Level3)143 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsMismatch, TestSize.Level3)184 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsAbnormal, TestSize.Level3)222 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsVeryBig, TestSize.Level3)246 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapCreateFromPixelsBoundary, TestSize.Level0)307 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildNormal, TestSize.Level0)369 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildNull, TestSize.Level3)413 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildMultipleCalls, TestSize.Level3)447 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapBuildBoundary, TestSize.Level0)509 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXNormal, TestSize.Level0)554 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXNull, TestSize.Level3)607 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXInputDestroyed, TestSize.Level3)652 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapGetXXBoundary, TestSize.Level0)664 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsNormal, TestSize.Level0)717 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsNull, TestSize.Level3)749 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsInputDestroyed, TestSize.Level3)798 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsMismatch, TestSize.Level3)810 HWTEST_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 */
HWTEST_F(DrawingNativeBitmapTest, testBitmapReadPixelsBoundary, TestSize.Level0)863 HWTEST_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