• 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_Release
82  * @tc.desc: test OH_PackingOptions_Release
83  * @tc.type: FUNC
84  */
85 HWTEST_F(ImagePackerNdk2Test, OH_PackingOptions_Release, TestSize.Level3)
86 {
87     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_Release start";
88     OH_PackingOptions *ops = nullptr;
89     Image_ErrorCode ret = OH_PackingOptions_Release(ops);
90     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
91     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_PackingOptions_Release end";
92 }
93 
94 /**
95  * @tc.name: OH_ImagePackerNative_Create
96  * @tc.desc: test OH_ImagePackerNative_Create
97  * @tc.type: FUNC
98  */
99 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_Create, TestSize.Level3)
100 {
101     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Create start";
102     OH_ImagePackerNative *imagePacker = nullptr;
103     Image_ErrorCode ret = OH_ImagePackerNative_Create(&imagePacker);
104     ASSERT_EQ(ret, IMAGE_SUCCESS);
105     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Create end";
106 }
107 
108 /**
109  * @tc.name: OH_ImagePackerNative_PackToDataFromImageSource
110  * @tc.desc: test OH_ImagePackerNative_PackToDataFromImageSource
111  * @tc.type: FUNC
112  */
113 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromImageSource, TestSize.Level3)
114 {
115     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromImageSource start";
116     OH_ImagePackerNative *imagePacker = nullptr;
117     OH_PackingOptions* option = nullptr;
118     OH_ImageSourceNative* imageSource = nullptr;
119     uint8_t* outData = nullptr;
120     size_t *size = nullptr;
121     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromImageSource(imagePacker, option, imageSource,
122         outData, size);
123     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
124     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromImageSource end";
125 }
126 
127 /**
128  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmap
129  * @tc.desc: test OH_ImagePackerNative_PackToDataFromPixelmap
130  * @tc.type: FUNC
131  */
132 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmap, TestSize.Level3)
133 {
134     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmap start";
135     OH_ImagePackerNative *imagePacker = nullptr;
136     OH_PackingOptions* option = nullptr;
137     OH_PixelmapNative* pixelMap = nullptr;
138     uint8_t* outData = nullptr;
139     size_t *size = nullptr;
140     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmap(imagePacker, option, pixelMap, outData, size);
141     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
142     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmap end";
143 }
144 
145 /**
146  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence001
147  * @tc.desc: test imagePacker is nullptr
148  * @tc.type: FUNC
149  */
150 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence001, TestSize.Level3)
151 {
152     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 start";
153     OH_ImagePackerNative *imagePacker = nullptr;
154 
155     OH_PackingOptionsForSequence* option = nullptr;
156     Image_ErrorCode errCode = OH_PackingOptionsForSequence_Create(&option);
157     ASSERT_EQ(errCode, IMAGE_SUCCESS);
158     ASSERT_NE(option, nullptr);
159 
160     size_t dataSize = ARGB_8888_BYTES;
161     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
162     OH_Pixelmap_InitializationOptions *createOpts;
163     OH_PixelmapInitializationOptions_Create(&createOpts);
164     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
165     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
166     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
167     std::vector<OH_PixelmapNative*> pixelMaps;
168     OH_PixelmapNative* pixelMap = nullptr;
169     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
170     pixelMaps.push_back(pixelMap);
171     ASSERT_EQ(errCode, IMAGE_SUCCESS);
172     ASSERT_NE(pixelMaps.data(), nullptr);
173 
174     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
175     ASSERT_NE(outData.get(), nullptr);
176 
177     size_t outDataSize = 0;
178     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
179         pixelMaps.data(), 0, outData.get(), &outDataSize);
180     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
181     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 end";
182 }
183 
184 /**
185  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence002
186  * @tc.desc: test options is nullptr
187  * @tc.type: FUNC
188  */
189 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence002, TestSize.Level3)
190 {
191     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence002 start";
192     OH_ImagePackerNative *imagePacker = nullptr;
193     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
194     EXPECT_EQ(errCode, IMAGE_SUCCESS);
195     ASSERT_NE(imagePacker, nullptr);
196 
197     OH_PackingOptionsForSequence* option = nullptr;
198 
199     size_t dataSize = ARGB_8888_BYTES;
200     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
201     OH_Pixelmap_InitializationOptions *createOpts;
202     OH_PixelmapInitializationOptions_Create(&createOpts);
203     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
204     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
205     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
206     std::vector<OH_PixelmapNative*> pixelMaps;
207     OH_PixelmapNative* pixelMap = nullptr;
208     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
209     pixelMaps.push_back(pixelMap);
210     ASSERT_EQ(errCode, IMAGE_SUCCESS);
211     ASSERT_NE(pixelMaps.data(), nullptr);
212 
213     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
214     ASSERT_NE(outData.get(), nullptr);
215 
216     size_t outDataSize = 0;
217     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
218         pixelMaps.data(), 0, outData.get(), &outDataSize);
219     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
220     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence001 end";
221 }
222 
223 /**
224  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence003
225  * @tc.desc: test pixelmapSequence is nullptr
226  * @tc.type: FUNC
227  */
228 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence003, TestSize.Level3)
229 {
230     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence003 start";
231     OH_ImagePackerNative *imagePacker = nullptr;
232     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
233     EXPECT_EQ(errCode, IMAGE_SUCCESS);
234     ASSERT_NE(imagePacker, nullptr);
235 
236     OH_PackingOptionsForSequence* option = nullptr;
237     errCode = OH_PackingOptionsForSequence_Create(&option);
238     ASSERT_EQ(errCode, IMAGE_SUCCESS);
239     ASSERT_NE(option, nullptr);
240 
241     OH_PixelmapNative **pixelMaps = nullptr;
242 
243     std::unique_ptr<uint8_t[]> outData = std::make_unique<uint8_t[]>(OUT_DATA_LENGTH);
244     ASSERT_NE(outData.get(), nullptr);
245 
246     size_t outDataSize = 0;
247     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
248         pixelMaps, 0, outData.get(), &outDataSize);
249     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
250     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence003 end";
251 }
252 
253 /**
254  * @tc.name: OH_ImagePackerNative_PackToDataFromPixelmapSequence004
255  * @tc.desc: test outData is nullptr
256  * @tc.type: FUNC
257  */
258 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToDataFromPixelmapSequence004, TestSize.Level3)
259 {
260     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence004 start";
261     OH_ImagePackerNative *imagePacker = nullptr;
262     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
263     EXPECT_EQ(errCode, IMAGE_SUCCESS);
264     ASSERT_NE(imagePacker, nullptr);
265 
266     OH_PackingOptionsForSequence* option = nullptr;
267     errCode = OH_PackingOptionsForSequence_Create(&option);
268     ASSERT_EQ(errCode, IMAGE_SUCCESS);
269     ASSERT_NE(option, nullptr);
270 
271     size_t dataSize = ARGB_8888_BYTES;
272     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
273     OH_Pixelmap_InitializationOptions *createOpts;
274     OH_PixelmapInitializationOptions_Create(&createOpts);
275     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
276     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
277     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
278     std::vector<OH_PixelmapNative*> pixelMaps;
279     OH_PixelmapNative* pixelMap = nullptr;
280     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
281     pixelMaps.push_back(pixelMap);
282     ASSERT_EQ(errCode, IMAGE_SUCCESS);
283     ASSERT_NE(pixelMaps.data(), nullptr);
284 
285     uint8_t* outData = nullptr;
286 
287     size_t outDataSize = 0;
288     Image_ErrorCode ret = OH_ImagePackerNative_PackToDataFromPixelmapSequence(imagePacker, option,
289         pixelMaps.data(), 0, outData, &outDataSize);
290     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
291     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToDataFromPixelmapSequence004 end";
292 }
293 
294 /**
295  * @tc.name: OH_ImagePackerNative_PackToFileFromImageSource
296  * @tc.desc: test OH_ImagePackerNative_PackToFileFromImageSource
297  * @tc.type: FUNC
298  */
299 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromImageSource, TestSize.Level3)
300 {
301     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromImageSource start";
302     OH_ImagePackerNative *imagePacker = nullptr;
303     OH_PackingOptions* option = nullptr;
304     OH_ImageSourceNative* imageSource = nullptr;
305     int32_t fd = 0;
306     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromImageSource(imagePacker, option, imageSource, fd);
307     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
308     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromImageSource end";
309 }
310 
311 /**
312  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmap
313  * @tc.desc: test OH_ImagePackerNative_PackToFileFromPixelmap
314  * @tc.type: FUNC
315  */
316 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmap, TestSize.Level3)
317 {
318     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmap start";
319     OH_ImagePackerNative *imagePacker = nullptr;
320     OH_PackingOptions* option = nullptr;
321     OH_PixelmapNative* pixelMap = nullptr;
322     int32_t fd = 0;
323     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromPixelmap(imagePacker, option, pixelMap, fd);
324     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
325     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmap end";
326 }
327 
328 /**
329  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence001
330  * @tc.desc: test imagePacker is nullptr
331  * @tc.type: FUNC
332  */
333 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence001, TestSize.Level3)
334 {
335     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence001 start";
336     OH_ImagePackerNative *imagePacker = nullptr;
337 
338     OH_PackingOptionsForSequence* option = nullptr;
339     Image_ErrorCode errCode = OH_PackingOptionsForSequence_Create(&option);
340     ASSERT_EQ(errCode, IMAGE_SUCCESS);
341     ASSERT_NE(option, nullptr);
342 
343     size_t dataSize = ARGB_8888_BYTES;
344     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
345     OH_Pixelmap_InitializationOptions *createOpts;
346     OH_PixelmapInitializationOptions_Create(&createOpts);
347     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
348     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
349     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
350     std::vector<OH_PixelmapNative*> pixelMaps;
351     OH_PixelmapNative* pixelMap = nullptr;
352     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
353     pixelMaps.push_back(pixelMap);
354     ASSERT_EQ(errCode, IMAGE_SUCCESS);
355     ASSERT_NE(pixelMaps.data(), nullptr);
356 
357     int32_t fd = 0;
358     Image_ErrorCode ret =
359         OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps.data(), 0, fd);
360     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
361     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence001 end";
362 }
363 
364 /**
365  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence002
366  * @tc.desc: test option is nullptr
367  * @tc.type: FUNC
368  */
369 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence002, TestSize.Level3)
370 {
371     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence002 start";
372     OH_ImagePackerNative *imagePacker = nullptr;
373     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
374     EXPECT_EQ(errCode, IMAGE_SUCCESS);
375     ASSERT_NE(imagePacker, nullptr);
376 
377     OH_PackingOptionsForSequence* option = nullptr;
378 
379     size_t dataSize = ARGB_8888_BYTES;
380     uint8_t data[] = {0x01, 0x02, 0x03, 0xFF};
381     OH_Pixelmap_InitializationOptions *createOpts;
382     OH_PixelmapInitializationOptions_Create(&createOpts);
383     OH_PixelmapInitializationOptions_SetWidth(createOpts, 1);
384     OH_PixelmapInitializationOptions_SetHeight(createOpts, 1);
385     OH_PixelmapInitializationOptions_SetPixelFormat(createOpts, PIXEL_FORMAT_BGRA_8888);
386     std::vector<OH_PixelmapNative*> pixelMaps;
387     OH_PixelmapNative* pixelMap = nullptr;
388     errCode = OH_PixelmapNative_CreatePixelmap(data, dataSize, createOpts, &pixelMap);
389     pixelMaps.push_back(pixelMap);
390     ASSERT_EQ(errCode, IMAGE_SUCCESS);
391     ASSERT_NE(pixelMaps.data(), nullptr);
392 
393     int32_t fd = 0;
394     Image_ErrorCode ret =
395         OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps.data(), 0, fd);
396     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
397     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence002 end";
398 }
399 
400 /**
401  * @tc.name: OH_ImagePackerNative_PackToFileFromPixelmapSequence003
402  * @tc.desc: test pixelmapSequence is nullptr
403  * @tc.type: FUNC
404  */
405 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_PackToFileFromPixelmapSequence003, TestSize.Level3)
406 {
407     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence003 start";
408     OH_ImagePackerNative *imagePacker = nullptr;
409     Image_ErrorCode errCode = OH_ImagePackerNative_Create(&imagePacker);
410     EXPECT_EQ(errCode, IMAGE_SUCCESS);
411     ASSERT_NE(imagePacker, nullptr);
412 
413     OH_PackingOptionsForSequence* option = nullptr;
414     errCode = OH_PackingOptionsForSequence_Create(&option);
415     ASSERT_EQ(errCode, IMAGE_SUCCESS);
416     ASSERT_NE(option, nullptr);
417 
418     OH_PixelmapNative **pixelMaps = nullptr;
419 
420     int32_t fd = 0;
421     Image_ErrorCode ret = OH_ImagePackerNative_PackToFileFromPixelmapSequence(imagePacker, option, pixelMaps, 0, fd);
422     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
423     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_PackToFileFromPixelmapSequence003 end";
424 }
425 
426 /**
427  * @tc.name: OH_ImagePackerNative_Release
428  * @tc.desc: test OH_ImagePackerNative_Release
429  * @tc.type: FUNC
430  */
431 HWTEST_F(ImagePackerNdk2Test, OH_ImagePackerNative_Release, TestSize.Level3)
432 {
433     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Release start";
434     OH_ImagePackerNative *imagePacker = nullptr;
435     Image_ErrorCode ret = OH_ImagePackerNative_Release(imagePacker);
436     ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
437     GTEST_LOG_(INFO) << "ImagePackerNdk2Test: OH_ImagePackerNative_Release end";
438 }
439 }
440 }