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 "image_pixel_map_mdk.h"
18 #include "image_pixel_map_napi.h"
19 #include "common_utils.h"
20 #include "image_pixel_map_napi_kits.h"
21 
22 using namespace testing::ext;
23 using namespace OHOS::Media;
24 namespace OHOS {
25 namespace Media {
26 class NdkTest : public testing::Test {
27 public:
NdkTest()28     NdkTest() {}
~NdkTest()29     ~NdkTest() {}
30 };
31 
32 /**
33  * @tc.name: NdkTest001
34  * @tc.desc: OH_PixelMap_GetBytesNumberPerRow
35  * @tc.type: FUNC
36  */
37 HWTEST_F(NdkTest, NdkTest001, TestSize.Level3)
38 {
39     GTEST_LOG_(INFO) << "NdkTest: NdkTest001 start";
40     const NativePixelMap *p = nullptr;
41     int* num = nullptr;
42     int32_t res = OH_PixelMap_GetBytesNumberPerRow(p, num);
43     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
44 
45     GTEST_LOG_(INFO) << "NdkTest: NdkTest001 end";
46 }
47 
48 /**
49  * @tc.name: NdkTest002
50  * @tc.desc: OH_PixelMap_GetIsEditable
51  * @tc.type: FUNC
52  */
53 HWTEST_F(NdkTest, NdkTest002, TestSize.Level3)
54 {
55     GTEST_LOG_(INFO) << "NdkTest: NdkTest002 start";
56     const NativePixelMap *p = nullptr;
57     int* num = nullptr;
58     int32_t res = OH_PixelMap_GetIsEditable(p, num);
59     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
60 
61     GTEST_LOG_(INFO) << "NdkTest: NdkTest002 end";
62 }
63 
64 /**
65  * @tc.name: NdkTest003
66  * @tc.desc: OH_PixelMap_IsSupportAlpha
67  * @tc.type: FUNC
68  */
69 HWTEST_F(NdkTest, NdkTest003, TestSize.Level3)
70 {
71     GTEST_LOG_(INFO) << "NdkTest: NdkTest003 start";
72     const NativePixelMap *p = nullptr;
73     int* num = nullptr;
74     int32_t res = OH_PixelMap_IsSupportAlpha(p, num);
75     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
76 
77     GTEST_LOG_(INFO) << "NdkTest: NdkTest003 end";
78 }
79 
80 /**
81  * @tc.name: NdkTest004
82  * @tc.desc: OH_PixelMap_SetAlphaAble
83  * @tc.type: FUNC
84  */
85 HWTEST_F(NdkTest, NdkTest004, TestSize.Level3)
86 {
87     GTEST_LOG_(INFO) << "NdkTest: NdkTest004 start";
88     const NativePixelMap *p = nullptr;
89     int num = 0;
90     int32_t res = OH_PixelMap_SetAlphaAble(p, num);
91     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
92 
93     GTEST_LOG_(INFO) << "NdkTest: NdkTest004 end";
94 }
95 
96 /**
97  * @tc.name: NdkTest005
98  * @tc.desc: GetFilterRowType
99  * @tc.type: FUNC
100  */
101 HWTEST_F(NdkTest, NdkTest005, TestSize.Level3)
102 {
103     GTEST_LOG_(INFO) << "NdkTest: NdkTest005 start";
104     const NativePixelMap *p = nullptr;
105     int* num = nullptr;
106     int32_t res = OH_PixelMap_GetDensity(p, num);
107     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
108 
109     GTEST_LOG_(INFO) << "NdkTest: NdkTest005 end";
110 }
111 
112 /**
113  * @tc.name: NdkTest006
114  * @tc.desc: OH_PixelMap_SetDensity
115  * @tc.type: FUNC
116  */
117 HWTEST_F(NdkTest, NdkTest006, TestSize.Level3)
118 {
119     GTEST_LOG_(INFO) << "NdkTest: NdkTest006 start";
120     const NativePixelMap *p = nullptr;
121     int num = 0;
122     int32_t res = OH_PixelMap_SetDensity(p, num);
123     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
124 
125     GTEST_LOG_(INFO) << "NdkTest: NdkTest006 end";
126 }
127 
128 /**
129  * @tc.name: NdkTest007
130  * @tc.desc: OH_PixelMap_SetOpacity
131  * @tc.type: FUNC
132  */
133 HWTEST_F(NdkTest, NdkTest007, TestSize.Level3)
134 {
135     GTEST_LOG_(INFO) << "NdkTest: NdkTest007 start";
136     const NativePixelMap *p = nullptr;
137     float num = 0.5;
138     int32_t res = OH_PixelMap_SetOpacity(p, num);
139     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
140 
141     GTEST_LOG_(INFO) << "NdkTest: NdkTest007 end";
142 }
143 
144 /**
145  * @tc.name: NdkTest008
146  * @tc.desc: OH_PixelMap_Scale
147  * @tc.type: FUNC
148  */
149 HWTEST_F(NdkTest, NdkTest008, TestSize.Level3)
150 {
151     GTEST_LOG_(INFO) << "NdkTest: NdkTest008 start";
152     const NativePixelMap *p = nullptr;
153     float x = 0.5;
154     float y = 0.5;
155     int32_t res = OH_PixelMap_Scale(p, x, y);
156     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
157 
158     GTEST_LOG_(INFO) << "NdkTest: NdkTest008 end";
159 }
160 
161 /**
162  * @tc.name: OH_PixelMap_ScaleWithAntiAliasingTest
163  * @tc.desc: OH_PixelMap_ScaleWithAntiAliasing
164  * @tc.type: FUNC
165  */
166 HWTEST_F(NdkTest, OH_PixelMap_ScaleWithAntiAliasingTest, TestSize.Level3)
167 {
168     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_ScaleWithAntiAliasingTest start";
169     const NativePixelMap *p = nullptr;
170     float x = 0.5;
171     float y = 0.5;
172     int32_t res =
173         OH_PixelMap_ScaleWithAntiAliasing(p, x, y, OH_PixelMap_AntiAliasingLevel::OH_PixelMap_AntiAliasing_NONE);
174     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
175 
176     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_ScaleWithAntiAliasingTest end";
177 }
178 
179 /**
180  * @tc.name: NdkTest009
181  * @tc.desc: OH_PixelMap_Translate
182  * @tc.type: FUNC
183  */
184 HWTEST_F(NdkTest, NdkTest009, TestSize.Level3)
185 {
186     GTEST_LOG_(INFO) << "NdkTest: NdkTest009 start";
187     const NativePixelMap *p = nullptr;
188     float x = 0.5;
189     float y = 0.5;
190     int32_t res = OH_PixelMap_Translate(p, x, y);
191     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
192 
193     GTEST_LOG_(INFO) << "NdkTest: NdkTest009 end";
194 }
195 
196 /**
197  * @tc.name: NdkTest0010
198  * @tc.desc: OH_PixelMap_Rotate
199  * @tc.type: FUNC
200  */
201 HWTEST_F(NdkTest, NdkTest0010, TestSize.Level3)
202 {
203     GTEST_LOG_(INFO) << "NdkTest: NdkTest0010 start";
204     const NativePixelMap *p = nullptr;
205     float x = 0.5;
206     int32_t res = OH_PixelMap_Rotate(p, x);
207     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
208 
209     GTEST_LOG_(INFO) << "NdkTest: NdkTest0010 end";
210 }
211 
212 /**
213  * @tc.name: NdkTest0011
214  * @tc.desc: OH_PixelMap_Flip
215  * @tc.type: FUNC
216  */
217 HWTEST_F(NdkTest, NdkTest0011, TestSize.Level3)
218 {
219     GTEST_LOG_(INFO) << "NdkTest: NdkTest0011 start";
220     const NativePixelMap *p = nullptr;
221     int32_t x = 0;
222     int32_t y = 0;
223     int32_t res = OH_PixelMap_Flip(p, x, y);
224     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
225 
226     GTEST_LOG_(INFO) << "NdkTest: NdkTest0011 end";
227 }
228 
229 /**
230  * @tc.name: NdkTest0012
231  * @tc.desc: OH_PixelMap_Crop
232  * @tc.type: FUNC
233  */
234 HWTEST_F(NdkTest, NdkTest0012, TestSize.Level3)
235 {
236     GTEST_LOG_(INFO) << "NdkTest: NdkTest0012 start";
237     const NativePixelMap *p = nullptr;
238     int32_t x = 0;
239     int32_t y = 0;
240     int32_t width = 0;
241     int32_t height = 0;
242     int32_t res = OH_PixelMap_Crop(p, x, y, width, height);
243     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
244 
245     GTEST_LOG_(INFO) << "NdkTest: NdkTest0012 end";
246 }
247 
248 /**
249  * @tc.name: NdkTest0013
250  * @tc.desc: OH_PixelMap_Crop
251  * @tc.type: FUNC
252  */
253 HWTEST_F(NdkTest, NdkTest0013, TestSize.Level3)
254 {
255     GTEST_LOG_(INFO) << "NdkTest: NdkTest0013 start";
256     const NativePixelMap *p = nullptr;
257     OhosPixelMapInfos *info = nullptr;
258     int32_t res = OH_PixelMap_GetImageInfo(p, info);
259     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
260 
261     GTEST_LOG_(INFO) << "NdkTest: NdkTest0013 end";
262 }
263 
264 /**
265  * @tc.name: NdkTest0014
266  * @tc.desc: OH_PixelMap_AccessPixels
267  * @tc.type: FUNC
268  */
269 HWTEST_F(NdkTest, NdkTest0014, TestSize.Level3)
270 {
271     GTEST_LOG_(INFO) << "NdkTest: NdkTest0014 start";
272     const NativePixelMap *p = nullptr;
273     void **info = nullptr;
274     int32_t res = OH_PixelMap_AccessPixels(p, info);
275     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
276 
277     GTEST_LOG_(INFO) << "NdkTest: NdkTest0014 end";
278 }
279 
280 /**
281  * @tc.name: NdkTest0015
282  * @tc.desc: OH_PixelMap_UnAccessPixels
283  * @tc.type: FUNC
284  */
285 HWTEST_F(NdkTest, NdkTest0015, TestSize.Level3)
286 {
287     GTEST_LOG_(INFO) << "NdkTest: NdkTest0015 start";
288     const NativePixelMap *p = nullptr;
289     int32_t res = OH_PixelMap_UnAccessPixels(p);
290     ASSERT_EQ(res, IMAGE_RESULT_BAD_PARAMETER);
291 
292     GTEST_LOG_(INFO) << "NdkTest: NdkTest0015 end";
293 }
294 
295 /**
296  * @tc.name: OH_PixelMap_InitNativePixelMapTest
297  * @tc.desc: OH_PixelMap_InitNativePixelMap
298  * @tc.type: FUNC
299  */
300 HWTEST_F(NdkTest, OH_PixelMap_InitNativePixelMapTest, TestSize.Level3)
301 {
302     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_InitNativePixelMapTest start";
303     napi_env env = nullptr;
304     napi_value source = nullptr;
305     NativePixelMap* res = OH_PixelMap_InitNativePixelMap(env, source);
306     ASSERT_EQ(res, nullptr);
307 
308     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_InitNativePixelMapTest end";
309 }
310 
311 /**
312  * @tc.name: OH_PixelMap_CreatePixelMapTest
313  * @tc.desc: OH_PixelMap_CreatePixelMap
314  * @tc.type: FUNC
315  */
316 HWTEST_F(NdkTest, OH_PixelMap_CreatePixelMapTest, TestSize.Level3)
317 {
318     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreatePixelMapTest start";
319     napi_env env = nullptr;
320     OhosPixelMapCreateOps info;
321     void* buf = nullptr;
322     size_t len = 0;
323     napi_value* res = nullptr;
324     int32_t ret = OH_PixelMap_CreatePixelMap(env, info, buf, len, res);
325     ASSERT_EQ(ret, IMAGE_RESULT_INVALID_PARAMETER);
326 
327     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreatePixelMapTest end";
328 }
329 
330 /**
331  * @tc.name: OH_PixelMap_CreatePixelMapWithStrideTest
332  * @tc.desc: OH_PixelMap_CreatePixelMapWithStride
333  * @tc.type: FUNC
334  */
335 HWTEST_F(NdkTest, OH_PixelMap_CreatePixelMapWithStrideTest, TestSize.Level3)
336 {
337     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreatePixelMapWithStrideTest start";
338     napi_env env = nullptr;
339     OhosPixelMapCreateOps info;
340     void* buf = nullptr;
341     size_t len = 0;
342     int32_t rowStride = 0;
343     napi_value* res = nullptr;
344     int32_t ret = OH_PixelMap_CreatePixelMapWithStride(env, info, buf, len, rowStride, res);
345     ASSERT_EQ(ret, IMAGE_RESULT_INVALID_PARAMETER);
346 
347     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreatePixelMapWithStrideTest end";
348 }
349 
350 /**
351  * @tc.name: OH_PixelMap_CreateAlphaPixelMapTest
352  * @tc.desc: OH_PixelMap_CreateAlphaPixelMap
353  * @tc.type: FUNC
354  */
355 HWTEST_F(NdkTest, OH_PixelMap_CreateAlphaPixelMapTest, TestSize.Level3)
356 {
357     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreateAlphaPixelMapTest start";
358     napi_env env = nullptr;
359     napi_value source = nullptr;
360     napi_value* alpha = nullptr;
361     int32_t res = OH_PixelMap_CreateAlphaPixelMap(env, source, alpha);
362     ASSERT_EQ(res, IMAGE_RESULT_INVALID_PARAMETER);
363 
364     GTEST_LOG_(INFO) << "NdkTest: OH_PixelMap_CreateAlphaPixelMapTest end";
365 }
366 
367 /**
368  * @tc.name: OH_AccessPixelsTest
369  * @tc.desc: OH_AccessPixels
370  * @tc.type: FUNC
371  */
372 HWTEST_F(NdkTest, OH_AccessPixelsTest, TestSize.Level3)
373 {
374     GTEST_LOG_(INFO) << "NdkTest: OH_AccessPixelsTest start";
375     napi_env env = nullptr;
376     napi_value value = nullptr;
377     void** addr = nullptr;
378     int32_t res = OH_AccessPixels(env, value, addr);
379     ASSERT_EQ(res, OHOS_IMAGE_RESULT_BAD_PARAMETER);
380 
381     GTEST_LOG_(INFO) << "NdkTest: OH_AccessPixelsTest end";
382 }
383 
384 /**
385  * @tc.name: OH_UnAccessPixelsTest
386  * @tc.desc: OH_UnAccessPixels
387  * @tc.type: FUNC
388  */
389 HWTEST_F(NdkTest, OH_UnAccessPixelsTest, TestSize.Level3)
390 {
391     GTEST_LOG_(INFO) << "NdkTest: OH_UnAccessPixelsTest start";
392     napi_env env = nullptr;
393     napi_value value = nullptr;
394     int32_t res = OH_UnAccessPixels(env, value);
395     ASSERT_EQ(res, OHOS_IMAGE_RESULT_BAD_PARAMETER);
396 
397     GTEST_LOG_(INFO) << "NdkTest: OH_UnAccessPixelsTest end";
398 }
399 
400 /**
401  * @tc.name: OH_GetImageInfoTest
402  * @tc.desc: OH_GetImageInfo
403  * @tc.type: FUNC
404  */
405 HWTEST_F(NdkTest, OH_GetImageInfoTest, TestSize.Level3)
406 {
407     GTEST_LOG_(INFO) << "NdkTest: OH_GetImageInfoTest start";
408     napi_env env = nullptr;
409     napi_value value = nullptr;;
410     OhosPixelMapInfo *info = nullptr;
411     int32_t res = OH_GetImageInfo(env, value, info);
412     ASSERT_EQ(res, OHOS_IMAGE_RESULT_BAD_PARAMETER);
413 
414     GTEST_LOG_(INFO) << "NdkTest: OH_GetImageInfoTest end";
415 }
416 }
417 }
418