• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 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 "image_packer_native.h"
18 #include "image_packer_native_impl.h"
19 #include "file_packer_stream.h"
20 #include <fcntl.h>
21 #include "securec.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS::Media;
25 
26 namespace OHOS {
27 namespace Multimedia {
28 
29 constexpr int8_t ARGB_8888_BYTES = 4;
30 constexpr int32_t OUT_DATA_LENGTH = 1000;
31 class ImagePackerNdk2Test : public testing::Test {
32 public:
ImagePackerNdk2Test()33     ImagePackerNdk2Test() {}
~ImagePackerNdk2Test()34     ~ImagePackerNdk2Test() {}
35 };
36 
37 /**
38  * @tc.name: OH_ImageSourceInfo_Create
39  * @tc.desc: test OH_ImageSourceInfo_Create
40  * @tc.type: FUNC
41  */
42 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_Create, TestSize.Level3)
43 {
44     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImageSourceInfo_Create start";
45     OH_PackingOptions *ops = nullptr;
46     Image_ErrorCode ret = OH_PackingOptions_Create(&ops);
47     ASSERT_EQ(ret, IMAGE_SUCCESS);
48     OH_PackingOptions_Release(ops);
49     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImageSourceInfo_Create end";
50 }
51 
52 /**
53  * @tc.name: OH_PackingOptions_SetGetMimeType
54  * @tc.desc: test OH_PackingOptions_SetGetMimeType
55  * @tc.type: FUNC
56  */
57 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_SetGetMimeType, TestSize.Level3)
58 {
59     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_SetGetMimeType start";
60     OH_PackingOptions *ops = nullptr;
61     char str[10] = "";
62     char str2[10] = "12";
63     Image_MimeType *mimeType = new Image_MimeType();
64     mimeType->data = str;
65     mimeType->size = 0;
66     Image_MimeType *mimeType2 = new Image_MimeType();
67     mimeType2->data = str2;
68     mimeType2->size = 2;
69     Image_ErrorCode ret = OH_PackingOptions_Create(&ops);
70     ASSERT_EQ(ret, IMAGE_SUCCESS);
71     OH_PackingOptions_SetMimeType(ops, mimeType2);
72     OH_PackingOptions_GetMimeType(ops, mimeType);
73     ASSERT_EQ(mimeType->size, 2);
74     string res(mimeType->data, mimeType->size);
75     ASSERT_EQ(res, "12");
76     OH_PackingOptions_Release(ops);
77     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_SetGetMimeType end";
78 }
79 
80 /**
81  * @tc.name: OH_PackingOptions_GetMimeTypeWithNullTest001
82  * @tc.desc: test OH_PackingOptions_GetMimeTypeWithNull with null pointer
83  * @tc.type: FUNC
84  */
85 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_GetMimeTypeWithNullTest001, TestSize.Level3)
86 {
87     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_GetMimeTypeWithNullTest001 start";
88     OH_PackingOptions *ops = nullptr;
89     Image_MimeType *mimeType = nullptr;
90     Image_ErrorCode ret = OH_PackingOptions_Create(&ops);
91     ASSERT_EQ(ret, IMAGE_SUCCESS);
92     ret = OH_PackingOptions_GetMimeTypeWithNull(ops, mimeType);
93     ASSERT_NE(ret, IMAGE_SUCCESS);
94     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_GetMimeTypeWithNullTest001 end";
95 }
96 
97 /**
98  * @tc.name: OH_PackingOptions_GetMimeTypeWithNullTest002
99  * @tc.desc: test OH_PackingOptions_GetMimeTypeWithNull with right value
100  * @tc.type: FUNC
101  */
102 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_GetMimeTypeWithNullTest002, TestSize.Level3)
103 {
104     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_GetMimeTypeWithNullTest002 start";
105     OH_PackingOptions *ops = nullptr;
106     char str[10] = "";
107     char str2[10] = "12";
108     Image_MimeType *mimeType = new Image_MimeType();
109     mimeType->data = str;
110     mimeType->size = 0;
111     Image_MimeType *mimeType2 = new Image_MimeType();
112     mimeType2->data = str2;
113     mimeType2->size = 2;
114     Image_ErrorCode ret = OH_PackingOptions_Create(&ops);
115     ASSERT_EQ(ret, IMAGE_SUCCESS);
116     OH_PackingOptions_SetMimeType(ops, mimeType2);
117     OH_PackingOptions_GetMimeTypeWithNull(ops, mimeType);
118     ASSERT_EQ(mimeType->size, 2);
119     string res(mimeType->data, mimeType->size);
120     ASSERT_EQ(res, "12");
121     OH_PackingOptions_Release(ops);
122     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_GetMimeTypeWithNullTest002 end";
123 }
124 
125 /**
126  * @tc.name: OH_PackingOptions_Release
127  * @tc.desc: test OH_PackingOptions_Release
128  * @tc.type: FUNC
129  */
130 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_Release, TestSize.Level3)
131 {
132     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_Release start";
133     OH_PackingOptions *ops = nullptr;
134     Image_ErrorCode ret = OH_PackingOptions_Release(ops);
135     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
136     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_Release end";
137 }
138 
139 /**
140  * @tc.name: OH_ImagePackerNative_Create
141  * @tc.desc: test OH_ImagePackerNative_Create
142  * @tc.type: FUNC
143  */
144 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_Create, TestSize.Level3)
145 {
146     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Create start";
147     OH_ImagePackerNative *imagePacker = nullptr;
148     Image_ErrorCode ret = OH_ImagePackerNative_Create(&imagePacker);
149     ASSERT_EQ(ret, IMAGE_SUCCESS);
150     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Create end";
151 }
152 
153 /**
154  * @tc.name: OH_ImagePackerNative_PackToDataFromImageSource
155  * @tc.desc: test OH_ImagePackerNative_PackToDataFromImageSource
156  * @tc.type: FUNC
157  */
158 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromImageSource, TestSize.Level3)
159 {
160     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromImageSource start";
161     OH_ImagePackerNative *imagePacker = nullptr;
162     OH_PackingOptions* option = nullptr;
163     OH_ImageSourceNative* imageSource = nullptr;
164     uint8_t* outData = nullptr;
165     size_t *size = nullptr;
166     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromImageSource(imagePacker, option, imageSource,
167         outData, size);
168     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
169     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromImageSource end";
170 }
171 
172 /**
173  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmap
174  * @tc.desc: test OH_ImagePackerNative_PackToDataFromPixelmap
175  * @tc.type: FUNC
176  */
177 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmap, TestSize.Level3)
178 {
179     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmap start";
180     OH_ImagePackerNative *imagePacker = nullptr;
181     OH_PackingOptions* option = nullptr;
182     OH_PixelmapNative* pixelMap = nullptr;
183     uint8_t* outData = nullptr;
184     size_t *size = nullptr;
185     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmap(imagePacker, option, pixelMap, outData, size);
186     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
187     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmap end";
188 }
189 
190 /**
191  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence001
192  * @tc.desc: test imagePacker is nullptr
193  * @tc.type: FUNC
194  */
195 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence001, TestSize.Level3)
196 {
197     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 start";
198     OH_ImagePackerNative *imagePacker = nullptr;
199 
200     OH_PackingOptionsForSequence* option = nullptr;
201     Image_ErrorCode errCode = OH_PackingOptionsForSequence_Create(&option);
202     ASSERT_EQ(errCode, IMAGE_SUCCESS);
203     ASSERT_NE(option, nullptr);
204 
205     size_t dataSize = ARGB_8888_BYTES;
206     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
207     OH_Pixelmap_InitializationOptions *createOpts;
208     OH_PixelmapInitializationOptions_Create(&createOpts);
209     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
210     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
211     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
212     std::vector<OH_PixelmapNative*> pixelMaps;
213     OH_PixelmapNative* pixelMap = nullptr;
214     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
215     pixelMaps.push_back(pixelMap);
216     ASSERT_EQ(errCode, IMAGE_SUCCESS);
217     ASSERT_NE(pixelMaps.data(), nullptr);
218 
219     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
220     ASSERT_NE(outData.get(), nullptr);
221 
222     size_t outDataSize = 0;
223     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
224         pixelMaps.data(), 0, outData.get(), &outDataSize);
225     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
226     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 end";
227 }
228 
229 /**
230  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence002
231  * @tc.desc: test options is nullptr
232  * @tc.type: FUNC
233  */
234 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence002, TestSize.Level3)
235 {
236     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence002 start";
237     OH_ImagePackerNative *imagePacker = nullptr;
238     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
239     EXPECT_EQ(errCode, IMAGE_SUCCESS);
240     ASSERT_NE(imagePacker, nullptr);
241 
242     OH_PackingOptionsForSequence* option = nullptr;
243 
244     size_t dataSize = ARGB_8888_BYTES;
245     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
246     OH_Pixelmap_InitializationOptions *createOpts;
247     OH_PixelmapInitializationOptions_Create(&createOpts);
248     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
249     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
250     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
251     std::vector<OH_PixelmapNative*> pixelMaps;
252     OH_PixelmapNative* pixelMap = nullptr;
253     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
254     pixelMaps.push_back(pixelMap);
255     ASSERT_EQ(errCode, IMAGE_SUCCESS);
256     ASSERT_NE(pixelMaps.data(), nullptr);
257 
258     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
259     ASSERT_NE(outData.get(), nullptr);
260 
261     size_t outDataSize = 0;
262     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
263         pixelMaps.data(), 0, outData.get(), &outDataSize);
264     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
265     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 end";
266 }
267 
268 /**
269  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence003
270  * @tc.desc: test pixelmapSequence is nullptr
271  * @tc.type: FUNC
272  */
273 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence003, TestSize.Level3)
274 {
275     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence003 start";
276     OH_ImagePackerNative *imagePacker = nullptr;
277     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
278     EXPECT_EQ(errCode, IMAGE_SUCCESS);
279     ASSERT_NE(imagePacker, nullptr);
280 
281     OH_PackingOptionsForSequence* option = nullptr;
282     errCode = OH_PackingOptionsForSequence_Create(&option);
283     ASSERT_EQ(errCode, IMAGE_SUCCESS);
284     ASSERT_NE(option, nullptr);
285 
286     OH_PixelmapNative **pixelMaps = nullptr;
287 
288     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
289     ASSERT_NE(outData.get(), nullptr);
290 
291     size_t outDataSize = 0;
292     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
293         pixelMaps, 0, outData.get(), &outDataSize);
294     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
295     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence003 end";
296 }
297 
298 /**
299  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence004
300  * @tc.desc: test outData is nullptr
301  * @tc.type: FUNC
302  */
303 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence004, TestSize.Level3)
304 {
305     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence004 start";
306     OH_ImagePackerNative *imagePacker = nullptr;
307     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
308     EXPECT_EQ(errCode, IMAGE_SUCCESS);
309     ASSERT_NE(imagePacker, nullptr);
310 
311     OH_PackingOptionsForSequence* option = nullptr;
312     errCode = OH_PackingOptionsForSequence_Create(&option);
313     ASSERT_EQ(errCode, IMAGE_SUCCESS);
314     ASSERT_NE(option, nullptr);
315 
316     size_t dataSize = ARGB_8888_BYTES;
317     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
318     OH_Pixelmap_InitializationOptions *createOpts;
319     OH_PixelmapInitializationOptions_Create(&createOpts);
320     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
321     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
322     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
323     std::vector<OH_PixelmapNative*> pixelMaps;
324     OH_PixelmapNative* pixelMap = nullptr;
325     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
326     pixelMaps.push_back(pixelMap);
327     ASSERT_EQ(errCode, IMAGE_SUCCESS);
328     ASSERT_NE(pixelMaps.data(), nullptr);
329 
330     uint8_t* outData = nullptr;
331 
332     size_t outDataSize = 0;
333     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
334         pixelMaps.data(), 0, outData, &outDataSize);
335     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
336     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence004 end";
337 }
338 
339 /**
340  * @tc.name: OH_ImagePackerNative_PackToFileFromImageSource
341  * @tc.desc: test OH_ImagePackerNative_PackToFileFromImageSource
342  * @tc.type: FUNC
343  */
344 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromImageSource, TestSize.Level3)
345 {
346     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromImageSource start";
347     OH_ImagePackerNative *imagePacker = nullptr;
348     OH_PackingOptions* option = nullptr;
349     OH_ImageSourceNative* imageSource = nullptr;
350     int32_t fd = 0;
351     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromImageSource(imagePacker, option, imageSource, fd);
352     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
353     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromImageSource end";
354 }
355 
356 /**
357  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmap
358  * @tc.desc: test OH_ImagePackerNative_PackToFileFromPixelmap
359  * @tc.type: FUNC
360  */
361 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmap, TestSize.Level3)
362 {
363     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmap start";
364     OH_ImagePackerNative *imagePacker = nullptr;
365     OH_PackingOptions* option = nullptr;
366     OH_PixelmapNative* pixelMap = nullptr;
367     int32_t fd = 0;
368     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromPixelmap(imagePacker, option, pixelMap, fd);
369     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
370     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmap end";
371 }
372 
373 /**
374  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence001
375  * @tc.desc: test imagePacker is nullptr
376  * @tc.type: FUNC
377  */
378 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence001, TestSize.Level3)
379 {
380     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence001 start";
381     OH_ImagePackerNative *imagePacker = nullptr;
382 
383     OH_PackingOptionsForSequence* option = nullptr;
384     Image_ErrorCode errCode = OH_PackingOptionsForSequence_Create(&option);
385     ASSERT_EQ(errCode, IMAGE_SUCCESS);
386     ASSERT_NE(option, nullptr);
387 
388     size_t dataSize = ARGB_8888_BYTES;
389     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
390     OH_Pixelmap_InitializationOptions *createOpts;
391     OH_PixelmapInitializationOptions_Create(&createOpts);
392     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
393     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
394     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
395     std::vector<OH_PixelmapNative*> pixelMaps;
396     OH_PixelmapNative* pixelMap = nullptr;
397     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
398     pixelMaps.push_back(pixelMap);
399     ASSERT_EQ(errCode, IMAGE_SUCCESS);
400     ASSERT_NE(pixelMaps.data(), nullptr);
401 
402     int32_t fd = 0;
403     Image_ErrorCode ret =
404         OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps.data(), 0, fd);
405     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
406     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence001 end";
407 }
408 
409 /**
410  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence002
411  * @tc.desc: test option is nullptr
412  * @tc.type: FUNC
413  */
414 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence002, TestSize.Level3)
415 {
416     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence002 start";
417     OH_ImagePackerNative *imagePacker = nullptr;
418     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
419     EXPECT_EQ(errCode, IMAGE_SUCCESS);
420     ASSERT_NE(imagePacker, nullptr);
421 
422     OH_PackingOptionsForSequence* option = nullptr;
423 
424     size_t dataSize = ARGB_8888_BYTES;
425     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
426     OH_Pixelmap_InitializationOptions *createOpts;
427     OH_PixelmapInitializationOptions_Create(&createOpts);
428     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
429     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
430     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
431     std::vector<OH_PixelmapNative*> pixelMaps;
432     OH_PixelmapNative* pixelMap = nullptr;
433     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
434     pixelMaps.push_back(pixelMap);
435     ASSERT_EQ(errCode, IMAGE_SUCCESS);
436     ASSERT_NE(pixelMaps.data(), nullptr);
437 
438     int32_t fd = 0;
439     Image_ErrorCode ret =
440         OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps.data(), 0, fd);
441     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
442     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence002 end";
443 }
444 
445 /**
446  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence003
447  * @tc.desc: test pixelmapSequence is nullptr
448  * @tc.type: FUNC
449  */
450 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence003, TestSize.Level3)
451 {
452     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence003 start";
453     OH_ImagePackerNative *imagePacker = nullptr;
454     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
455     EXPECT_EQ(errCode, IMAGE_SUCCESS);
456     ASSERT_NE(imagePacker, nullptr);
457 
458     OH_PackingOptionsForSequence* option = nullptr;
459     errCode = OH_PackingOptionsForSequence_Create(&option);
460     ASSERT_EQ(errCode, IMAGE_SUCCESS);
461     ASSERT_NE(option, nullptr);
462 
463     OH_PixelmapNative **pixelMaps = nullptr;
464 
465     int32_t fd = 0;
466     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps, 0, fd);
467     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
468     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence003 end";
469 }
470 
471 /**
472  * @tc.name: OH_ImagePackerNative_Release
473  * @tc.desc: test OH_ImagePackerNative_Release
474  * @tc.type: FUNC
475  */
476 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_Release, TestSize.Level3)
477 {
478     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Release start";
479     OH_ImagePackerNative *imagePacker = nullptr;
480     Image_ErrorCode ret = OH_ImagePackerNative_Release(imagePacker);
481     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
482     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Release end";
483 }
484 
485 /**
486  * @tc.name: OH_ImageSourceNative_GetSupportedFormatTest001
487  * @tc.desc: Verify GetSupportedFormat returns valid format list with non-empty data and correct size.
488  * @tc.type: FUNC
489  */
490 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_GetSupportedFormatTest001, TestSize.Level3)
491 {
492     Image_MimeType* supportedFormat = nullptr;
493     size_t length = 0;
494     Image_ErrorCode ret = OH_ImagePackerNative_GetSupportedFormats(&supportedFormat, &length);
495     EXPECT_EQ(ret, IMAGE_SUCCESS);
496     for (size_t i = 0; i < length; i++) {
497         EXPECT_NE(supportedFormat[i].data, nullptr);
498         EXPECT_NE(supportedFormat[i].size, 0);
499     }
500     EXPECT_NE(length, 0);
501 }
502 
503 /**
504  * @tc.name: OH_ImagePackerNative_GetSupportedFormatTest002
505  * @tc.desc: Verify GetSupportedFormat returns IMAGE_PACKER_INVALID_PARAMETER when given null input parameters.
506  * @tc.type: FUNC
507  */
508 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_GetSupportedFormatTest002, TestSize.Level3)
509 {
510     Image_MimeType* supportedFormat = nullptr;
511     size_t length = 0;
512     Image_ErrorCode ret = OH_ImagePackerNative_GetSupportedFormats(nullptr, &length);
513     EXPECT_EQ(ret, IMAGE_PACKER_INVALID_PARAMETER);
514     ret = OH_ImagePackerNative_GetSupportedFormats(&supportedFormat, nullptr);
515     EXPECT_EQ(ret, IMAGE_PACKER_INVALID_PARAMETER);
516     ret = OH_ImagePackerNative_GetSupportedFormats(nullptr, nullptr);
517     EXPECT_EQ(ret, IMAGE_PACKER_INVALID_PARAMETER);
518 }
519 }
520 }