1/*
2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "drawing_bitmap.h"
17#include "drawing_error_code.h"
18#include "drawing_image.h"
19#include "gtest/gtest.h"
20#include <cstdlib>
21#include <ctime>
22
23using namespace testing;
24using namespace testing::ext;
25
26namespace OHOS {
27namespace Rosen {
28namespace Drawing {
29class DrawingNativeImageTest : public testing::Test {};
30
31/*
32 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0100
33 * @tc.name: testImageCreateDestroyNormal
34 * @tc.desc: Test for creating and destroying an image object with normal parameters.
35 * @tc.size  : SmallTest
36 * @tc.type  : Function
37 * @tc.level : Level 0
38 */
39HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyNormal, TestSize.Level0) {
40    // 1. OH_Drawing_ImageCreate
41    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
42    // 2. OH_Drawing_ImageDestroy
43    OH_Drawing_ImageDestroy(image);
44}
45
46/*
47 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0101
48 * @tc.name: testImageCreateDestroyNULL
49 * @tc.desc: Test for destroying an image object with a NULL parameter.
50 * @tc.size  : SmallTest
51 * @tc.type  : Function
52 * @tc.level : Level 3
53 */
54HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyNULL, TestSize.Level3) {
55    // 1. OH_Drawing_ImageDestroy with a NULL parameter
56    OH_Drawing_ImageDestroy(nullptr);
57}
58
59/*
60 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0102
61 * @tc.name: testImageCreateDestroyMultipleCalls
62 * @tc.desc: Test for multiple calls of creating and destroying an image object.
63 * @tc.size  : SmallTest
64 * @tc.type  : Function
65 * @tc.level : Level 3
66 */
67HWTEST_F(DrawingNativeImageTest, testImageCreateDestroyMultipleCalls, TestSize.Level3) {
68    // 1. Call OH_Drawing_ImageCreate and OH_Drawing_ImageDestroy 10 times
69    for (int i = 0; i < 10; i++) {
70        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
71        OH_Drawing_ImageDestroy(image);
72    }
73    // 2. Call OH_Drawing_ImageCreate 10 times continuously
74    OH_Drawing_Image *images[10];
75    for (int i = 0; i < 10; i++) {
76        images[i] = OH_Drawing_ImageCreate();
77    }
78    // 3. Call OH_Drawing_ImageDestroy 10 times continuously
79    for (int i = 0; i < 10; i++) {
80        OH_Drawing_ImageDestroy(images[i]);
81    }
82}
83
84/*
85 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0200
86 * @tc.name: testImageBuildFromBitmapNormal
87 * @tc.desc: Test for building an image from a bitmap with normal parameters.
88 * @tc.size  : SmallTest
89 * @tc.type  : Function
90 * @tc.level : Level 0
91 */
92HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapNormal, TestSize.Level0) {
93    // 1. OH_Drawing_ImageCreate
94    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
95    // 2. OH_Drawing_BitmapCreate
96    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
97    // 3. OH_Drawing_ImageBuildFromBitmap successfully constructs the image content
98    OH_Drawing_ImageBuildFromBitmap(image, bitmap);
99    EXPECT_NE(bitmap, nullptr);
100    // 4. OH_Drawing_ImageBuildFromBitmap fails to construct the image content
101    OH_Drawing_ImageBuildFromBitmap(image, nullptr);
102    // 5. Free memory
103    OH_Drawing_ImageDestroy(image);
104    OH_Drawing_BitmapDestroy(bitmap);
105}
106
107/*
108 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0201
109 * @tc.name: testImageBuildFromBitmapNULL
110 * @tc.desc: Test for building an image from a bitmap with NULL parameters.
111 * @tc.size  : SmallTest
112 * @tc.type  : Function
113 * @tc.level : Level 3
114 */
115HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapNULL, TestSize.Level3) {
116    // 1. OH_Drawing_ImageCreate
117    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
118    // 2. OH_Drawing_BitmapCreate
119    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
120    // 3. OH_Drawing_ImageBuildFromBitmap with a null parameter, check the error code with OH_Drawing_ErrorCodeGet
121    OH_Drawing_ImageBuildFromBitmap(nullptr, bitmap);
122    EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER);
123    // 4. OH_Drawing_ImageBuildFromBitmap with a null parameter, check the error code with OH_Drawing_ErrorCodeGet
124    OH_Drawing_ImageBuildFromBitmap(image, nullptr);
125    EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER);
126    // 5. Free memory
127    OH_Drawing_ImageDestroy(image);
128    OH_Drawing_BitmapDestroy(bitmap);
129}
130
131/*
132 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0202
133 * @tc.name: testImageBuildFromBitmapMultipleCalls
134 * @tc.desc: Test for multiple calls of building an image from a bitmap.
135 * @tc.size  : SmallTest
136 * @tc.type  : Function
137 * @tc.level : Level 3
138 */
139HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapMultipleCalls, TestSize.Level3) {
140    for (int i = 0; i < 10; i++) {
141        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
142        OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
143        OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
144        uint32_t width = 200 + i * 10;
145        uint32_t height = 200 + i * 10;
146        OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
147        OH_Drawing_ImageBuildFromBitmap(image, bitmap);
148        OH_Drawing_ImageDestroy(image);
149        OH_Drawing_BitmapDestroy(bitmap);
150    }
151}
152
153/*
154 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0203
155 * @tc.name: testImageBuildFromBitmapMultipleCallsBoundary
156 * @tc.desc: Test for multiple calls of building an boundary value image from a bitmap.
157 * @tc.size  : SmallTest
158 * @tc.type  : Function
159 * @tc.level : Level 3
160 */
161HWTEST_F(DrawingNativeImageTest, testImageBuildFromBitmapMultipleCallsBoundary, TestSize.Level3) {
162    for (int i = 0; i < 10; i++) {
163        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
164        OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
165        OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
166        uint32_t width = 4096;
167        uint32_t height = 2160;
168        OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
169        OH_Drawing_ImageBuildFromBitmap(image, bitmap);
170        OH_Drawing_ImageDestroy(image);
171        OH_Drawing_BitmapDestroy(bitmap);
172    }
173}
174
175/*
176 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0300
177 * @tc.name: testImageGetWidthHeightNormal
178 * @tc.desc: Test for getting width and height of an image with normal parameters.
179 * @tc.size  : SmallTest
180 * @tc.type  : Function
181 * @tc.level : Level 0
182 */
183HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightNormal, TestSize.Level0) {
184    // 1. OH_Drawing_ImageCreate
185    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
186    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
187    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
188    constexpr uint32_t width = 200;
189    constexpr uint32_t height = 200;
190    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
191    OH_Drawing_ImageBuildFromBitmap(image, bitmap);
192    // 2. OH_Drawing_ImageGetWidth
193    int32_t width_ = OH_Drawing_ImageGetWidth(image);
194    EXPECT_EQ(width_, 200);
195    // 3. OH_Drawing_ImageGetHeight
196    int32_t height_ = OH_Drawing_ImageGetHeight(image);
197    EXPECT_EQ(height_, 200);
198    // 4. Free memory
199    OH_Drawing_ImageDestroy(image);
200    OH_Drawing_BitmapDestroy(bitmap);
201}
202
203/*
204 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0301
205 * @tc.name: testImageGetWidthHeightNULL
206 * @tc.desc: Test for getting width and height of an image with NULL parameters.
207 * @tc.size  : SmallTest
208 * @tc.type  : Function
209 * @tc.level : Level 3
210 */
211HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightNULL, TestSize.Level3) {
212    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
213    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
214    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
215    uint32_t width = 200;
216    uint32_t height = 200;
217    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
218    OH_Drawing_ImageBuildFromBitmap(image, bitmap);
219    // 1. OH_Drawing_ImageGetWidth with a null parameter, check the error code with OH_Drawing_ErrorCodeGet
220    OH_Drawing_ImageGetWidth(nullptr);
221    EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER);
222    // 2. OH_Drawing_ImageGetHeight with a null parameter, check the error code with OH_Drawing_ErrorCodeGet
223    OH_Drawing_ImageGetHeight(nullptr);
224    EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER);
225}
226
227/*
228 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0302
229 * @tc.name: testImageGetWidthHeightMultipleCalls
230 * @tc.desc: Test for multiple calls of getting width and height of an image.
231 * @tc.size  : SmallTest
232 * @tc.type  : Function
233 * @tc.level : Level 3
234 */
235HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightMultipleCalls, TestSize.Level3) {
236    for (int i = 0; i < 10; i++) {
237        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
238        OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
239        OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
240        uint32_t width = 200 + i * 10;
241        uint32_t height = 200 + i * 10;
242        OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
243        OH_Drawing_ImageBuildFromBitmap(image, bitmap);
244        int32_t width_ = OH_Drawing_ImageGetWidth(image);
245        EXPECT_EQ(width_, 200 + i * 10);
246        int32_t height_ = OH_Drawing_ImageGetHeight(image);
247        EXPECT_EQ(height_, 200 + i * 10);
248        OH_Drawing_ImageDestroy(image);
249        OH_Drawing_BitmapDestroy(bitmap);
250    }
251}
252
253/*
254 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0302
255 * @tc.name: testImageGetWidthHeightMultipleCallsBoundary
256 * @tc.desc: Test for multiple calls of getting width and height of an boundary value image.
257 * @tc.size  : SmallTest
258 * @tc.type  : Function
259 * @tc.level : Level 3
260 */
261HWTEST_F(DrawingNativeImageTest, testImageGetWidthHeightMultipleCallsBoundary, TestSize.Level3) {
262    for (int i = 0; i < 10; i++) {
263        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
264        OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
265        OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
266        uint32_t width = 4096;
267        uint32_t height = 2160;
268        OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
269        EXPECT_NE(bitmap, nullptr);
270        OH_Drawing_ImageBuildFromBitmap(image, bitmap);
271        EXPECT_NE(image, nullptr);
272        int32_t width_ = OH_Drawing_ImageGetWidth(image);
273        EXPECT_EQ(width_, 4096);
274        int32_t height_ = OH_Drawing_ImageGetHeight(image);
275        EXPECT_EQ(height_, 2160);
276        OH_Drawing_ImageDestroy(image);
277        OH_Drawing_BitmapDestroy(bitmap);
278    }
279}
280
281/*
282 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0400
283 * @tc.name: testImageGetImageInfoNormal
284 * @tc.desc: Test for getting image info with normal parameters.
285 * @tc.size  : SmallTest
286 * @tc.type  : Function
287 * @tc.level : Level 0
288 */
289HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoNormal, TestSize.Level0) {
290    OH_Drawing_ColorFormat cfs[] = {
291        COLOR_FORMAT_UNKNOWN,   COLOR_FORMAT_ALPHA_8,   COLOR_FORMAT_RGB_565,
292        COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888,
293    };
294    OH_Drawing_AlphaFormat afs[] = {
295        ALPHA_FORMAT_UNKNOWN,
296        ALPHA_FORMAT_OPAQUE,
297        ALPHA_FORMAT_PREMUL,
298        ALPHA_FORMAT_UNPREMUL,
299    };
300    for (OH_Drawing_ColorFormat cf : cfs) {
301        for (OH_Drawing_AlphaFormat af : afs) {
302            OH_Drawing_Image *image = OH_Drawing_ImageCreate();
303            OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
304            OH_Drawing_BitmapFormat cFormat{cf, af};
305            uint32_t width = 400;
306            uint32_t height = 400;
307            OH_Drawing_Image_Info imageInfo;
308            OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
309            OH_Drawing_ImageGetImageInfo(image, &imageInfo);
310            OH_Drawing_ImageDestroy(image);
311            OH_Drawing_BitmapDestroy(bitmap);
312        }
313    }
314}
315
316/*
317 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0401
318 * @tc.name: testImageGetImageInfoNULL
319 * @tc.desc: Test for getting image info with NULL parameters.
320 * @tc.size  : SmallTest
321 * @tc.type  : Function
322 * @tc.level : Level 3
323 */
324HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoNULL, TestSize.Level3) {
325    // 1. OH_Drawing_ImageCreate
326    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
327    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
328    // 2. OH_Drawing_Image_Info
329    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
330    uint32_t width = 400;
331    uint32_t height = 400;
332    OH_Drawing_Image_Info imageInfo;
333    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
334    OH_Drawing_ImageGetImageInfo(image, &imageInfo);
335    // 3. OH_Drawing_ImageGetImageInfo with a null parameter, check the error code with OH_Drawing_ErrorCodeGet
336    OH_Drawing_ImageGetImageInfo(nullptr, &imageInfo);
337    EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER);
338    // 4. Free memory
339    OH_Drawing_ImageDestroy(image);
340    OH_Drawing_BitmapDestroy(bitmap);
341}
342
343/*
344 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0402
345 * @tc.name: testImageGetImageInfoMultipleCalls
346 * @tc.desc: Test for multiple calls of getting image info.
347 * @tc.size  : SmallTest
348 * @tc.type  : Function
349 * @tc.level : Level 3
350 */
351HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoMultipleCalls, TestSize.Level3) {
352    OH_Drawing_ColorFormat cf[] = {
353        COLOR_FORMAT_UNKNOWN,   COLOR_FORMAT_ALPHA_8,   COLOR_FORMAT_RGB_565,
354        COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888,
355    };
356    OH_Drawing_AlphaFormat af[] = {
357        ALPHA_FORMAT_UNKNOWN,
358        ALPHA_FORMAT_OPAQUE,
359        ALPHA_FORMAT_PREMUL,
360        ALPHA_FORMAT_UNPREMUL,
361    };
362    for (int i = 0; i < 10; i++) {
363        OH_Drawing_Image *image = OH_Drawing_ImageCreate();
364        OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
365        srand(static_cast<unsigned int>(time(0)));
366        OH_Drawing_BitmapFormat cFormat{cf[rand() % 5 + 1], af[rand() % 3 + 1]};
367        uint32_t width = rand() % 100 + 1;
368        uint32_t height = rand() % 100 + 1;
369        OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
370        OH_Drawing_Image_Info imageInfo;
371        OH_Drawing_ImageGetImageInfo(image, &imageInfo);
372        OH_Drawing_ImageDestroy(image);
373        OH_Drawing_BitmapDestroy(bitmap);
374    }
375}
376
377/*
378 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0403
379 * @tc.name: testImageGetImageInfoAbnormal
380 * @tc.desc: Test for getting image info with abnormal parameters.
381 * @tc.size  : SmallTest
382 * @tc.type  : Function
383 * @tc.level : Level 3
384 */
385HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoAbnormal, TestSize.Level3) {
386    // 1. OH_Drawing_ImageCreate
387    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
388    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
389    // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=-400 and height=-400
390    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
391    uint32_t width = -400;
392    uint32_t height = -400;
393    OH_Drawing_Image_Info imageInfo;
394    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
395    OH_Drawing_ImageGetImageInfo(image, &imageInfo);
396    // 3. Free memory
397    OH_Drawing_ImageDestroy(image);
398    OH_Drawing_BitmapDestroy(bitmap);
399}
400
401/*
402 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0404
403 * @tc.name: testImageGetImageInfoMaximum
404 * @tc.desc: Test for getting image info with maximum values.
405 * @tc.size  : SmallTest
406 * @tc.type  : Function
407 * @tc.level : Level 3
408 */
409HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoMaximum, TestSize.Level3) {
410    // 1. OH_Drawing_ImageCreate
411    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
412    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
413    // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=maximum value and height=maximum value
414    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
415    uint32_t width = UINT32_MAX;
416    uint32_t height = UINT32_MAX;
417    OH_Drawing_Image_Info imageInfo;
418    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
419    OH_Drawing_ImageGetImageInfo(image, &imageInfo);
420    // 3. Free memory
421    OH_Drawing_ImageDestroy(image);
422    OH_Drawing_BitmapDestroy(bitmap);
423}
424
425/*
426 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_0405
427 * @tc.name: testImageGetImageInfoBoundary
428 * @tc.desc: Test for getting image info with Boundary value.
429 * @tc.size  : SmallTest
430 * @tc.type  : Function
431 * @tc.level : Level 3
432 */
433HWTEST_F(DrawingNativeImageTest, testImageGetImageInfoBoundary, TestSize.Level3) {
434    // 1. OH_Drawing_ImageCreate
435    OH_Drawing_Image *image = OH_Drawing_ImageCreate();
436    OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
437    // 2. OH_Drawing_ImageGetImageInfo creates OH_Drawing_Image_Info with width=maximum value and height=maximum value
438    OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
439    uint32_t width = 4096;
440    uint32_t height = 2160;
441    OH_Drawing_Image_Info imageInfo;
442    OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
443    EXPECT_NE(bitmap, nullptr);
444    OH_Drawing_ImageGetImageInfo(image, &imageInfo);
445    EXPECT_NE(image, nullptr);
446    // 3. Free memory
447    OH_Drawing_ImageDestroy(image);
448    OH_Drawing_BitmapDestroy(bitmap);
449}
450
451} // namespace Drawing
452} // namespace Rosen
453} // namespace OHOS