1 /*
2  * Copyright (C) 2021 Huawei Device 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 #include "pixelmap_native.h"
18 #include "pixelmap_native_impl.h"
19 #include "common_utils.h"
20 #include "image_source_native.h"
21 #include "securec.h"
22 #include "image_utils.h"
23 #include "native_color_space_manager.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::Media;
27 namespace OHOS {
28 namespace Media {
29 
30 constexpr int8_t ARGB_8888_BYTES = 4;
31 
32 class PixelMapNdk2Test : public testing::Test {
33 public:
PixelMapNdk2Test()34     PixelMapNdk2Test() {}
~PixelMapNdk2Test()35     ~PixelMapNdk2Test() {}
36 };
37 
38 constexpr int32_t bufferSize = 256;
39 static const std::string IMAGE_JPEG_PATH = "/data/local/tmp/image/test_jpeg_writeexifblob001.jpg";
40 static const std::string IMAGE_JPEG_PATH_TEST = "/data/local/tmp/image/test.jpg";
41 
42 /**
43  * @tc.name: OH_PixelmapInitializationOptions_Create
44  * @tc.desc: OH_PixelmapInitializationOptions_Create
45  * @tc.type: FUNC
46  */
47 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_Create, TestSize.Level3)
48 {
49     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Create start";
50     OH_Pixelmap_InitializationOptions *ops = nullptr;
51     Image_ErrorCode res = OH_PixelmapInitializationOptions_Create(&ops);
52     ASSERT_EQ(res, IMAGE_SUCCESS);
53     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Create end";
54 }
55 
56 /**
57  * @tc.name: OH_PixelmapInitializationOptions_SetGetWidth
58  * @tc.desc: OH_PixelmapInitializationOptions_SetGetWidth
59  * @tc.type: FUNC
60  */
61 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetWidth, TestSize.Level3)
62 {
63     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_GetWidth start";
64     OH_Pixelmap_InitializationOptions *ops = nullptr;
65     OH_PixelmapInitializationOptions_Create(&ops);
66     uint32_t width = 0;
67     OH_PixelmapInitializationOptions_SetWidth(ops, 1);
68     OH_PixelmapInitializationOptions_GetWidth(ops, &width);
69     ASSERT_EQ(width, 1);
70     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_GetWidth end";
71 }
72 
73 /**
74  * @tc.name: OH_PixelmapInitializationOptions_SetGetHeight
75  * @tc.desc: OH_PixelmapInitializationOptions_SetGetHeight
76  * @tc.type: FUNC
77  */
78 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetHeight, TestSize.Level3)
79 {
80     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetHeight start";
81     OH_Pixelmap_InitializationOptions *ops = nullptr;
82     OH_PixelmapInitializationOptions_Create(&ops);
83     uint32_t height = 0;
84     OH_PixelmapInitializationOptions_SetHeight(ops, 1);
85     OH_PixelmapInitializationOptions_GetHeight(ops, &height);
86     ASSERT_EQ(height, 1);
87     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetHeight end";
88 }
89 
90 /**
91  * @tc.name: OH_PixelmapInitializationOptions_SetGetPixelFormat
92  * @tc.desc: OH_PixelmapInitializationOptions_SetGetPixelFormat
93  * @tc.type: FUNC
94  */
95 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetPixelFormat, TestSize.Level3)
96 {
97     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetPixelFormat start";
98     OH_Pixelmap_InitializationOptions *ops = nullptr;
99     OH_PixelmapInitializationOptions_Create(&ops);
100     int32_t pixelFormat = 0;
101     OH_PixelmapInitializationOptions_SetPixelFormat(ops, 1);
102     OH_PixelmapInitializationOptions_GetPixelFormat(ops, &pixelFormat);
103     ASSERT_EQ(pixelFormat, 1);
104     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetPixelFormat end";
105 }
106 
107 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetAlphaType, TestSize.Level3)
108 {
109     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetAlphaType start";
110     OH_Pixelmap_InitializationOptions *ops = nullptr;
111     OH_PixelmapInitializationOptions_Create(&ops);
112     int32_t alphaType = 0;
113     OH_PixelmapInitializationOptions_SetAlphaType(ops, 1);
114     OH_PixelmapInitializationOptions_GetAlphaType(ops, &alphaType);
115     ASSERT_EQ(alphaType, 1);
116     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_SetGetAlphaType end";
117 }
118 
119 /**
120  * @tc.name: OH_PixelmapInitializationOptions_Release
121  * @tc.desc: OH_PixelmapInitializationOptions_Release
122  * @tc.type: FUNC
123  */
124 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_Release, TestSize.Level3)
125 {
126     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Release start";
127     OH_Pixelmap_InitializationOptions *ops = nullptr;
128     Image_ErrorCode ret = OH_PixelmapInitializationOptions_Release(ops);
129     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
130     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapInitializationOptions_Release end";
131 }
132 
133 /**
134  * @tc.name: OH_PixelmapImageInfo_Create
135  * @tc.desc: OH_PixelmapImageInfo_Create
136  * @tc.type: FUNC
137  */
138 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_Create, TestSize.Level3)
139 {
140     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Create start";
141     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
142     Image_ErrorCode ret = OH_PixelmapImageInfo_Create(&ImageInfo);
143     ASSERT_EQ(ret, IMAGE_SUCCESS);
144     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Create end";
145 }
146 
147 /**
148  * @tc.name: OH_PixelmapImageInfo_GetWidth
149  * @tc.desc: OH_PixelmapImageInfo_GetWidth
150  * @tc.type: FUNC
151  */
152 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetWidth, TestSize.Level3)
153 {
154     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetWidth start";
155     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
156     uint32_t width = 0;
157     Image_ErrorCode ret = OH_PixelmapImageInfo_GetWidth(ImageInfo, &width);
158     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
159     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetWidth end";
160 }
161 
162 /**
163  * @tc.name: OH_PixelmapImageInfo_GetHeight
164  * @tc.desc: OH_PixelmapImageInfo_GetHeight
165  * @tc.type: FUNC
166  */
167 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetHeight, TestSize.Level3)
168 {
169     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetHeight start";
170     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
171     uint32_t height = 0;
172     Image_ErrorCode ret = OH_PixelmapImageInfo_GetHeight(ImageInfo, &height);
173     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
174     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetHeight end";
175 }
176 
177 /**
178  * @tc.name: OH_PixelmapImageInfo_GetRowStride
179  * @tc.desc: OH_PixelmapImageInfo_GetRowStride
180  * @tc.type: FUNC
181  */
182 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetRowStride, TestSize.Level3)
183 {
184     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetRowStride start";
185     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
186     uint32_t rowSize = 0;
187     Image_ErrorCode ret = OH_PixelmapImageInfo_GetRowStride(ImageInfo, &rowSize);
188     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
189     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetRowStride end";
190 }
191 
192 /**
193  * @tc.name: OH_PixelmapImageInfo_GetPixelFormat
194  * @tc.desc: OH_PixelmapImageInfo_GetPixelFormat
195  * @tc.type: FUNC
196  */
197 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetPixelFormat, TestSize.Level3)
198 {
199     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetPixelFormat start";
200     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
201     int32_t pixelFormat = 0;
202     Image_ErrorCode ret = OH_PixelmapImageInfo_GetPixelFormat(ImageInfo, &pixelFormat);
203     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
204     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetPixelFormat end";
205 }
206 
207 /**
208  * @tc.name: OH_PixelmapImageInfo_GetAlphaType
209  * @tc.desc: OH_PixelmapImageInfo_GetAlphaType
210  * @tc.type: FUNC
211  */
212 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_GetAlphaType, TestSize.Level3)
213 {
214     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetAlphaType start";
215     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
216     int32_t density = 0;
217     Image_ErrorCode ret = OH_PixelmapImageInfo_GetAlphaType(ImageInfo, &density);
218     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
219     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_GetAlphaType end";
220 }
221 
222 /**
223  * @tc.name: OH_PixelmapImageInfo_Release
224  * @tc.desc: OH_PixelmapImageInfo_Release
225  * @tc.type: FUNC
226  */
227 HWTEST_F(PixelMapNdk2Test, OH_PixelmapImageInfo_Release, TestSize.Level3)
228 {
229     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Release start";
230     OH_Pixelmap_ImageInfo *ImageInfo = nullptr;
231     Image_ErrorCode ret = OH_PixelmapImageInfo_Release(ImageInfo);
232     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
233     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapImageInfo_Release end";
234 }
235 
236 /**
237  * @tc.name: OH_PixelmapNative_CreatePixelMap
238  * @tc.desc: OH_PixelmapNative_CreatePixelMap
239  * @tc.type: FUNC
240  */
241 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreatePixelMap, TestSize.Level3)
242 {
243     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreatePixelMap start";
244     uint8_t *colors = nullptr;
245     size_t colorLength = 0;
246     OH_Pixelmap_InitializationOptions *opts = nullptr;
247     OH_PixelmapNative *pixelMap = nullptr;
248     Image_ErrorCode ret = OH_PixelmapNative_CreatePixelmap(colors, colorLength, opts, &pixelMap);
249     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
250     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreatePixelMap end";
251 }
252 
253 /**
254  * @tc.name: OH_PixelmapNative_ConvertPixelmapNativeToNapi
255  * @tc.desc: test OH_PixelmapNative_ConvertPixelmapNativeToNapi
256  * @tc.type: FUNC
257  */
258 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertPixelmapNativeToNapi, TestSize.Level3)
259 {
260     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeToNapi start";
261     napi_env env = nullptr;
262     OH_PixelmapNative *pixelMap = nullptr;
263     napi_value res = nullptr;
264     Image_ErrorCode ret = OH_PixelmapNative_ConvertPixelmapNativeToNapi(env, pixelMap, &res);
265     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
266     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeToNapi end";
267 }
268 
269 /**
270  * @tc.name: OH_PixelmapNative_ConvertPixelmapNativeFromNapi
271  * @tc.desc: test OH_PixelmapNative_ConvertPixelmapNativeFromNapi
272  * @tc.type: FUNC
273  */
274 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertPixelmapNativeFromNapi, TestSize.Level3)
275 {
276     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeFromNapi start";
277     napi_env env = nullptr;
278     napi_value source = nullptr;
279     OH_PixelmapNative *pixelMap = nullptr;
280     Image_ErrorCode ret = OH_PixelmapNative_ConvertPixelmapNativeFromNapi(env, source, &pixelMap);
281     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
282     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertPixelmapNativeFromNapi end";
283 }
284 
285 /**
286  * @tc.name: OH_PixelmapNative_ReadPixels
287  * @tc.desc: OH_PixelmapNative_ReadPixels
288  * @tc.type: FUNC
289  */
290 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ReadPixels, TestSize.Level3)
291 {
292     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ReadPixels start";
293     OH_PixelmapNative *pixelMap = nullptr;
294     uint8_t *buffer = nullptr;
295     size_t *bufferSize = nullptr;
296     Image_ErrorCode ret = OH_PixelmapNative_ReadPixels(pixelMap, buffer, bufferSize);
297     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
298     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ReadPixels end";
299 }
300 
301 /**
302  * @tc.name: OH_PixelmapNative_WritePixels
303  * @tc.desc: OH_PixelmapNative_WritePixels
304  * @tc.type: FUNC
305  */
306 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_WritePixels, TestSize.Level3)
307 {
308     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_WritePixels start";
309     OH_PixelmapNative *pixelMap = nullptr;
310     uint8_t *source = nullptr;
311     size_t bufferSize = 0;
312     Image_ErrorCode ret = OH_PixelmapNative_WritePixels(pixelMap, source, bufferSize);
313     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
314     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_WritePixels end";
315 }
316 
317 /**
318  * @tc.name: OH_PixelmapNative_GetArgbPixels_Test001
319  * @tc.desc: Test OH_PixelmapNative_GetArgbPixels with valid inputs
320  * @tc.type: FUNC
321  */
322 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetArgbPixels_Test001, TestSize.Level3)
323 {
324     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test001 start";
325 
326     size_t dataSize = ARGB_8888_BYTES;
327     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
328     OH_Pixelmap_InitializationOptions *createOpts;
329     OH_PixelmapInitializationOptions_Create(&createOpts);
330     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
331     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
332     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
333     OH_PixelmapNative *pixelMap = nullptr;
334     Image_ErrorCode errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
335     ASSERT_EQ(errCode, IMAGE_SUCCESS);
336 
337     uint8_t result[ARGB_8888_BYTES];
338     errCode = OH_PixelmapNative_GetArgbPixels(pixelMap, result, &dataSize);
339     ASSERT_EQ(errCode, IMAGE_SUCCESS);
340     ASSERT_EQ(result[0], data[3]);
341     ASSERT_EQ(result[1], data[2]);
342     ASSERT_EQ(result[2], data[1]);
343     ASSERT_EQ(result[3], data[0]);
344 
345     OH_PixelmapNative_Release(pixelMap);
346     OH_PixelmapInitializationOptions_Release(createOpts);
347 
348     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test001 end";
349 }
350 
351 /**
352  * @tc.name: OH_PixelmapNative_GetArgbPixels_Test002
353  * @tc.desc: Test OH_PixelmapNative_GetArgbPixels with invalid inputs
354  * @tc.type: FUNC
355  */
356 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetArgbPixels_Test002, TestSize.Level3)
357 {
358     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test002 start";
359     OH_PixelmapNative *pixelMap = nullptr;
360     uint8_t *buffer = nullptr;
361     size_t *bufferSize = nullptr;
362     Image_ErrorCode errCode = OH_PixelmapNative_GetArgbPixels(pixelMap, buffer, bufferSize);
363     ASSERT_EQ(errCode, IMAGE_BAD_PARAMETER);
364     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetArgbPixels_Test002 end";
365 }
366 
367 /**
368  * @tc.name: OH_PixelmapNative_GetImageInfo
369  * @tc.desc: OH_PixelmapNative_GetImageInfo
370  * @tc.type: FUNC
371  */
372 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_GetImageInfo, TestSize.Level3)
373 {
374     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetImageInfo start";
375     OH_PixelmapNative *pixelMap = nullptr;
376     OH_Pixelmap_ImageInfo *imageInfo = nullptr;
377     Image_ErrorCode ret = OH_PixelmapNative_GetImageInfo(pixelMap, imageInfo);
378     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
379     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_GetImageInfo end";
380 }
381 
382 /**
383  * @tc.name: OH_PixelmapNative_Opacity
384  * @tc.desc: OH_PixelmapNative_Opacity
385  * @tc.type: FUNC
386  */
387 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Opacity, TestSize.Level3)
388 {
389     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Opacity start";
390     OH_PixelmapNative *pixelMap = nullptr;
391     float rate = 0;
392     Image_ErrorCode ret = OH_PixelmapNative_Opacity(pixelMap, rate);
393     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
394     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Opacity end";
395 }
396 
397 /**
398  * @tc.name: OH_PixelmapNative_Scale
399  * @tc.desc: OH_PixelmapNative_Scale
400  * @tc.type: FUNC
401  */
402 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Scale, TestSize.Level3)
403 {
404     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Scale start";
405     OH_PixelmapNative *pixelMap = nullptr;
406     float x = 0;
407     float y = 0;
408     Image_ErrorCode ret = OH_PixelmapNative_Scale(pixelMap, x, y);
409     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
410     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Scale end";
411 }
412 
413 /**
414  * @tc.name: OH_PixelmapNative_ScaleWithAntiAliasing
415  * @tc.desc: OH_PixelmapNative_ScaleWithAntiAliasing
416  * @tc.type: FUNC
417  */
418 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ScaleWithAntiAliasing, TestSize.Level3)
419 {
420     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ScaleWithAntiAliasing start";
421     OH_PixelmapNative *pixelMap = nullptr;
422     float x = 0;
423     float y = 0;
424     Image_ErrorCode ret = OH_PixelmapNative_ScaleWithAntiAliasing(pixelMap, x, y,
425         OH_PixelmapNative_AntiAliasingLevel::OH_PixelmapNative_AntiAliasing_NONE);
426     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
427     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ScaleWithAntiAliasing end";
428 }
429 
430 /**
431  * @tc.name: OH_PixelmapNative_Translate
432  * @tc.desc: OH_PixelmapNative_Translate
433  * @tc.type: FUNC
434  */
435 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Translate, TestSize.Level3)
436 {
437     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Translate start";
438     OH_PixelmapNative *pixelMap = nullptr;
439     float x = 0;
440     float y = 0;
441     Image_ErrorCode ret = OH_PixelmapNative_Translate(pixelMap, x, y);
442     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
443     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Translate end";
444 }
445 
446 /**
447  * @tc.name: OH_PixelmapNative_Rotate
448  * @tc.desc: OH_PixelmapNative_Rotate
449  * @tc.type: FUNC
450  */
451 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Rotate, TestSize.Level3)
452 {
453     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Rotate start";
454     OH_PixelmapNative *pixelMap = nullptr;
455     float angle = 0;
456     Image_ErrorCode ret = OH_PixelmapNative_Rotate(pixelMap, angle);
457     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
458     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Rotate end";
459 }
460 
461 /**
462  * @tc.name: OH_PixelmapNative_Flip
463  * @tc.desc: OH_PixelmapNative_Flip
464  * @tc.type: FUNC
465  */
466 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Flip, TestSize.Level3)
467 {
468     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Flip start";
469     OH_PixelmapNative *pixelMap = nullptr;
470     bool horizontal = 0;
471     bool vertical = 0;
472     Image_ErrorCode ret = OH_PixelmapNative_Flip(pixelMap, horizontal, vertical);
473     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
474     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Flip end";
475 }
476 
477 /**
478  * @tc.name: OH_PixelmapNative_Crop
479  * @tc.desc: OH_PixelmapNative_Crop
480  * @tc.type: FUNC
481  */
482 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Crop, TestSize.Level3)
483 {
484     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Crop start";
485     OH_PixelmapNative *pixelMap = nullptr;
486     Image_Region *region = nullptr;
487     Image_ErrorCode ret = OH_PixelmapNative_Crop(pixelMap, region);
488     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
489     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Crop end";
490 }
491 
492 /**
493  * @tc.name: OH_PixelmapNative_Release
494  * @tc.desc: OH_PixelmapNative_Release
495  * @tc.type: FUNC
496  */
497 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_Release, TestSize.Level3)
498 {
499     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Release start";
500     OH_PixelmapNative *pixelMap = nullptr;
501     Image_ErrorCode ret = OH_PixelmapNative_Release(pixelMap);
502     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
503     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_Release end";
504 }
505 
506 /**
507  * @tc.name: OH_PixelmapInitializationOptions_SetGetSrcPixelFormat
508  * @tc.desc: OH_PixelmapInitializationOptions_SetGetSrcPixelFormat
509  * @tc.type: FUNC
510  */
511 HWTEST_F(PixelMapNdk2Test, OH_PixelmapInitializationOptions_SetGetSrcPixelFormat, TestSize.Level3)
512 {
513     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetSrcPixelFormat start";
514     OH_Pixelmap_InitializationOptions *ops = nullptr;
515     OH_PixelmapInitializationOptions_Create(&ops);
516     int32_t srcpixelFormat = 0;
517     OH_PixelmapInitializationOptions_SetSrcPixelFormat(ops, 1);
518     OH_PixelmapInitializationOptions_GetSrcPixelFormat(ops, &srcpixelFormat);
519     ASSERT_EQ(srcpixelFormat, 1);
520     Image_ErrorCode ret = OH_PixelmapInitializationOptions_Release(ops);
521     ASSERT_EQ(ret, IMAGE_SUCCESS);
522     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_InitializationSetOptionsGetSrcPixelFormat end";
523 }
524 
525 /**
526  * @tc.name: OH_PixelmapNative_CreateEmptyPixelmap
527  * @tc.desc: OH_PixelmapNative_CreateEmptyPixelmap
528  * @tc.type: FUNC
529  */
530 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_CreateEmptyPixelmap, TestSize.Level3)
531 {
532     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateEmptyPixelmap start";
533     OH_Pixelmap_InitializationOptions *options = nullptr;
534     OH_PixelmapNative **pixelmap = nullptr;
535     Image_ErrorCode ret = OH_PixelmapNative_CreateEmptyPixelmap(options, pixelmap);
536     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
537     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_CreateEmptyPixelmap end";
538 }
539 
540 /**
541  * @tc.name: OH_PixelmapNative_ConvertAlphaFormat
542  * @tc.desc: OH_PixelmapNative_ConvertAlphaFormat
543  * @tc.type: FUNC
544  */
545 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_ConvertAlphaFormat, TestSize.Level3)
546 {
547     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertAlphaFormat start";
548     OH_PixelmapNative* srcpixelmap = nullptr;
549     OH_PixelmapNative* dstpixelmap = nullptr;
550     const bool isPremul = false;
551     Image_ErrorCode ret = OH_PixelmapNative_ConvertAlphaFormat(srcpixelmap, dstpixelmap, isPremul);
552     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
553     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_ConvertAlphaFormat end";
554 }
555 
556 /**
557  * @tc.name: OH_PixelmapNative_SetGetColorSpace
558  * @tc.desc: OH_PixelmapNative_SetGetColorSpace
559  * @tc.type: FUNC
560  */
561 HWTEST_F(PixelMapNdk2Test, OH_PixelmapNative_SetGetColorSpace, TestSize.Level3)
562 {
563     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetGetColorSpace start";
564     std::string realPath;
565     if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH.c_str(), realPath)) {
566         if (!ImageUtils::PathToRealPath(IMAGE_JPEG_PATH_TEST.c_str(), realPath)) {
567             return;
568         }
569     }
570     char filePath[bufferSize];
571     if (strcpy_s(filePath, sizeof(filePath), realPath.c_str()) != EOK) {
572         return;
573     }
574     size_t length = realPath.size();
575     OH_ImageSourceNative *source = nullptr;
576     Image_ErrorCode ret = OH_ImageSourceNative_CreateFromUri(filePath, length, &source);
577     EXPECT_EQ(ret, IMAGE_SUCCESS);
578 
579     OH_DecodingOptions *opts = nullptr;
580     OH_PixelmapNative *pixelmap = nullptr;
581     OH_DecodingOptions_Create(&opts);
582     ret = OH_ImageSourceNative_CreatePixelmap(source, opts, &pixelmap);
583     EXPECT_EQ(ret, IMAGE_SUCCESS);
584 
585     OH_NativeColorSpaceManager *setColorSpaceNative = nullptr;
586     ColorSpaceName setColorSpaceName = SRGB_LIMIT;
587     setColorSpaceNative = OH_NativeColorSpaceManager_CreateFromName(setColorSpaceName);
588     ret = OH_PixelmapNative_SetColorSpaceNative(pixelmap, setColorSpaceNative);
589     EXPECT_EQ(ret, IMAGE_SUCCESS);
590 
591     OH_NativeColorSpaceManager *getColorSpaceNative = nullptr;
592     ret = OH_PixelmapNative_GetColorSpaceNative(pixelmap, &getColorSpaceNative);
593     EXPECT_EQ(ret, IMAGE_SUCCESS);
594 
595     int getColorSpaceName = OH_NativeColorSpaceManager_GetColorSpaceName(getColorSpaceNative);
596     EXPECT_EQ(setColorSpaceName, getColorSpaceName);
597 
598     GTEST_LOG_(INFO) << "PixelMapNdk2Test: OH_PixelmapNative_SetGetColorSpace end";
599 }
600 
601 }
602 }
603