1 /*
2 * Copyright (C) 2024 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 #include "image_native.h"
19 #include "image_receiver_native.h"
20 #include "image_kits.h"
21 #include "image_receiver.h"
22
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace Media {
26
27 static constexpr int32_t IMAGE_TEST_WIDTH = 8192;
28 static constexpr int32_t IMAGE_TEST_HEIGHT = 8;
29 static constexpr int32_t IMAGE_TEST_CAPACITY = 8;
30
31 class ImageReceiverNativeTest : public testing::Test {
32 public:
ImageReceiverNativeTest()33 ImageReceiverNativeTest() {}
~ImageReceiverNativeTest()34 ~ImageReceiverNativeTest() {}
35 static OH_ImageReceiverNative* CreateReceiver();
36 };
37
CreateReceiver()38 OH_ImageReceiverNative* ImageReceiverNativeTest::CreateReceiver()
39 {
40 OH_ImageReceiverOptions* options = nullptr;
41 Image_ErrorCode nRst = IMAGE_SUCCESS;
42 nRst = OH_ImageReceiverOptions_Create(&options);
43 if (nRst != IMAGE_SUCCESS || options == nullptr) {
44 return nullptr;
45 }
46 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
47
48 Image_Size size;
49 size.width = IMAGE_TEST_WIDTH;
50 size.height = IMAGE_TEST_HEIGHT;
51 nRst = OH_ImageReceiverOptions_SetSize(options, size);
52 if (nRst != IMAGE_SUCCESS) {
53 return nullptr;
54 }
55
56 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
57 if (nRst != IMAGE_SUCCESS) {
58 return nullptr;
59 }
60
61 OH_ImageReceiverNative* pReceiver = nullptr;
62 nRst = OH_ImageReceiverNative_Create(options, &pReceiver);
63 if (nRst != IMAGE_SUCCESS || pReceiver == nullptr) {
64 return nullptr;
65 }
66 return pReceiver;
67 }
68
69 /**
70 * @tc.name: OH_ImageReceiverOptions_CreateTest
71 * @tc.desc: OH_ImageReceiverOptions_Create
72 * @tc.type: FUNC
73 */
74 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest, TestSize.Level3)
75 {
76 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest start";
77 OH_ImageReceiverOptions* options = nullptr;
78 Image_ErrorCode nRst = IMAGE_SUCCESS;
79 nRst = OH_ImageReceiverOptions_Create(&options);
80 ASSERT_EQ(nRst, IMAGE_SUCCESS);
81 ASSERT_NE(options, nullptr);
82 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
83 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest end";
84 }
85
86 /**
87 * @tc.name: OH_ImageReceiverOptions_ReleaseTest
88 * @tc.desc: OH_ImageReceiverOptions_Release
89 * @tc.type: FUNC
90 */
91 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_ReleaseTest, TestSize.Level3)
92 {
93 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest start";
94 OH_ImageReceiverOptions* options = nullptr;
95 Image_ErrorCode nRst = IMAGE_SUCCESS;
96 nRst = OH_ImageReceiverOptions_Create(&options);
97 ASSERT_EQ(nRst, IMAGE_SUCCESS);
98 ASSERT_NE(options, nullptr);
99 nRst = OH_ImageReceiverOptions_Release(options);
100 ASSERT_EQ(nRst, IMAGE_SUCCESS);
101 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest end";
102 }
103
104 /**
105 * @tc.name: OH_ImageReceiverOptions_SetSizeTest
106 * @tc.desc: OH_ImageReceiverOptions_SetSize
107 * @tc.type: FUNC
108 */
109 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetSizeTest, TestSize.Level3)
110 {
111 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest start";
112 OH_ImageReceiverOptions* options = nullptr;
113 Image_ErrorCode nRst = IMAGE_SUCCESS;
114 nRst = OH_ImageReceiverOptions_Create(&options);
115 ASSERT_EQ(nRst, IMAGE_SUCCESS);
116 ASSERT_NE(options, nullptr);
117 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
118
119 Image_Size size;
120 size.width = IMAGE_TEST_WIDTH;
121 size.height = IMAGE_TEST_HEIGHT;
122 nRst = OH_ImageReceiverOptions_SetSize(options, size);
123 ASSERT_EQ(nRst, IMAGE_SUCCESS);
124 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest end";
125 }
126
127 /**
128 * @tc.name: OH_ImageReceiverOptions_GetSizeTest
129 * @tc.desc: OH_ImageReceiverOptions_GetSize
130 * @tc.type: FUNC
131 */
132 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetSizeTest, TestSize.Level3)
133 {
134 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest start";
135 OH_ImageReceiverOptions* options = nullptr;
136 Image_ErrorCode nRst = IMAGE_SUCCESS;
137 nRst = OH_ImageReceiverOptions_Create(&options);
138 ASSERT_EQ(nRst, IMAGE_SUCCESS);
139 ASSERT_NE(options, nullptr);
140 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
141
142 Image_Size size;
143 size.width = IMAGE_TEST_WIDTH;
144 size.height = IMAGE_TEST_HEIGHT;
145 nRst = OH_ImageReceiverOptions_SetSize(options, size);
146 ASSERT_EQ(nRst, IMAGE_SUCCESS);
147
148 Image_Size size_get;
149 nRst = OH_ImageReceiverOptions_GetSize(options, &size_get);
150 ASSERT_EQ(nRst, IMAGE_SUCCESS);
151 ASSERT_EQ(size_get.width, IMAGE_TEST_WIDTH);
152 ASSERT_EQ(size_get.height, IMAGE_TEST_HEIGHT);
153 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest end";
154 }
155
156 /**
157 * @tc.name: OH_ImageReceiverOptions_SetCapacityTest
158 * @tc.desc: OH_ImageReceiverOptions_SetCapacity
159 * @tc.type: FUNC
160 */
161 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetCapacityTest, TestSize.Level3)
162 {
163 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest start";
164 OH_ImageReceiverOptions* options = nullptr;
165 Image_ErrorCode nRst = IMAGE_SUCCESS;
166 nRst = OH_ImageReceiverOptions_Create(&options);
167 ASSERT_EQ(nRst, IMAGE_SUCCESS);
168 ASSERT_NE(options, nullptr);
169 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
170
171 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
172 ASSERT_EQ(nRst, IMAGE_SUCCESS);
173 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest end";
174 }
175
176 /**
177 * @tc.name: OH_ImageReceiverOptions_GetCapacityTest
178 * @tc.desc: OH_ImageReceiverOptions_GetCapacity
179 * @tc.type: FUNC
180 */
181 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetCapacityTest, TestSize.Level3)
182 {
183 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest start";
184 OH_ImageReceiverOptions* options = nullptr;
185 Image_ErrorCode nRst = IMAGE_SUCCESS;
186 nRst = OH_ImageReceiverOptions_Create(&options);
187 ASSERT_EQ(nRst, IMAGE_SUCCESS);
188 ASSERT_NE(options, nullptr);
189 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
190
191 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
192 ASSERT_EQ(nRst, IMAGE_SUCCESS);
193
194 int32_t nCapacity = 0;
195 nRst = OH_ImageReceiverOptions_GetCapacity(options, &nCapacity);
196 ASSERT_EQ(nRst, IMAGE_SUCCESS);
197 ASSERT_EQ(nCapacity, IMAGE_TEST_CAPACITY);
198 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest end";
199 }
200
201 /**
202 * @tc.name: OH_ImageReceiverNative_CreateTest
203 * @tc.desc: OH_ImageReceiverNative_Create
204 * @tc.type: FUNC
205 */
206 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest, TestSize.Level3)
207 {
208 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest start";
209 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
210 ASSERT_NE(pReceiver, nullptr);
211 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
212 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest end";
213 }
214
215 /**
216 * @tc.name: OH_ImageReceiverNative_ReleaseTest
217 * @tc.desc: OH_ImageReceiverNative_Release
218 * @tc.type: FUNC
219 */
220 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReleaseTest, TestSize.Level3)
221 {
222 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest start";
223 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
224 ASSERT_NE(pReceiver, nullptr);
225 Image_ErrorCode nRst = OH_ImageReceiverNative_Release(pReceiver);
226 ASSERT_EQ(nRst, IMAGE_SUCCESS);
227 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest end";
228 }
229
230 /**
231 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest
232 * @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
233 * @tc.type: FUNC
234 */
235 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest, TestSize.Level3)
236 {
237 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest start";
238 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
239 ASSERT_NE(pReceiver, nullptr);
240 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
241
242 uint64_t nSurfaceId = 0;
243 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(pReceiver, &nSurfaceId);
244 ASSERT_EQ(nRst, IMAGE_SUCCESS);
245 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest end";
246 }
247
248 /**
249 * @tc.name: OH_ImageReceiverNative_ReadLatestImageTest
250 * @tc.desc: OH_ImageReceiverNative_ReadLatestImage
251 * @tc.type: FUNC
252 */
253 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadLatestImageTest, TestSize.Level3)
254 {
255 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest start";
256 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
257 ASSERT_NE(pReceiver, nullptr);
258 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
259
260 OH_ImageNative* pImg = nullptr;
261 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadLatestImage(pReceiver, &pImg);
262 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
263 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest end";
264 }
265
266 /**
267 * @tc.name: OH_ImageReceiverNative_ReadNextImageTest
268 * @tc.desc: OH_ImageReceiverNative_ReadNextImage
269 * @tc.type: FUNC
270 */
271 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadNextImageTest, TestSize.Level3)
272 {
273 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest start";
274 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
275 ASSERT_NE(pReceiver, nullptr);
276 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
277
278 OH_ImageNative* pImg = nullptr;
279 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadNextImage(pReceiver, &pImg);
280 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
281 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest end";
282 }
283
284 /**
285 * @tc.name: OH_ImageReceiverNative_OnTest
286 * @tc.desc: OH_ImageReceiverNative_On
287 * @tc.type: FUNC
288 */
OH_ImageReceiver_OnCallback(OH_ImageReceiverNative * receiver)289 static void OH_ImageReceiver_OnCallback(OH_ImageReceiverNative* receiver) {}
290
291 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest, TestSize.Level3)
292 {
293 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest start";
294 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
295 ASSERT_NE(pReceiver, nullptr);
296 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
297
298 Image_ErrorCode nRst = OH_ImageReceiverNative_On(pReceiver, OH_ImageReceiver_OnCallback);
299 ASSERT_EQ(nRst, IMAGE_SUCCESS);
300 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest end";
301 }
302
303 /**
304 * @tc.name: OH_ImageReceiverNative_OffTest
305 * @tc.desc: OH_ImageReceiverNative_Off
306 * @tc.type: FUNC
307 */
308 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffTest, TestSize.Level3)
309 {
310 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest start";
311 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
312 ASSERT_NE(pReceiver, nullptr);
313 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
314
315 Image_ErrorCode nRst = OH_ImageReceiverNative_Off(pReceiver);
316 ASSERT_EQ(nRst, IMAGE_SUCCESS);
317 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest end";
318 }
319
320 /**
321 * @tc.name: OH_ImageReceiverNative_GetSizeTest
322 * @tc.desc: OH_ImageReceiverNative_GetSize
323 * @tc.type: FUNC
324 */
325 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest, TestSize.Level3)
326 {
327 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest start";
328 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
329 ASSERT_NE(pReceiver, nullptr);
330 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
331
332 Image_Size size;
333 Image_ErrorCode nRst = OH_ImageReceiverNative_GetSize(pReceiver, &size);
334 ASSERT_EQ(nRst, IMAGE_SUCCESS);
335 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest end";
336 }
337
338 /**
339 * @tc.name: OH_ImageReceiverNative_GetCapacityTest
340 * @tc.desc: OH_ImageReceiverNative_GetCapacity
341 * @tc.type: FUNC
342 */
343 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest, TestSize.Level3)
344 {
345 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest start";
346 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
347 ASSERT_NE(pReceiver, nullptr);
348 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
349
350 int32_t nCapacity = 0;
351 Image_ErrorCode nRst = OH_ImageReceiverNative_GetCapacity(pReceiver, &nCapacity);
352 ASSERT_EQ(nRst, IMAGE_SUCCESS);
353 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest end";
354 }
355
356 /**
357 @tc.name: OH_ImageReceiverOptions_CreateTest002
358 @tc.desc: OH_ImageReceiverOptions_Create
359 @tc.type: FUNC
360 */
361 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest002, TestSize.Level3)
362 {
363 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 start";
364 OH_ImageReceiverOptions** options = nullptr;
365 Image_ErrorCode nRst = OH_ImageReceiverOptions_Create(options);
366 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
367 OH_ImageReceiverOptions* opt = nullptr;
368 Image_Size size;
369 nRst = OH_ImageReceiverOptions_GetSize(opt, &size);
370 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
371 nRst = OH_ImageReceiverOptions_SetSize(opt, size);
372 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
373 int32_t capacity = 0;
374 nRst = OH_ImageReceiverOptions_GetCapacity(opt, &capacity);
375 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
376 nRst = OH_ImageReceiverOptions_SetCapacity(opt, capacity);
377 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
378 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 end";
379 }
380
381 /**
382 @tc.name: OH_ImageReceiverNative_CreateTest002
383 @tc.desc: OH_ImageReceiverNative_Create
384 @tc.type: FUNC
385 */
386 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest002, TestSize.Level3)
387 {
388 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 start";
389 OH_ImageReceiverOptions* options = nullptr;
390 OH_ImageReceiverNative* receiver = nullptr;
391 Image_ErrorCode nRst = OH_ImageReceiverNative_Create(options, &receiver);
392 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
393 OH_ImageReceiverOptions_Create(&options);
394 ASSERT_NE(options, nullptr);
395 receiver = ImageReceiverNativeTest::CreateReceiver();
396 ASSERT_NE(receiver, nullptr);
397 ASSERT_NE(&receiver, nullptr);
398 nRst = OH_ImageReceiverNative_Create(options, &receiver);
399 ASSERT_EQ(nRst, IMAGE_SUCCESS);
400 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 end";
401 }
402
403 /**
404 @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002
405 @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
406 @tc.type: FUNC
407 */
408 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest002, TestSize.Level3)
409 {
410 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 start";
411 OH_ImageReceiverNative* receiver = nullptr;
412 uint64_t* surfaceId = nullptr;
413 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, surfaceId);
414 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
415 OH_ImageNative** image = nullptr;
416 nRst = OH_ImageReceiverNative_ReadLatestImage(receiver, image);
417 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
418 nRst = OH_ImageReceiverNative_ReadNextImage(receiver, image);
419 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
420 nRst = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
421 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
422 nRst = OH_ImageReceiverNative_Off(receiver);
423 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
424 Image_Size* size = nullptr;
425 nRst = OH_ImageReceiverNative_GetSize(receiver, size);
426 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
427 int32_t* capacity = nullptr;
428 nRst = OH_ImageReceiverNative_GetCapacity(receiver, capacity);
429 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
430 nRst = OH_ImageReceiverNative_Release(receiver);
431 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
432 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 end";
433 }
434 } // namespace Media
435 } // namespace OHOS