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 "common_utils.h"
18 
19 #include "image_mdk.h"
20 #include "image_mdk_kits.h"
21 #include "image_receiver_mdk.h"
22 #include "image_receiver_mdk_kits.h"
23 #include "image_source_mdk.h"
24 #include "image_source_mdk_kits.h"
25 #include "image_pixel_map_napi.h"
26 #include "raw_file.h"
27 
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace Media {
31 static constexpr int32_t UNSUCCESS = -1;
32 class ImageNdkTest : public testing::Test {
33 public:
ImageNdkTest()34     ImageNdkTest() {}
~ImageNdkTest()35     ~ImageNdkTest() {}
36 };
37 
38 /**
39  * @tc.name: OH_Image_ClipRectTest
40  * @tc.desc: OH_Image_ClipRect
41  * @tc.type: FUNC
42  */
43 HWTEST_F(ImageNdkTest, OH_Image_ClipRectTest, TestSize.Level3)
44 {
45     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ClipRectTest start";
46     const ImageNative* native = nullptr;
47     struct OhosImageRect* rect = nullptr;
48     int32_t result = OH_Image_ClipRect(native, rect);
49     ASSERT_EQ(result, UNSUCCESS);
50 
51     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ClipRectTest end";
52 }
53 
54 /**
55  * @tc.name: OH_Image_SizeTest
56  * @tc.desc: OH_Image_Size
57  * @tc.type: FUNC
58  */
59 HWTEST_F(ImageNdkTest, OH_Image_SizeTest, TestSize.Level3)
60 {
61     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_SizeTest start";
62     const ImageNative* native = nullptr;
63     struct OhosImageSize* size = nullptr;
64     int32_t result = OH_Image_Size(native, size);
65     ASSERT_EQ(result, UNSUCCESS);
66 
67     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_SizeTest end";
68 }
69 
70 /**
71  * @tc.name: OH_Image_FormatTest
72  * @tc.desc: OH_Image_Format
73  * @tc.type: FUNC
74  */
75 HWTEST_F(ImageNdkTest, OH_Image_FormatTest, TestSize.Level3)
76 {
77     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_FormatTest start";
78     const ImageNative* native = nullptr;
79     int32_t* format = nullptr;
80     int32_t result = OH_Image_Format(native, format);
81     ASSERT_EQ(result, UNSUCCESS);
82 
83     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_FormatTest end";
84 }
85 
86 /**
87  * @tc.name: OH_Image_GetComponentTest
88  * @tc.desc: OH_Image_GetComponent
89  * @tc.type: FUNC
90  */
91 HWTEST_F(ImageNdkTest, OH_Image_GetComponentTest, TestSize.Level3)
92 {
93     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_GetComponentTest start";
94     const ImageNative* native = nullptr;
95     int32_t componentType = 0;
96     struct OhosImageComponent* componentNative = nullptr;
97     int32_t result = OH_Image_GetComponent(native, componentType, componentNative);
98     ASSERT_EQ(result, UNSUCCESS);
99 
100     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_GetComponentTest end";
101 }
102 
103 /**
104  * @tc.name: OH_Image_ReleaseTest
105  * @tc.desc: OH_Image_Release
106  * @tc.type: FUNC
107  */
108 HWTEST_F(ImageNdkTest, OH_Image_ReleaseTest, TestSize.Level3)
109 {
110     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ReleaseTest start";
111     ImageNative* native = nullptr;
112     int32_t result = OH_Image_Release(native);
113     ASSERT_EQ(result, 0);
114 
115     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ReleaseTest end";
116 }
117 
118 /**
119  * @tc.name: OH_Image_Receiver_InitImageReceiverNativeTest
120  * @tc.desc: OH_Image_Receiver_InitImageReceiverNative
121  * @tc.type: FUNC
122  */
123 HWTEST_F(ImageNdkTest, OH_Image_Receiver_InitImageReceiverNativeTest, TestSize.Level3)
124 {
125     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_InitImageReceiverNativeTest start";
126     napi_env env = nullptr;
127     napi_value source = nullptr;
128     ImageReceiverNative* res = OH_Image_Receiver_InitImageReceiverNative(env, source);
129     ASSERT_EQ(res, nullptr);
130 
131     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_InitImageReceiverNativeTest end";
132 }
133 
134 /**
135  * @tc.name: OH_Image_Receiver_GetReceivingSurfaceIdTest
136  * @tc.desc: OH_Image_Receiver_GetReceivingSurfaceId
137  * @tc.type: FUNC
138  */
139 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetReceivingSurfaceIdTest, TestSize.Level3)
140 {
141     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetReceivingSurfaceIdTest start";
142     const ImageReceiverNative *p = nullptr;
143     char* id = nullptr;
144     size_t len = 100;
145     int32_t res = OH_Image_Receiver_GetReceivingSurfaceId(p, id, len);
146     ASSERT_EQ(res, UNSUCCESS);
147 
148     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetReceivingSurfaceIdTest end";
149 }
150 
151 /**
152  * @tc.name: OH_Image_Receiver_ReadLatestImageTest
153  * @tc.desc: OH_Image_Receiver_ReadLatestImage
154  * @tc.type: FUNC
155  */
156 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReadLatestImageTest, TestSize.Level3)
157 {
158     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadLatestImageTest start";
159     const ImageReceiverNative *p = nullptr;
160     napi_value* image = nullptr;
161     int32_t res = OH_Image_Receiver_ReadLatestImage(p, image);
162     ASSERT_EQ(res, UNSUCCESS);
163 
164     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadLatestImageTest end";
165 }
166 
167 /**
168  * @tc.name: OH_Image_Receiver_ReadNextImageTest
169  * @tc.desc: OH_Image_Receiver_ReadNextImage
170  * @tc.type: FUNC
171  */
172 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReadNextImageTest, TestSize.Level3)
173 {
174     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadNextImageTest start";
175     const ImageReceiverNative *p = nullptr;
176     napi_value* image = nullptr;
177     int32_t res = OH_Image_Receiver_ReadNextImage(p, image);
178     ASSERT_EQ(res, UNSUCCESS);
179 
180     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadNextImageTest end";
181 }
182 
183 /**
184  * @tc.name: OH_Image_Receiver_OnTest
185  * @tc.desc: OH_Image_Receiver_On
186  * @tc.type: FUNC
187  */
188 HWTEST_F(ImageNdkTest, OH_Image_Receiver_OnTest, TestSize.Level3)
189 {
190     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_OnTest start";
191     const ImageReceiverNative *p = nullptr;
192     OH_Image_Receiver_On_Callback callback = nullptr;
193     int32_t res = OH_Image_Receiver_On(p, callback);
194     ASSERT_EQ(res, UNSUCCESS);
195 
196     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_OnTest end";
197 }
198 
199 /**
200  * @tc.name: OH_Image_Receiver_GetSizeTest
201  * @tc.desc: OH_Image_Receiver_GetSize
202  * @tc.type: FUNC
203  */
204 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetSizeTest, TestSize.Level3)
205 {
206     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetSizeTest start";
207     const ImageReceiverNative *p = nullptr;
208     struct OhosImageSize* size = nullptr;
209     int32_t res = OH_Image_Receiver_GetSize(p, size);
210     ASSERT_EQ(res, UNSUCCESS);
211 
212     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetSizeTest end";
213 }
214 
215 /**
216  * @tc.name: OH_Image_Receiver_GetCapacityTest
217  * @tc.desc: OH_Image_Receiver_GetCapacity
218  * @tc.type: FUNC
219  */
220 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetCapacityTest, TestSize.Level3)
221 {
222     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetCapacityTest start";
223     const ImageReceiverNative *p = nullptr;
224     int32_t* capacity = nullptr;
225     int32_t res = OH_Image_Receiver_GetCapacity(p, capacity);
226     ASSERT_EQ(res, UNSUCCESS);
227 
228     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetCapacityTest end";
229 }
230 
231 /**
232  * @tc.name: OH_Image_Receiver_GetFormatTest
233  * @tc.desc: OH_Image_Receiver_GetFormat
234  * @tc.type: FUNC
235  */
236 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetFormatTest, TestSize.Level3)
237 {
238     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetFormatTest start";
239     const ImageReceiverNative *p = nullptr;
240     int32_t* format = nullptr;
241     int32_t res = OH_Image_Receiver_GetFormat(p, format);
242     ASSERT_EQ(res, UNSUCCESS);
243 
244     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetFormatTest end";
245 }
246 
247 /**
248  * @tc.name: OH_Image_Receiver_ReleaseTest
249  * @tc.desc: OH_Image_Receiver_Release
250  * @tc.type: FUNC
251  */
252 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReleaseTest, TestSize.Level3)
253 {
254     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReleaseTest start";
255     ImageReceiverNative *p = nullptr;
256     int32_t res = OH_Image_Receiver_Release(p);
257     ASSERT_EQ(res, IMAGE_RESULT_SUCCESS);
258 
259     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReleaseTest end";
260 }
261 
262 /**
263  * @tc.name: OH_Image_InitImageNativeTest
264  * @tc.desc: OH_Image_InitImageNative
265  * @tc.type: FUNC
266  */
267 HWTEST_F(ImageNdkTest, OH_Image_InitImageNativeTest, TestSize.Level3)
268 {
269     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_InitImageNativeTest start";
270     napi_env env = nullptr;
271     napi_value source = nullptr;
272     ImageNative* res = OH_Image_InitImageNative(env, source);
273     ASSERT_EQ(res, nullptr);
274 
275     GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_InitImageNativeTest end";
276 }
277 /**
278  * @tc.name: OH_ImageSource_CreateTest
279  * @tc.desc: OH_ImageSource_Create
280  * @tc.type: FUNC
281  */
282 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateTest, TestSize.Level3)
283 {
284     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateTest start";
285     napi_env env = nullptr;
286     napi_value* res = nullptr;
287     OhosImageSource* src = nullptr;
288     OhosImageSourceOps* ops= nullptr;
289     int32_t ret = OH_ImageSource_Create(env, src, ops, res);
290     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
291 
292     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateTest end";
293 }
294 
295 /**
296  * @tc.name: OH_ImageSource_CreateFromUriTest
297  * @tc.desc: OH_ImageSource_CreateFromUri
298  * @tc.type: FUNC
299  */
300 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateFromUriTest, TestSize.Level3)
301 {
302     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromUriTest start";
303     napi_env env = nullptr;
304     napi_value* res = nullptr;
305     char* uri = nullptr;
306     size_t size = 0;
307     OhosImageSourceOps* ops= nullptr;
308     int32_t ret = OH_ImageSource_CreateFromUri(env, uri, size, ops, res);
309     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
310 
311     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromUriTest end";
312 }
313 
314 /**
315  * @tc.name: OH_ImageSource_CreateFromFdTest
316  * @tc.desc: OH_ImageSource_CreateFromFd
317  * @tc.type: FUNC
318  */
319 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateFromFdTest, TestSize.Level3)
320 {
321     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromFdTest start";
322     napi_env env = nullptr;
323     napi_value* res = nullptr;
324     int32_t fd = -1;
325     OhosImageSourceOps* ops= nullptr;
326     int32_t ret = OH_ImageSource_CreateFromFd(env, fd, ops, res);
327     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
328 
329     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromFdTest end";
330 }
331 
332 /**
333  * @tc.name: OH_ImageSource_CreateFromDataTest
334  * @tc.desc: OH_ImageSource_CreateFromData
335  * @tc.type: FUNC
336  */
337 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateFromDataTest, TestSize.Level3)
338 {
339     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromDataTest start";
340     napi_env env = nullptr;
341     napi_value* res = nullptr;
342     uint8_t* data = nullptr;
343     size_t dataSize = 0;
344     OhosImageSourceOps* ops= nullptr;
345     int32_t ret = OH_ImageSource_CreateFromData(env, data, dataSize, ops, res);
346     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
347 
348     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromDataTest end";
349 }
350 
351 /**
352  * @tc.name: OH_ImageSource_CreateFromRawFileTest
353  * @tc.desc: OH_ImageSource_CreateFromRawFile
354  * @tc.type: FUNC
355  */
356 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateFromRawFileTest, TestSize.Level3)
357 {
358     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromRawFileTest start";
359     napi_env env = nullptr;
360     napi_value* res = nullptr;
361     RawFileDescriptor rawFile;
362     rawFile.fd = -1;
363     rawFile.start = 0;
364     rawFile.length = 0;
365     OhosImageSourceOps* ops= nullptr;
366     int32_t ret = OH_ImageSource_CreateFromRawFile(env, rawFile, ops, res);
367     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
368 
369     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateFromRawFileTest end";
370 }
371 
372 /**
373  * @tc.name: OH_ImageSource_CreateIncrementalTest
374  * @tc.desc: OH_ImageSource_CreateIncremental
375  * @tc.type: FUNC
376  */
377 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateIncrementalTest, TestSize.Level3)
378 {
379     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalTest start";
380     napi_env env = nullptr;
381     napi_value* res = nullptr;
382     OhosImageSource* src = nullptr;
383     OhosImageSourceOps* ops= nullptr;
384     int32_t ret = OH_ImageSource_CreateIncremental(env, src, ops, res);
385     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
386 
387     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalTest end";
388 }
389 
390 /**
391  * @tc.name: OH_ImageSource_CreateIncrementalFromDataTest
392  * @tc.desc: OH_ImageSource_CreateIncrementalFromData
393  * @tc.type: FUNC
394  */
395 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateIncrementalFromDataTest, TestSize.Level3)
396 {
397     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalFromDataTest start";
398     napi_env env = nullptr;
399     napi_value* res = nullptr;
400     uint8_t* data = nullptr;
401     size_t dataSize = 0;
402     OhosImageSourceOps* ops= nullptr;
403     int32_t ret = OH_ImageSource_CreateIncrementalFromData(env, data, dataSize, ops, res);
404     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
405 
406     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalFromDataTest end";
407 }
408 
409 /**
410  * @tc.name: OH_ImageSource_GetSupportedFormatsTest
411  * @tc.desc: OH_ImageSource_GetSupportedFormats
412  * @tc.type: FUNC
413  */
414 HWTEST_F(ImageNdkTest, OH_ImageSource_GetSupportedFormatsTest, TestSize.Level3)
415 {
416     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetSupportedFormatsTest start";
417     OhosImageSourceSupportedFormatList* res = nullptr;
418     int32_t ret = OH_ImageSource_GetSupportedFormats(res);
419     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
420 
421     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetSupportedFormatsTest end";
422 }
423 
424 /**
425  * @tc.name: OH_ImageSource_CreatePixelMapTest
426  * @tc.desc: OH_ImageSource_CreatePixelMap
427  * @tc.type: FUNC
428  */
429 HWTEST_F(ImageNdkTest, OH_ImageSource_CreatePixelMapTest, TestSize.Level3)
430 {
431     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapTest start";
432     ImageSourceNative* native = nullptr;
433     OhosImageDecodingOps* ops = nullptr;
434     napi_value *res = nullptr;
435     int32_t ret = OH_ImageSource_CreatePixelMap(native, ops, res);
436     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
437 
438     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapTest end";
439 }
440 
441 /**
442  * @tc.name: OH_ImageSource_CreatePixelMapListTest
443  * @tc.desc: OH_ImageSource_CreatePixelMapList
444  * @tc.type: FUNC
445  */
446 HWTEST_F(ImageNdkTest, OH_ImageSource_CreatePixelMapListTest, TestSize.Level3)
447 {
448     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapListTest start";
449     ImageSourceNative* native = nullptr;
450     OhosImageDecodingOps* ops = nullptr;
451     napi_value *res = nullptr;
452     int32_t ret = OH_ImageSource_CreatePixelMapList(native, ops, res);
453     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
454 
455     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapListTest end";
456 }
457 
458 /**
459  * @tc.name: OH_ImageSource_GetDelayTimeTest
460  * @tc.desc: OH_ImageSource_GetDelayTime
461  * @tc.type: FUNC
462  */
463 HWTEST_F(ImageNdkTest, OH_ImageSource_GetDelayTimeTest, TestSize.Level3)
464 {
465     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetDelayTimeTest start";
466     ImageSourceNative* native = nullptr;
467     OhosImageSourceDelayTimeList* res = nullptr;
468     int32_t ret = OH_ImageSource_GetDelayTime(native, res);
469     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
470 
471     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetDelayTimeTest end";
472 }
473 
474 /**
475  * @tc.name: OH_ImageSource_GetFrameCountTest
476  * @tc.desc: OH_ImageSource_GetFrameCount
477  * @tc.type: FUNC
478  */
479 HWTEST_F(ImageNdkTest, OH_ImageSource_GetFrameCountTest, TestSize.Level3)
480 {
481     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetFrameCountTest start";
482     ImageSourceNative* native = nullptr;
483     uint32_t *res = nullptr;
484     int32_t ret = OH_ImageSource_GetFrameCount(native, res);
485     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
486 
487     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetFrameCountTest end";
488 }
489 
490 /**
491  * @tc.name: OH_ImageSource_GetImageInfoTest
492  * @tc.desc: OH_ImageSource_GetImageInfo
493  * @tc.type: FUNC
494  */
495 HWTEST_F(ImageNdkTest, OH_ImageSource_GetImageInfoTest, TestSize.Level3)
496 {
497     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImageInfoTest start";
498     ImageSourceNative* native = nullptr;
499     int32_t index = 0;
500     OhosImageSourceInfo* info = nullptr;
501     int32_t ret = OH_ImageSource_GetImageInfo(native, index, info);
502     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
503 
504     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImageInfoTest end";
505 }
506 
507 /**
508  * @tc.name: OH_ImageSource_GetImagePropertyTest
509  * @tc.desc: OH_ImageSource_GetImageProperty
510  * @tc.type: FUNC
511  */
512 HWTEST_F(ImageNdkTest, OH_ImageSource_GetImagePropertyTest, TestSize.Level3)
513 {
514     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImagePropertyTest start";
515     ImageSourceNative* native = nullptr;
516     OhosImageSourceProperty* key = nullptr;
517     OhosImageSourceProperty* value = nullptr;
518     int32_t ret = OH_ImageSource_GetImageProperty(native, key, value);
519     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
520 
521     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImagePropertyTest end";
522 }
523 
524 /**
525  * @tc.name: OH_ImageSource_ModifyImagePropertyTest
526  * @tc.desc: OH_ImageSource_ModifyImageProperty
527  * @tc.type: FUNC
528  */
529 HWTEST_F(ImageNdkTest, OH_ImageSource_ModifyImagePropertyTest, TestSize.Level3)
530 {
531     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ModifyImagePropertyTest start";
532     ImageSourceNative* native = nullptr;
533     OhosImageSourceProperty* key = nullptr;
534     OhosImageSourceProperty* value = nullptr;
535     int32_t ret = OH_ImageSource_ModifyImageProperty(native, key, value);
536     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
537 
538     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ModifyImagePropertyTest end";
539 }
540 
541 /**
542  * @tc.name: OH_ImageSource_UpdateDataTest
543  * @tc.desc: OH_ImageSource_UpdateData
544  * @tc.type: FUNC
545  */
546 HWTEST_F(ImageNdkTest, OH_ImageSource_UpdateDataTest, TestSize.Level3)
547 {
548     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_UpdateDataTest start";
549     ImageSourceNative* native = nullptr;
550     OhosImageSourceUpdateData* data = nullptr;
551     int32_t ret = OH_ImageSource_UpdateData(native, data);
552     ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS);
553 
554     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_UpdateDataTest end";
555 }
556 
557 /**
558  * @tc.name: OH_ImageSource_ReleaseTest
559  * @tc.desc: OH_ImageSource_Release
560  * @tc.type: FUNC
561  */
562 HWTEST_F(ImageNdkTest, OH_ImageSource_ReleaseTest, TestSize.Level3)
563 {
564     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ReleaseTest start";
565     ImageSourceNative* native = nullptr;
566     int32_t ret = OH_ImageSource_Release(native);
567     ASSERT_EQ(ret, OHOS_IMAGE_RESULT_SUCCESS);
568 
569     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ReleaseTest end";
570 }
571 
572 /**
573  * @tc.name: OH_ImageSource_InitNativeTest
574  * @tc.desc: OH_ImageSource_InitNative
575  * @tc.type: FUNC
576  */
577 HWTEST_F(ImageNdkTest, OH_ImageSource_InitNativeTest, TestSize.Level3)
578 {
579     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_InitNativeTest start";
580     napi_env env = nullptr;
581     napi_value source = nullptr;
582     ImageSourceNative*  ret = OH_ImageSource_InitNative(env, source);
583     ASSERT_EQ(ret, nullptr);
584 
585     GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_InitNativeTest end";
586 }
587 }
588 }
589