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 #define private public
18 #define protected public
19 #include "common_utils.h"
20 #include "image_native.h"
21 #include "image_receiver_native.h"
22 #include "image_kits.h"
23 #include "image_receiver.h"
24
25 struct OH_ImageReceiverNative {
26 std::shared_ptr<OHOS::Media::ImageReceiver> ptrImgRcv;
27 };
28
29 struct OH_ImageReceiverOptions {
30 int32_t width = 0;
31 int32_t height = 0;
32 int32_t format = 0;
33 int32_t capacity = 0;
34 };
35
36 using namespace testing::ext;
37 namespace OHOS {
38 namespace Media {
39
40 static constexpr int32_t IMAGE_TEST_WIDTH = 8192;
41 static constexpr int32_t IMAGE_TEST_HEIGHT = 8;
42 static constexpr int32_t IMAGE_TEST_CAPACITY = 8;
43
44 class ImageReceiverNativeTest : public testing::Test {
45 public:
ImageReceiverNativeTest()46 ImageReceiverNativeTest() {}
~ImageReceiverNativeTest()47 ~ImageReceiverNativeTest() {}
48 static OH_ImageReceiverNative* CreateReceiver();
49 };
50
CreateReceiver()51 OH_ImageReceiverNative* ImageReceiverNativeTest::CreateReceiver()
52 {
53 OH_ImageReceiverOptions* options = nullptr;
54 Image_ErrorCode nRst = IMAGE_SUCCESS;
55 nRst = OH_ImageReceiverOptions_Create(&options);
56 if (nRst != IMAGE_SUCCESS || options == nullptr) {
57 return nullptr;
58 }
59 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
60
61 Image_Size size;
62 size.width = IMAGE_TEST_WIDTH;
63 size.height = IMAGE_TEST_HEIGHT;
64 nRst = OH_ImageReceiverOptions_SetSize(options, size);
65 if (nRst != IMAGE_SUCCESS) {
66 return nullptr;
67 }
68
69 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
70 if (nRst != IMAGE_SUCCESS) {
71 return nullptr;
72 }
73
74 OH_ImageReceiverNative* pReceiver = nullptr;
75 nRst = OH_ImageReceiverNative_Create(options, &pReceiver);
76 if (nRst != IMAGE_SUCCESS || pReceiver == nullptr) {
77 return nullptr;
78 }
79 return pReceiver;
80 }
81
OH_ImageReceiver_ImageArriveCallback_Test(OH_ImageReceiverNative * receiver,void * userData)82 static void OH_ImageReceiver_ImageArriveCallback_Test(OH_ImageReceiverNative *receiver, void *userData)
83 {
84 if (userData != nullptr) {
85 int32_t *number = static_cast<int32_t *>(userData);
86 *number = 1;
87 }
88 }
89
90 /**
91 * @tc.name: OH_ImageReceiverOptions_CreateTest
92 * @tc.desc: OH_ImageReceiverOptions_Create
93 * @tc.type: FUNC
94 */
95 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest, TestSize.Level3)
96 {
97 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest start";
98 OH_ImageReceiverOptions* options = nullptr;
99 Image_ErrorCode nRst = IMAGE_SUCCESS;
100 nRst = OH_ImageReceiverOptions_Create(&options);
101 ASSERT_EQ(nRst, IMAGE_SUCCESS);
102 ASSERT_NE(options, nullptr);
103 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
104 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest end";
105 }
106
107 /**
108 * @tc.name: OH_ImageReceiverOptions_ReleaseTest
109 * @tc.desc: OH_ImageReceiverOptions_Release
110 * @tc.type: FUNC
111 */
112 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_ReleaseTest, TestSize.Level3)
113 {
114 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest start";
115 OH_ImageReceiverOptions* options = nullptr;
116 Image_ErrorCode nRst = IMAGE_SUCCESS;
117 nRst = OH_ImageReceiverOptions_Create(&options);
118 ASSERT_EQ(nRst, IMAGE_SUCCESS);
119 ASSERT_NE(options, nullptr);
120 nRst = OH_ImageReceiverOptions_Release(options);
121 ASSERT_EQ(nRst, IMAGE_SUCCESS);
122 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest end";
123 }
124
125 /**
126 * @tc.name: OH_ImageReceiverOptions_SetSizeTest
127 * @tc.desc: OH_ImageReceiverOptions_SetSize
128 * @tc.type: FUNC
129 */
130 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetSizeTest, TestSize.Level3)
131 {
132 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest start";
133 OH_ImageReceiverOptions* options = nullptr;
134 Image_ErrorCode nRst = IMAGE_SUCCESS;
135 nRst = OH_ImageReceiverOptions_Create(&options);
136 ASSERT_EQ(nRst, IMAGE_SUCCESS);
137 ASSERT_NE(options, nullptr);
138 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
139
140 Image_Size size;
141 size.width = IMAGE_TEST_WIDTH;
142 size.height = IMAGE_TEST_HEIGHT;
143 nRst = OH_ImageReceiverOptions_SetSize(options, size);
144 ASSERT_EQ(nRst, IMAGE_SUCCESS);
145 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest end";
146 }
147
148 /**
149 * @tc.name: OH_ImageReceiverOptions_GetSizeTest
150 * @tc.desc: OH_ImageReceiverOptions_GetSize
151 * @tc.type: FUNC
152 */
153 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetSizeTest, TestSize.Level3)
154 {
155 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest start";
156 OH_ImageReceiverOptions* options = nullptr;
157 Image_ErrorCode nRst = IMAGE_SUCCESS;
158 nRst = OH_ImageReceiverOptions_Create(&options);
159 ASSERT_EQ(nRst, IMAGE_SUCCESS);
160 ASSERT_NE(options, nullptr);
161 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
162
163 Image_Size size;
164 size.width = IMAGE_TEST_WIDTH;
165 size.height = IMAGE_TEST_HEIGHT;
166 nRst = OH_ImageReceiverOptions_SetSize(options, size);
167 ASSERT_EQ(nRst, IMAGE_SUCCESS);
168
169 Image_Size size_get;
170 nRst = OH_ImageReceiverOptions_GetSize(options, &size_get);
171 ASSERT_EQ(nRst, IMAGE_SUCCESS);
172 ASSERT_EQ(size_get.width, IMAGE_TEST_WIDTH);
173 ASSERT_EQ(size_get.height, IMAGE_TEST_HEIGHT);
174 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest end";
175 }
176
177 /**
178 * @tc.name: OH_ImageReceiverOptions_SetCapacityTest
179 * @tc.desc: OH_ImageReceiverOptions_SetCapacity
180 * @tc.type: FUNC
181 */
182 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetCapacityTest, TestSize.Level3)
183 {
184 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest start";
185 OH_ImageReceiverOptions* options = nullptr;
186 Image_ErrorCode nRst = IMAGE_SUCCESS;
187 nRst = OH_ImageReceiverOptions_Create(&options);
188 ASSERT_EQ(nRst, IMAGE_SUCCESS);
189 ASSERT_NE(options, nullptr);
190 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
191
192 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
193 ASSERT_EQ(nRst, IMAGE_SUCCESS);
194 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest end";
195 }
196
197 /**
198 * @tc.name: OH_ImageReceiverOptions_GetCapacityTest
199 * @tc.desc: OH_ImageReceiverOptions_GetCapacity
200 * @tc.type: FUNC
201 */
202 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetCapacityTest, TestSize.Level3)
203 {
204 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest start";
205 OH_ImageReceiverOptions* options = nullptr;
206 Image_ErrorCode nRst = IMAGE_SUCCESS;
207 nRst = OH_ImageReceiverOptions_Create(&options);
208 ASSERT_EQ(nRst, IMAGE_SUCCESS);
209 ASSERT_NE(options, nullptr);
210 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
211
212 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
213 ASSERT_EQ(nRst, IMAGE_SUCCESS);
214
215 int32_t nCapacity = 0;
216 nRst = OH_ImageReceiverOptions_GetCapacity(options, &nCapacity);
217 ASSERT_EQ(nRst, IMAGE_SUCCESS);
218 ASSERT_EQ(nCapacity, IMAGE_TEST_CAPACITY);
219 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest end";
220 }
221
222 /**
223 * @tc.name: OH_ImageReceiverNative_CreateTest
224 * @tc.desc: OH_ImageReceiverNative_Create
225 * @tc.type: FUNC
226 */
227 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest, TestSize.Level3)
228 {
229 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest start";
230 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
231 ASSERT_NE(pReceiver, nullptr);
232 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
233 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest end";
234 }
235
236 /**
237 * @tc.name: OH_ImageReceiverNative_ReleaseTest
238 * @tc.desc: OH_ImageReceiverNative_Release
239 * @tc.type: FUNC
240 */
241 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReleaseTest, TestSize.Level3)
242 {
243 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest start";
244 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
245 ASSERT_NE(pReceiver, nullptr);
246 Image_ErrorCode nRst = OH_ImageReceiverNative_Release(pReceiver);
247 ASSERT_EQ(nRst, IMAGE_SUCCESS);
248 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest end";
249 }
250
251 /**
252 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest
253 * @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
254 * @tc.type: FUNC
255 */
256 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest, TestSize.Level3)
257 {
258 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest start";
259 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
260 ASSERT_NE(pReceiver, nullptr);
261 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
262
263 uint64_t nSurfaceId = 0;
264 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(pReceiver, &nSurfaceId);
265 ASSERT_EQ(nRst, IMAGE_SUCCESS);
266 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest end";
267 }
268
269 /**
270 * @tc.name: OH_ImageReceiverNative_ReadLatestImageTest
271 * @tc.desc: OH_ImageReceiverNative_ReadLatestImage
272 * @tc.type: FUNC
273 */
274 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadLatestImageTest, TestSize.Level3)
275 {
276 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest start";
277 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
278 ASSERT_NE(pReceiver, nullptr);
279 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
280
281 OH_ImageNative* pImg = nullptr;
282 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadLatestImage(pReceiver, &pImg);
283 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
284 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest end";
285 }
286
287 /**
288 * @tc.name: OH_ImageReceiverNative_ReadNextImageTest
289 * @tc.desc: OH_ImageReceiverNative_ReadNextImage
290 * @tc.type: FUNC
291 */
292 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadNextImageTest, TestSize.Level3)
293 {
294 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest start";
295 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
296 ASSERT_NE(pReceiver, nullptr);
297 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
298
299 OH_ImageNative* pImg = nullptr;
300 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadNextImage(pReceiver, &pImg);
301 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
302 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest end";
303 }
304
305 /**
306 * @tc.name: OH_ImageReceiverNative_OnTest
307 * @tc.desc: OH_ImageReceiverNative_On
308 * @tc.type: FUNC
309 */
OH_ImageReceiver_OnCallback(OH_ImageReceiverNative * receiver)310 static void OH_ImageReceiver_OnCallback(OH_ImageReceiverNative* receiver) {}
311
312 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest, TestSize.Level3)
313 {
314 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest start";
315 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
316 ASSERT_NE(pReceiver, nullptr);
317 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
318
319 Image_ErrorCode nRst = OH_ImageReceiverNative_On(pReceiver, OH_ImageReceiver_OnCallback);
320 ASSERT_EQ(nRst, IMAGE_SUCCESS);
321 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest end";
322 }
323
324 /**
325 * @tc.name: OH_ImageReceiverNative_OffTest
326 * @tc.desc: OH_ImageReceiverNative_Off
327 * @tc.type: FUNC
328 */
329 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffTest, TestSize.Level3)
330 {
331 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest start";
332 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
333 ASSERT_NE(pReceiver, nullptr);
334 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
335
336 Image_ErrorCode nRst = OH_ImageReceiverNative_Off(pReceiver);
337 ASSERT_EQ(nRst, IMAGE_SUCCESS);
338 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest end";
339 }
340
341 /**
342 * @tc.name: OH_ImageReceiverNative_GetSizeTest
343 * @tc.desc: OH_ImageReceiverNative_GetSize
344 * @tc.type: FUNC
345 */
346 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest, TestSize.Level3)
347 {
348 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest start";
349 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
350 ASSERT_NE(pReceiver, nullptr);
351 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
352
353 Image_Size size;
354 Image_ErrorCode nRst = OH_ImageReceiverNative_GetSize(pReceiver, &size);
355 ASSERT_EQ(nRst, IMAGE_SUCCESS);
356 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest end";
357 }
358
359 /**
360 * @tc.name: OH_ImageReceiverNative_GetCapacityTest
361 * @tc.desc: OH_ImageReceiverNative_GetCapacity
362 * @tc.type: FUNC
363 */
364 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest, TestSize.Level3)
365 {
366 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest start";
367 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
368 ASSERT_NE(pReceiver, nullptr);
369 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
370
371 int32_t nCapacity = 0;
372 Image_ErrorCode nRst = OH_ImageReceiverNative_GetCapacity(pReceiver, &nCapacity);
373 ASSERT_EQ(nRst, IMAGE_SUCCESS);
374 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest end";
375 }
376
377 /**
378 @tc.name: OH_ImageReceiverOptions_CreateTest002
379 @tc.desc: OH_ImageReceiverOptions_Create
380 @tc.type: FUNC
381 */
382 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest002, TestSize.Level3)
383 {
384 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 start";
385 OH_ImageReceiverOptions** options = nullptr;
386 Image_ErrorCode nRst = OH_ImageReceiverOptions_Create(options);
387 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
388 OH_ImageReceiverOptions* opt = nullptr;
389 Image_Size size;
390 nRst = OH_ImageReceiverOptions_GetSize(opt, &size);
391 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
392 nRst = OH_ImageReceiverOptions_SetSize(opt, size);
393 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
394 int32_t capacity = 0;
395 nRst = OH_ImageReceiverOptions_GetCapacity(opt, &capacity);
396 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
397 nRst = OH_ImageReceiverOptions_SetCapacity(opt, capacity);
398 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
399 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 end";
400 }
401
402 /**
403 @tc.name: OH_ImageReceiverNative_CreateTest002
404 @tc.desc: OH_ImageReceiverNative_Create
405 @tc.type: FUNC
406 */
407 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest002, TestSize.Level3)
408 {
409 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 start";
410 OH_ImageReceiverOptions* options = nullptr;
411 OH_ImageReceiverNative* receiver = nullptr;
412 Image_ErrorCode nRst = OH_ImageReceiverNative_Create(options, &receiver);
413 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
414 OH_ImageReceiverOptions_Create(&options);
415 ASSERT_NE(options, nullptr);
416 receiver = ImageReceiverNativeTest::CreateReceiver();
417 ASSERT_NE(receiver, nullptr);
418 ASSERT_NE(&receiver, nullptr);
419 nRst = OH_ImageReceiverNative_Create(options, &receiver);
420 ASSERT_EQ(nRst, IMAGE_SUCCESS);
421 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 end";
422 }
423
424 /**
425 @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002
426 @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
427 @tc.type: FUNC
428 */
429 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest002, TestSize.Level3)
430 {
431 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 start";
432 OH_ImageReceiverNative* receiver = nullptr;
433 uint64_t* surfaceId = nullptr;
434 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, surfaceId);
435 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
436 OH_ImageNative** image = nullptr;
437 nRst = OH_ImageReceiverNative_ReadLatestImage(receiver, image);
438 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
439 nRst = OH_ImageReceiverNative_ReadNextImage(receiver, image);
440 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
441 nRst = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
442 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
443 nRst = OH_ImageReceiverNative_Off(receiver);
444 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
445 Image_Size* size = nullptr;
446 nRst = OH_ImageReceiverNative_GetSize(receiver, size);
447 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
448 int32_t* capacity = nullptr;
449 nRst = OH_ImageReceiverNative_GetCapacity(receiver, capacity);
450 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
451 nRst = OH_ImageReceiverNative_Release(receiver);
452 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
453 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 end";
454 }
455
456 /**
457 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003
458 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
459 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
460 * @tc.type: FUNC
461 */
462 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest003, TestSize.Level3)
463 {
464 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003 start";
465 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
466 receiver->ptrImgRcv = nullptr;
467 uint64_t surfaceId = 0;
468 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
469 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
470 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003 end";
471 }
472
473 /**
474 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004
475 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
476 when receiverKey is empty,return IMAGE_UNKNOWN_ERROR
477 * @tc.type: FUNC
478 */
479 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest004, TestSize.Level3)
480 {
481 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004 start";
482 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
483 std::string receiverKey = "";
484 receiver->ptrImgRcv->iraContext_->SetReceiverKey(receiverKey);
485 uint64_t surfaceId = 0;
486 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
487 ASSERT_EQ(ret, IMAGE_UNKNOWN_ERROR);
488 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004 end";
489 }
490
491 /**
492 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005
493 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
494 when receiverKey convert string to uint64_t failed,return IMAGE_UNKNOWN_ERROR
495 * @tc.type: FUNC
496 */
497 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest005, TestSize.Level3)
498 {
499 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005 start";
500 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
501 std::string receiverKey = "abc";
502 receiver->ptrImgRcv->iraContext_->SetReceiverKey(receiverKey);
503 uint64_t surfaceId = 0;
504 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
505 ASSERT_EQ(ret, IMAGE_UNKNOWN_ERROR);
506 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005 end";
507 }
508
509 /**
510 * @tc.name: OH_ImageReceiverNative_ReadLatestImageTest002
511 * @tc.desc: test the OH_ImageReceiverNative_ReadLatestImage
512 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
513 * @tc.type: FUNC
514 */
515 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadLatestImageTest002, TestSize.Level3)
516 {
517 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest002 start";
518 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
519 receiver->ptrImgRcv = nullptr;
520 OH_ImageNative* image = nullptr;
521 Image_ErrorCode ret = OH_ImageReceiverNative_ReadLatestImage(receiver, &image);
522 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
523 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest002 end";
524 }
525
526 /**
527 * @tc.name: OH_ImageReceiverNative_ReadNextImageTest002
528 * @tc.desc: test the OH_ImageReceiverNative_ReadNextImage
529 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
530 * @tc.type: FUNC
531 */
532 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadNextImageTest002, TestSize.Level3)
533 {
534 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest002 start";
535 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
536 receiver->ptrImgRcv = nullptr;
537 OH_ImageNative* image = nullptr;
538 Image_ErrorCode ret = OH_ImageReceiverNative_ReadNextImage(receiver, &image);
539 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
540 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest002 end";
541 }
542
543 /**
544 * @tc.name: OH_ImageReceiverNative_OnTest002
545 * @tc.desc: test the OH_ImageReceiverNative_On
546 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
547 * @tc.type: FUNC
548 */
549 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest002, TestSize.Level3)
550 {
551 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest002 start";
552 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
553 receiver->ptrImgRcv = nullptr;
554 Image_ErrorCode ret = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
555 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
556 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest002 end";
557 }
558
559 /**
560 * @tc.name: OH_ImageReceiverNative_OffTest002
561 * @tc.desc: test the OH_ImageReceiverNative_Off
562 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
563 * @tc.type: FUNC
564 */
565 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffTest002, TestSize.Level3)
566 {
567 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest002 start";
568 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
569 receiver->ptrImgRcv = nullptr;
570 Image_ErrorCode ret = OH_ImageReceiverNative_Off(receiver);
571 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
572 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest002 end";
573 }
574
575 /**
576 * @tc.name: OH_ImageReceiverNative_GetSizeTest002
577 * @tc.desc: test the OH_ImageReceiverNative_GetSize
578 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
579 * @tc.type: FUNC
580 */
581 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest002, TestSize.Level3)
582 {
583 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest002 start";
584 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
585 receiver->ptrImgRcv = nullptr;
586 Image_Size size = {1, 1};
587 Image_ErrorCode ret = OH_ImageReceiverNative_GetSize(receiver, &size);
588 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
589 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest002 end";
590 }
591
592 /**
593 * @tc.name: OH_ImageReceiverNative_GetCapacityTest002
594 * @tc.desc: test the OH_ImageReceiverNative_GetCapacity
595 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
596 * @tc.type: FUNC
597 */
598 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest002, TestSize.Level3)
599 {
600 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest002 start";
601 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
602 receiver->ptrImgRcv = nullptr;
603 int32_t capacity = 0;
604 Image_ErrorCode ret = OH_ImageReceiverNative_GetCapacity(receiver, &capacity);
605 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
606 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest002 end";
607 }
608
609 /**
610 * @tc.name: OH_ImageReceiverOptions_ReleaseTest001
611 * @tc.desc: test the OH_ImageReceiverOptions_Release when options is not nullptr or nullptr
612 * @tc.type: FUNC
613 */
614 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_ReleaseTest001, TestSize.Level3)
615 {
616 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest001 start";
617 OH_ImageReceiverOptions* options = new OH_ImageReceiverOptions;
618 ASSERT_NE(options, nullptr);
619 Image_ErrorCode errCode = OH_ImageReceiverOptions_Release(options);
620 EXPECT_EQ(errCode, IMAGE_SUCCESS);
621
622 errCode = OH_ImageReceiverOptions_Release(nullptr);
623 EXPECT_EQ(errCode, IMAGE_SUCCESS);
624 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest001 end";
625 }
626
627 /**
628 * @tc.name: OH_ImageReceiverNative_CreateTest001
629 * @tc.desc: test the OH_ImageReceiverNative_Create when options and receiver is nullptr or not
630 * @tc.type: FUNC
631 */
632 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest001, TestSize.Level3)
633 {
634 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest001 start";
635 Image_ErrorCode errCode = OH_ImageReceiverNative_Create(nullptr, nullptr);
636 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
637
638 OH_ImageReceiverOptions* options = new OH_ImageReceiverOptions;
639 ASSERT_NE(options, nullptr);
640 errCode = OH_ImageReceiverNative_Create(options, nullptr);
641 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
642
643 OH_ImageReceiverNative* receiver = new OH_ImageReceiverNative;
644 ASSERT_NE(receiver, nullptr);
645 errCode = OH_ImageReceiverNative_Create(options, &receiver);
646 EXPECT_EQ(errCode, IMAGE_SUCCESS);
647
648 delete options;
649 delete receiver;
650 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest001 end";
651 }
652
653 /**
654 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest001
655 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId when ptrImgRcv or iraContexe is nullptr or not
656 * @tc.type: FUNC
657 */
658 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest001, TestSize.Level3)
659 {
660 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest001 start";
661 OH_ImageReceiverNative* receiver = new OH_ImageReceiverNative;
662 ASSERT_NE(receiver, nullptr);
663 uint64_t mockSurfaceId = 1;
664 receiver->ptrImgRcv = nullptr;
665
666 Image_ErrorCode errCode = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &mockSurfaceId);
667 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
668
669 receiver->ptrImgRcv = std::make_shared<OHOS::Media::ImageReceiver>();
670 ASSERT_NE(receiver->ptrImgRcv, nullptr);
671 receiver->ptrImgRcv->iraContext_ = nullptr;
672 errCode = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &mockSurfaceId);
673 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
674
675 ASSERT_NE(receiver->ptrImgRcv, nullptr);
676 receiver->ptrImgRcv->iraContext_ = std::make_shared<OHOS::Media::ImageReceiverContext>();
677 ASSERT_NE(receiver->ptrImgRcv->iraContext_, nullptr);
678 receiver->ptrImgRcv->iraContext_->receiverKey_ = "";
679 errCode = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &mockSurfaceId);
680 EXPECT_EQ(errCode, IMAGE_UNKNOWN_ERROR);
681
682 delete receiver;
683 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest001 end";
684 }
685
686 /**
687 * @tc.name: OH_ImageReceiverNative_OnTest001
688 * @tc.desc: test the OH_ImageReceiverNative_On when receiver and callback is nullptr or not
689 * @tc.type: FUNC
690 */
691 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest001, TestSize.Level3)
692 {
693 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest001 start";
694 OH_ImageReceiverNative* receiver = new OH_ImageReceiverNative;
695 ASSERT_NE(receiver, nullptr);
696 receiver->ptrImgRcv = nullptr;
697
698 Image_ErrorCode errCode = OH_ImageReceiverNative_On(nullptr, nullptr);
699 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
700
701 errCode = OH_ImageReceiverNative_On(receiver, nullptr);
702 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
703
704 errCode = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
705 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
706
707 delete receiver;
708 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest001 end";
709 }
710
711 /**
712 * @tc.name: OH_ImageReceiverNative_GetSizeTest001
713 * @tc.desc: test the OH_ImageReceiverNative_GetSize when size and iraContext is nullptr or not
714 * @tc.type: FUNC
715 */
716 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest001, TestSize.Level3)
717 {
718 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest001 start";
719 OH_ImageReceiverNative* receiver = new OH_ImageReceiverNative;
720 ASSERT_NE(receiver, nullptr);
721 Image_Size* size = new Image_Size;
722 ASSERT_NE(size, nullptr);
723
724 Image_ErrorCode errCode = OH_ImageReceiverNative_GetSize(nullptr, nullptr);
725 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
726
727 errCode = OH_ImageReceiverNative_GetSize(receiver, nullptr);
728 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
729
730 receiver->ptrImgRcv = nullptr;
731 errCode = OH_ImageReceiverNative_GetSize(receiver, size);
732 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
733
734 receiver->ptrImgRcv = std::make_shared<OHOS::Media::ImageReceiver>();
735 ASSERT_NE(receiver->ptrImgRcv, nullptr);
736 receiver->ptrImgRcv->iraContext_ = nullptr;
737 errCode = OH_ImageReceiverNative_GetSize(receiver, size);
738 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
739
740 ASSERT_NE(receiver->ptrImgRcv, nullptr);
741 receiver->ptrImgRcv->iraContext_ = std::make_shared<OHOS::Media::ImageReceiverContext>();
742 ASSERT_NE(receiver->ptrImgRcv->iraContext_, nullptr);
743 errCode = OH_ImageReceiverNative_GetSize(receiver, size);
744 EXPECT_EQ(errCode, IMAGE_SUCCESS);
745
746 delete receiver;
747 delete size;
748 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest001 end";
749 }
750
751 /**
752 * @tc.name: OH_ImageReceiverNative_GetCapacityTest001
753 * @tc.desc: test the OH_ImageReceiverNative_GetCapacity when capacity and iraContext is nullptr or not
754 * @tc.type: FUNC
755 */
756 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest001, TestSize.Level3)
757 {
758 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest001 start";
759 OH_ImageReceiverNative* receiver = new OH_ImageReceiverNative;
760 ASSERT_NE(receiver, nullptr);
761 int32_t mockCapacity = 32;
762
763 Image_ErrorCode errCode = OH_ImageReceiverNative_GetCapacity(nullptr, nullptr);
764 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
765
766 errCode = OH_ImageReceiverNative_GetCapacity(receiver, nullptr);
767 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
768
769 receiver->ptrImgRcv = nullptr;
770 errCode = OH_ImageReceiverNative_GetCapacity(receiver, &mockCapacity);
771 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
772
773 receiver->ptrImgRcv = std::make_shared<OHOS::Media::ImageReceiver>();
774 ASSERT_NE(receiver->ptrImgRcv, nullptr);
775 receiver->ptrImgRcv->iraContext_ = nullptr;
776 mockCapacity = 32;
777 errCode = OH_ImageReceiverNative_GetCapacity(receiver, &mockCapacity);
778 EXPECT_EQ(errCode, IMAGE_BAD_PARAMETER);
779
780 ASSERT_NE(receiver->ptrImgRcv, nullptr);
781 receiver->ptrImgRcv->iraContext_ = std::make_shared<OHOS::Media::ImageReceiverContext>();
782 ASSERT_NE(receiver->ptrImgRcv->iraContext_, nullptr);
783 mockCapacity = 32;
784 errCode = OH_ImageReceiverNative_GetCapacity(receiver, &mockCapacity);
785 EXPECT_EQ(errCode, IMAGE_SUCCESS);
786
787 delete receiver;
788 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest001 end";
789 }
790
791 /*
792 * @tc.name: OH_ImageReceiverNative_OnImageArriveTest001
793 * @tc.desc: erify that OH_ImageReceiverNative_OnImageArrive correctly registers the callback, handles duplicate
794 * registrations, and triggers the callback when a surface buffer becomes available, updating the user data.
795 * @tc.type: FUNC
796 */
797
798 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnImageArriveTest001, TestSize.Level3)
799 {
800 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnImageArriveTest001 start";
801 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
802 ASSERT_NE(pReceiver, nullptr);
803 int32_t number = 0;
804 void* userData = &number;
805 Image_ErrorCode nRst = OH_ImageReceiverNative_OnImageArrive(pReceiver,
806 OH_ImageReceiver_ImageArriveCallback_Test, userData);
807 ASSERT_EQ(nRst, IMAGE_SUCCESS);
808 nRst = OH_ImageReceiverNative_OnImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test, userData);
809 ASSERT_EQ(nRst, IMAGE_SUCCESS);
810
811 ASSERT_NE(pReceiver->ptrImgRcv, nullptr);
812 std::shared_ptr<ImageReceiverArriveListener> receiverArriveListener =
813 std::make_shared<ImageReceiverArriveListener>(pReceiver);
814 receiverArriveListener->RegisterCallback(OH_ImageReceiver_ImageArriveCallback_Test, userData);
815 pReceiver->ptrImgRcv->surfaceBufferAvaliableListener_ = receiverArriveListener;
816 ASSERT_NE(pReceiver->ptrImgRcv->surfaceBufferAvaliableListener_, nullptr);
817
818 pReceiver->ptrImgRcv->surfaceBufferAvaliableListener_->OnSurfaceBufferAvaliable();
819 EXPECT_EQ(number, 1);
820 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
821 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnImageArriveTest001 end";
822 }
823
824 /**
825 * @tc.name: OH_ImageReceiverNative_OnImageArriveTest002
826 * @tc.desc: Verify that OH_ImageReceiverNative_OnImageArrive returns IMAGE_RECEIVER_INVALID_PARAMETER when the receiver
827 * is null, the callback is null, or the receiver's internal pointer is null.
828 * @tc.type: FUNC
829 */
830 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnImageArriveTest002, TestSize.Level3)
831 {
832 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnImageArriveTest002 start";
833 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
834 receiver->ptrImgRcv = nullptr;
835 Image_ErrorCode ret;
836 ret = OH_ImageReceiverNative_OnImageArrive(nullptr, OH_ImageReceiver_ImageArriveCallback_Test, nullptr);
837 ASSERT_EQ(ret, IMAGE_RECEIVER_INVALID_PARAMETER);
838 ret = OH_ImageReceiverNative_OnImageArrive(receiver, OH_ImageReceiver_ImageArriveCallback_Test, nullptr);
839 ASSERT_EQ(ret, IMAGE_RECEIVER_INVALID_PARAMETER);
840 ret = OH_ImageReceiverNative_OnImageArrive(receiver, nullptr, nullptr);
841 ASSERT_EQ(ret, IMAGE_RECEIVER_INVALID_PARAMETER);
842 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(receiver, OH_ImageReceiverNative_Release);
843 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest002 end";
844 }
845
846 /**
847 * @tc.name: OH_ImageReceiverNative_OffImageArriveTest001
848 * @tc.desc: Verify that OH_ImageReceiverNative_OffImageArrive correctly handles invalid parameters, including null
849 * receiver, null callback, and receiver with a null internal pointer, and returns appropriate error codes.
850 * @tc.type: FUNC
851 */
852 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffImageArriveTest001, TestSize.Level3)
853 {
854 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffImageArriveTest001 start";
855 Image_ErrorCode nRst = OH_ImageReceiverNative_OffImageArrive(nullptr, OH_ImageReceiver_ImageArriveCallback_Test);
856 ASSERT_EQ(nRst, IMAGE_RECEIVER_INVALID_PARAMETER);
857 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
858 ASSERT_NE(pReceiver, nullptr);
859 nRst = OH_ImageReceiverNative_OffImageArrive(pReceiver, nullptr);
860 ASSERT_EQ(nRst, IMAGE_SUCCESS);
861 pReceiver->ptrImgRcv = nullptr;
862 nRst = OH_ImageReceiverNative_OffImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test);
863 ASSERT_EQ(nRst, IMAGE_RECEIVER_INVALID_PARAMETER);
864 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
865 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffImageArriveTest001 end";
866 }
867
868 /**
869 * @tc.name: OH_ImageReceiverNative_OffImageArriveTest002
870 * @tc.desc: Verify that OH_ImageReceiverNative_OffImageArrive correctly handles registering
871 * and unregistering the callback.
872 * @tc.type: FUNC
873 */
874 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffImageArriveTest002, TestSize.Level3)
875 {
876 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffImageArriveTest002 start";
877 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
878 ASSERT_NE(pReceiver, nullptr);
879 int32_t number = 0;
880 void* userData = &number;
881 Image_ErrorCode nRst;
882 nRst = OH_ImageReceiverNative_OffImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test);
883 ASSERT_EQ(nRst, IMAGE_RECEIVER_INVALID_PARAMETER);
884
885 nRst = OH_ImageReceiverNative_OnImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test, userData);
886 ASSERT_EQ(nRst, IMAGE_SUCCESS);
887
888 nRst = OH_ImageReceiverNative_OffImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test);
889 ASSERT_EQ(nRst, IMAGE_SUCCESS);
890
891 nRst = OH_ImageReceiverNative_OffImageArrive(pReceiver, OH_ImageReceiver_ImageArriveCallback_Test);
892 ASSERT_EQ(nRst, IMAGE_RECEIVER_INVALID_PARAMETER);
893 }
894
895 } // namespace Media
896 } // namespace OHOS