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 struct OH_ImageReceiverNative {
24 std::shared_ptr<OHOS::Media::ImageReceiver> ptrImgRcv;
25 };
26
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace Media {
30
31 static constexpr int32_t IMAGE_TEST_WIDTH = 8192;
32 static constexpr int32_t IMAGE_TEST_HEIGHT = 8;
33 static constexpr int32_t IMAGE_TEST_CAPACITY = 8;
34
35 class ImageReceiverNativeTest : public testing::Test {
36 public:
ImageReceiverNativeTest()37 ImageReceiverNativeTest() {}
~ImageReceiverNativeTest()38 ~ImageReceiverNativeTest() {}
39 static OH_ImageReceiverNative* CreateReceiver();
40 };
41
CreateReceiver()42 OH_ImageReceiverNative* ImageReceiverNativeTest::CreateReceiver()
43 {
44 OH_ImageReceiverOptions* options = nullptr;
45 Image_ErrorCode nRst = IMAGE_SUCCESS;
46 nRst = OH_ImageReceiverOptions_Create(&options);
47 if (nRst != IMAGE_SUCCESS || options == nullptr) {
48 return nullptr;
49 }
50 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
51
52 Image_Size size;
53 size.width = IMAGE_TEST_WIDTH;
54 size.height = IMAGE_TEST_HEIGHT;
55 nRst = OH_ImageReceiverOptions_SetSize(options, size);
56 if (nRst != IMAGE_SUCCESS) {
57 return nullptr;
58 }
59
60 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
61 if (nRst != IMAGE_SUCCESS) {
62 return nullptr;
63 }
64
65 OH_ImageReceiverNative* pReceiver = nullptr;
66 nRst = OH_ImageReceiverNative_Create(options, &pReceiver);
67 if (nRst != IMAGE_SUCCESS || pReceiver == nullptr) {
68 return nullptr;
69 }
70 return pReceiver;
71 }
72
73 /**
74 * @tc.name: OH_ImageReceiverOptions_CreateTest
75 * @tc.desc: OH_ImageReceiverOptions_Create
76 * @tc.type: FUNC
77 */
78 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest, TestSize.Level3)
79 {
80 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest start";
81 OH_ImageReceiverOptions* options = nullptr;
82 Image_ErrorCode nRst = IMAGE_SUCCESS;
83 nRst = OH_ImageReceiverOptions_Create(&options);
84 ASSERT_EQ(nRst, IMAGE_SUCCESS);
85 ASSERT_NE(options, nullptr);
86 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
87 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest end";
88 }
89
90 /**
91 * @tc.name: OH_ImageReceiverOptions_ReleaseTest
92 * @tc.desc: OH_ImageReceiverOptions_Release
93 * @tc.type: FUNC
94 */
95 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_ReleaseTest, TestSize.Level3)
96 {
97 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest 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 nRst = OH_ImageReceiverOptions_Release(options);
104 ASSERT_EQ(nRst, IMAGE_SUCCESS);
105 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_ReleaseTest end";
106 }
107
108 /**
109 * @tc.name: OH_ImageReceiverOptions_SetSizeTest
110 * @tc.desc: OH_ImageReceiverOptions_SetSize
111 * @tc.type: FUNC
112 */
113 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetSizeTest, TestSize.Level3)
114 {
115 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest start";
116 OH_ImageReceiverOptions* options = nullptr;
117 Image_ErrorCode nRst = IMAGE_SUCCESS;
118 nRst = OH_ImageReceiverOptions_Create(&options);
119 ASSERT_EQ(nRst, IMAGE_SUCCESS);
120 ASSERT_NE(options, nullptr);
121 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
122
123 Image_Size size;
124 size.width = IMAGE_TEST_WIDTH;
125 size.height = IMAGE_TEST_HEIGHT;
126 nRst = OH_ImageReceiverOptions_SetSize(options, size);
127 ASSERT_EQ(nRst, IMAGE_SUCCESS);
128 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetSizeTest end";
129 }
130
131 /**
132 * @tc.name: OH_ImageReceiverOptions_GetSizeTest
133 * @tc.desc: OH_ImageReceiverOptions_GetSize
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetSizeTest, TestSize.Level3)
137 {
138 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest start";
139 OH_ImageReceiverOptions* options = nullptr;
140 Image_ErrorCode nRst = IMAGE_SUCCESS;
141 nRst = OH_ImageReceiverOptions_Create(&options);
142 ASSERT_EQ(nRst, IMAGE_SUCCESS);
143 ASSERT_NE(options, nullptr);
144 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
145
146 Image_Size size;
147 size.width = IMAGE_TEST_WIDTH;
148 size.height = IMAGE_TEST_HEIGHT;
149 nRst = OH_ImageReceiverOptions_SetSize(options, size);
150 ASSERT_EQ(nRst, IMAGE_SUCCESS);
151
152 Image_Size size_get;
153 nRst = OH_ImageReceiverOptions_GetSize(options, &size_get);
154 ASSERT_EQ(nRst, IMAGE_SUCCESS);
155 ASSERT_EQ(size_get.width, IMAGE_TEST_WIDTH);
156 ASSERT_EQ(size_get.height, IMAGE_TEST_HEIGHT);
157 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetSizeTest end";
158 }
159
160 /**
161 * @tc.name: OH_ImageReceiverOptions_SetCapacityTest
162 * @tc.desc: OH_ImageReceiverOptions_SetCapacity
163 * @tc.type: FUNC
164 */
165 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_SetCapacityTest, TestSize.Level3)
166 {
167 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest start";
168 OH_ImageReceiverOptions* options = nullptr;
169 Image_ErrorCode nRst = IMAGE_SUCCESS;
170 nRst = OH_ImageReceiverOptions_Create(&options);
171 ASSERT_EQ(nRst, IMAGE_SUCCESS);
172 ASSERT_NE(options, nullptr);
173 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
174
175 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
176 ASSERT_EQ(nRst, IMAGE_SUCCESS);
177 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_SetCapacityTest end";
178 }
179
180 /**
181 * @tc.name: OH_ImageReceiverOptions_GetCapacityTest
182 * @tc.desc: OH_ImageReceiverOptions_GetCapacity
183 * @tc.type: FUNC
184 */
185 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_GetCapacityTest, TestSize.Level3)
186 {
187 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest start";
188 OH_ImageReceiverOptions* options = nullptr;
189 Image_ErrorCode nRst = IMAGE_SUCCESS;
190 nRst = OH_ImageReceiverOptions_Create(&options);
191 ASSERT_EQ(nRst, IMAGE_SUCCESS);
192 ASSERT_NE(options, nullptr);
193 std::shared_ptr<OH_ImageReceiverOptions> ptrOptions(options, OH_ImageReceiverOptions_Release);
194
195 nRst = OH_ImageReceiverOptions_SetCapacity(options, IMAGE_TEST_CAPACITY);
196 ASSERT_EQ(nRst, IMAGE_SUCCESS);
197
198 int32_t nCapacity = 0;
199 nRst = OH_ImageReceiverOptions_GetCapacity(options, &nCapacity);
200 ASSERT_EQ(nRst, IMAGE_SUCCESS);
201 ASSERT_EQ(nCapacity, IMAGE_TEST_CAPACITY);
202 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_GetCapacityTest end";
203 }
204
205 /**
206 * @tc.name: OH_ImageReceiverNative_CreateTest
207 * @tc.desc: OH_ImageReceiverNative_Create
208 * @tc.type: FUNC
209 */
210 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest, TestSize.Level3)
211 {
212 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest start";
213 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
214 ASSERT_NE(pReceiver, nullptr);
215 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
216 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest end";
217 }
218
219 /**
220 * @tc.name: OH_ImageReceiverNative_ReleaseTest
221 * @tc.desc: OH_ImageReceiverNative_Release
222 * @tc.type: FUNC
223 */
224 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReleaseTest, TestSize.Level3)
225 {
226 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest start";
227 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
228 ASSERT_NE(pReceiver, nullptr);
229 Image_ErrorCode nRst = OH_ImageReceiverNative_Release(pReceiver);
230 ASSERT_EQ(nRst, IMAGE_SUCCESS);
231 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReleaseTest end";
232 }
233
234 /**
235 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest
236 * @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
237 * @tc.type: FUNC
238 */
239 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest, TestSize.Level3)
240 {
241 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest start";
242 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
243 ASSERT_NE(pReceiver, nullptr);
244 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
245
246 uint64_t nSurfaceId = 0;
247 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(pReceiver, &nSurfaceId);
248 ASSERT_EQ(nRst, IMAGE_SUCCESS);
249 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest end";
250 }
251
252 /**
253 * @tc.name: OH_ImageReceiverNative_ReadLatestImageTest
254 * @tc.desc: OH_ImageReceiverNative_ReadLatestImage
255 * @tc.type: FUNC
256 */
257 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadLatestImageTest, TestSize.Level3)
258 {
259 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest start";
260 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
261 ASSERT_NE(pReceiver, nullptr);
262 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
263
264 OH_ImageNative* pImg = nullptr;
265 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadLatestImage(pReceiver, &pImg);
266 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
267 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest end";
268 }
269
270 /**
271 * @tc.name: OH_ImageReceiverNative_ReadNextImageTest
272 * @tc.desc: OH_ImageReceiverNative_ReadNextImage
273 * @tc.type: FUNC
274 */
275 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadNextImageTest, TestSize.Level3)
276 {
277 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest start";
278 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
279 ASSERT_NE(pReceiver, nullptr);
280 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
281
282 OH_ImageNative* pImg = nullptr;
283 Image_ErrorCode nRst = OH_ImageReceiverNative_ReadNextImage(pReceiver, &pImg);
284 ASSERT_EQ(nRst, IMAGE_UNKNOWN_ERROR);
285 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest end";
286 }
287
288 /**
289 * @tc.name: OH_ImageReceiverNative_OnTest
290 * @tc.desc: OH_ImageReceiverNative_On
291 * @tc.type: FUNC
292 */
OH_ImageReceiver_OnCallback(OH_ImageReceiverNative * receiver)293 static void OH_ImageReceiver_OnCallback(OH_ImageReceiverNative* receiver) {}
294
295 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest, TestSize.Level3)
296 {
297 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest start";
298 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
299 ASSERT_NE(pReceiver, nullptr);
300 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
301
302 Image_ErrorCode nRst = OH_ImageReceiverNative_On(pReceiver, OH_ImageReceiver_OnCallback);
303 ASSERT_EQ(nRst, IMAGE_SUCCESS);
304 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest end";
305 }
306
307 /**
308 * @tc.name: OH_ImageReceiverNative_OffTest
309 * @tc.desc: OH_ImageReceiverNative_Off
310 * @tc.type: FUNC
311 */
312 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffTest, TestSize.Level3)
313 {
314 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest 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_Off(pReceiver);
320 ASSERT_EQ(nRst, IMAGE_SUCCESS);
321 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest end";
322 }
323
324 /**
325 * @tc.name: OH_ImageReceiverNative_GetSizeTest
326 * @tc.desc: OH_ImageReceiverNative_GetSize
327 * @tc.type: FUNC
328 */
329 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest, TestSize.Level3)
330 {
331 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest 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_Size size;
337 Image_ErrorCode nRst = OH_ImageReceiverNative_GetSize(pReceiver, &size);
338 ASSERT_EQ(nRst, IMAGE_SUCCESS);
339 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest end";
340 }
341
342 /**
343 * @tc.name: OH_ImageReceiverNative_GetCapacityTest
344 * @tc.desc: OH_ImageReceiverNative_GetCapacity
345 * @tc.type: FUNC
346 */
347 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest, TestSize.Level3)
348 {
349 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest start";
350 OH_ImageReceiverNative* pReceiver = ImageReceiverNativeTest::CreateReceiver();
351 ASSERT_NE(pReceiver, nullptr);
352 std::shared_ptr<OH_ImageReceiverNative> ptrReceiver(pReceiver, OH_ImageReceiverNative_Release);
353
354 int32_t nCapacity = 0;
355 Image_ErrorCode nRst = OH_ImageReceiverNative_GetCapacity(pReceiver, &nCapacity);
356 ASSERT_EQ(nRst, IMAGE_SUCCESS);
357 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest end";
358 }
359
360 /**
361 @tc.name: OH_ImageReceiverOptions_CreateTest002
362 @tc.desc: OH_ImageReceiverOptions_Create
363 @tc.type: FUNC
364 */
365 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverOptions_CreateTest002, TestSize.Level3)
366 {
367 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 start";
368 OH_ImageReceiverOptions** options = nullptr;
369 Image_ErrorCode nRst = OH_ImageReceiverOptions_Create(options);
370 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
371 OH_ImageReceiverOptions* opt = nullptr;
372 Image_Size size;
373 nRst = OH_ImageReceiverOptions_GetSize(opt, &size);
374 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
375 nRst = OH_ImageReceiverOptions_SetSize(opt, size);
376 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
377 int32_t capacity = 0;
378 nRst = OH_ImageReceiverOptions_GetCapacity(opt, &capacity);
379 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
380 nRst = OH_ImageReceiverOptions_SetCapacity(opt, capacity);
381 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
382 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverOptions_CreateTest002 end";
383 }
384
385 /**
386 @tc.name: OH_ImageReceiverNative_CreateTest002
387 @tc.desc: OH_ImageReceiverNative_Create
388 @tc.type: FUNC
389 */
390 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_CreateTest002, TestSize.Level3)
391 {
392 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 start";
393 OH_ImageReceiverOptions* options = nullptr;
394 OH_ImageReceiverNative* receiver = nullptr;
395 Image_ErrorCode nRst = OH_ImageReceiverNative_Create(options, &receiver);
396 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
397 OH_ImageReceiverOptions_Create(&options);
398 ASSERT_NE(options, nullptr);
399 receiver = ImageReceiverNativeTest::CreateReceiver();
400 ASSERT_NE(receiver, nullptr);
401 ASSERT_NE(&receiver, nullptr);
402 nRst = OH_ImageReceiverNative_Create(options, &receiver);
403 ASSERT_EQ(nRst, IMAGE_SUCCESS);
404 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_CreateTest002 end";
405 }
406
407 /**
408 @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002
409 @tc.desc: OH_ImageReceiverNative_GetReceivingSurfaceId
410 @tc.type: FUNC
411 */
412 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest002, TestSize.Level3)
413 {
414 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 start";
415 OH_ImageReceiverNative* receiver = nullptr;
416 uint64_t* surfaceId = nullptr;
417 Image_ErrorCode nRst = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, surfaceId);
418 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
419 OH_ImageNative** image = nullptr;
420 nRst = OH_ImageReceiverNative_ReadLatestImage(receiver, image);
421 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
422 nRst = OH_ImageReceiverNative_ReadNextImage(receiver, image);
423 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
424 nRst = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
425 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
426 nRst = OH_ImageReceiverNative_Off(receiver);
427 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
428 Image_Size* size = nullptr;
429 nRst = OH_ImageReceiverNative_GetSize(receiver, size);
430 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
431 int32_t* capacity = nullptr;
432 nRst = OH_ImageReceiverNative_GetCapacity(receiver, capacity);
433 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
434 nRst = OH_ImageReceiverNative_Release(receiver);
435 ASSERT_EQ(nRst, IMAGE_BAD_PARAMETER);
436 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest002 end";
437 }
438
439 /**
440 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003
441 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
442 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
443 * @tc.type: FUNC
444 */
445 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest003, TestSize.Level3)
446 {
447 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003 start";
448 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
449 receiver->ptrImgRcv = nullptr;
450 uint64_t surfaceId = 0;
451 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
452 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
453 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest003 end";
454 }
455
456 /**
457 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004
458 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
459 when receiverKey is empty,return IMAGE_UNKNOWN_ERROR
460 * @tc.type: FUNC
461 */
462 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest004, TestSize.Level3)
463 {
464 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004 start";
465 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
466 std::string receiverKey = "";
467 receiver->ptrImgRcv->iraContext_->SetReceiverKey(receiverKey);
468 uint64_t surfaceId = 0;
469 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
470 ASSERT_EQ(ret, IMAGE_UNKNOWN_ERROR);
471 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest004 end";
472 }
473
474 /**
475 * @tc.name: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005
476 * @tc.desc: test the OH_ImageReceiverNative_GetReceivingSurfaceId
477 when receiverKey convert string to uint64_t failed,return IMAGE_UNKNOWN_ERROR
478 * @tc.type: FUNC
479 */
480 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetReceivingSurfaceIdTest005, TestSize.Level3)
481 {
482 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005 start";
483 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
484 std::string receiverKey = "abc";
485 receiver->ptrImgRcv->iraContext_->SetReceiverKey(receiverKey);
486 uint64_t surfaceId = 0;
487 Image_ErrorCode ret = OH_ImageReceiverNative_GetReceivingSurfaceId(receiver, &surfaceId);
488 ASSERT_EQ(ret, IMAGE_UNKNOWN_ERROR);
489 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetReceivingSurfaceIdTest005 end";
490 }
491
492 /**
493 * @tc.name: OH_ImageReceiverNative_ReadLatestImageTest002
494 * @tc.desc: test the OH_ImageReceiverNative_ReadLatestImage
495 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
496 * @tc.type: FUNC
497 */
498 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadLatestImageTest002, TestSize.Level3)
499 {
500 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest002 start";
501 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
502 receiver->ptrImgRcv = nullptr;
503 OH_ImageNative* image = nullptr;
504 Image_ErrorCode ret = OH_ImageReceiverNative_ReadLatestImage(receiver, &image);
505 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
506 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadLatestImageTest002 end";
507 }
508
509 /**
510 * @tc.name: OH_ImageReceiverNative_ReadNextImageTest002
511 * @tc.desc: test the OH_ImageReceiverNative_ReadNextImage
512 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
513 * @tc.type: FUNC
514 */
515 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_ReadNextImageTest002, TestSize.Level3)
516 {
517 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest002 start";
518 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
519 receiver->ptrImgRcv = nullptr;
520 OH_ImageNative* image = nullptr;
521 Image_ErrorCode ret = OH_ImageReceiverNative_ReadNextImage(receiver, &image);
522 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
523 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_ReadNextImageTest002 end";
524 }
525
526 /**
527 * @tc.name: OH_ImageReceiverNative_OnTest002
528 * @tc.desc: test the OH_ImageReceiverNative_On
529 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
530 * @tc.type: FUNC
531 */
532 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OnTest002, TestSize.Level3)
533 {
534 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest002 start";
535 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
536 receiver->ptrImgRcv = nullptr;
537 Image_ErrorCode ret = OH_ImageReceiverNative_On(receiver, OH_ImageReceiver_OnCallback);
538 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
539 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OnTest002 end";
540 }
541
542 /**
543 * @tc.name: OH_ImageReceiverNative_OffTest002
544 * @tc.desc: test the OH_ImageReceiverNative_Off
545 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
546 * @tc.type: FUNC
547 */
548 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_OffTest002, TestSize.Level3)
549 {
550 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest002 start";
551 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
552 receiver->ptrImgRcv = nullptr;
553 Image_ErrorCode ret = OH_ImageReceiverNative_Off(receiver);
554 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
555 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_OffTest002 end";
556 }
557
558 /**
559 * @tc.name: OH_ImageReceiverNative_GetSizeTest002
560 * @tc.desc: test the OH_ImageReceiverNative_GetSize
561 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
562 * @tc.type: FUNC
563 */
564 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetSizeTest002, TestSize.Level3)
565 {
566 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest002 start";
567 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
568 receiver->ptrImgRcv = nullptr;
569 Image_Size size = {1, 1};
570 Image_ErrorCode ret = OH_ImageReceiverNative_GetSize(receiver, &size);
571 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
572 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetSizeTest002 end";
573 }
574
575 /**
576 * @tc.name: OH_ImageReceiverNative_GetCapacityTest002
577 * @tc.desc: test the OH_ImageReceiverNative_GetCapacity
578 when receiver->ptrImgRcv is nullptr,return IMAGE_BAD_PARAMETER
579 * @tc.type: FUNC
580 */
581 HWTEST_F(ImageReceiverNativeTest, OH_ImageReceiverNative_GetCapacityTest002, TestSize.Level3)
582 {
583 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest002 start";
584 OH_ImageReceiverNative* receiver = ImageReceiverNativeTest::CreateReceiver();
585 receiver->ptrImgRcv = nullptr;
586 int32_t capacity = 0;
587 Image_ErrorCode ret = OH_ImageReceiverNative_GetCapacity(receiver, &capacity);
588 ASSERT_EQ(ret, IMAGE_BAD_PARAMETER);
589 GTEST_LOG_(INFO) << "ImageReceiverNativeTest: OH_ImageReceiverNative_GetCapacityTest002 end";
590 }
591 } // namespace Media
592 } // namespace OHOS