1 /*
2 * Copyright (c) 2025 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
18 #include "dcamera_host.h"
19 #include "dcamera_test_utils.h"
20 #include "v1_0/icamera_device_callback.h"
21 #include "v1_0/icamera_host_callback.h"
22 #include "v1_2/icamera_host_callback.h"
23 #include "iremote_object.h"
24 #include "distributed_hardware_log.h"
25
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace DistributedHardware {
30 class DCameraHostTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp(void);
35 void TearDown(void);
36 };
37
38 class MockCameraHostCallback : public HDI::Camera::V1_0::ICameraHostCallback {
39 public:
40 MockCameraHostCallback() = default;
41 ~MockCameraHostCallback() override = default;
OnCameraStatus(const std::string & cameraId,CameraStatus status)42 int32_t OnCameraStatus(const std::string &cameraId, CameraStatus status) override
43 {
44 return 0;
45 }
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)46 int32_t OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) override
47 {
48 return 0;
49 }
OnCameraEvent(const std::string & cameraId,CameraEvent event)50 int32_t OnCameraEvent(const std::string &cameraId, CameraEvent event) override
51 {
52 return 0;
53 }
54 };
55
56 class MockCameraHostCallbackV12 : public HDI::Camera::V1_2::ICameraHostCallback {
57 public:
58 MockCameraHostCallbackV12() = default;
59 ~MockCameraHostCallbackV12() override = default;
OnCameraStatus(const std::string & cameraId,CameraStatus status)60 int32_t OnCameraStatus(const std::string &cameraId, CameraStatus status) override
61 {
62 return 0;
63 }
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)64 int32_t OnFlashlightStatus(const std::string &cameraId, FlashlightStatus status) override
65 {
66 return 0;
67 }
OnCameraEvent(const std::string & cameraId,CameraEvent event)68 int32_t OnCameraEvent(const std::string &cameraId, CameraEvent event) override
69 {
70 return 0;
71 }
OnFlashlightStatus_V1_2(FlashlightStatus status)72 int32_t OnFlashlightStatus_V1_2(FlashlightStatus status) override
73 {
74 return 0;
75 }
76 };
77
78 class MockCameraDeviceCallback : public ICameraDeviceCallback {
79 public:
80 MockCameraDeviceCallback() = default;
81 ~MockCameraDeviceCallback() override = default;
OnError(ErrorType type,int32_t errorCode)82 int32_t OnError(ErrorType type, int32_t errorCode) override
83 {
84 return 0;
85 }
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)86 int32_t OnResult(uint64_t timestamp, const std::vector<uint8_t> &result) override
87 {
88 return 0;
89 }
90 };
91
92 class MockIRemoteObject : public IRemoteObject {
93 public:
MockIRemoteObject()94 MockIRemoteObject() : IRemoteObject {u"MockIRemoteObject"}
95 {
96 }
97
~MockIRemoteObject()98 ~MockIRemoteObject()
99 {
100 }
101
GetObjectRefCount()102 int32_t GetObjectRefCount()
103 {
104 return 0;
105 }
106
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)107 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
108 {
109 return 0;
110 }
111
IsProxyObject() const112 bool IsProxyObject() const
113 {
114 return true;
115 }
116
CheckObjectLegality() const117 bool CheckObjectLegality() const
118 {
119 return true;
120 }
121
AddDeathRecipient(const sptr<DeathRecipient> & recipient)122 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient)
123 {
124 return true;
125 }
126
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)127 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient)
128 {
129 return true;
130 }
131
AsInterface()132 sptr<IRemoteBroker> AsInterface()
133 {
134 return nullptr;
135 }
136
Dump(int fd,const std::vector<std::u16string> & args)137 int Dump(int fd, const std::vector<std::u16string> &args)
138 {
139 return 0;
140 }
141 };
142
143 class MockDeathRecipient : public IRemoteObject::DeathRecipient {
144 public:
OnRemoteDied(const wptr<IRemoteObject> & remote)145 void OnRemoteDied(const wptr<IRemoteObject> &remote)
146 {}
147 };
148
149 namespace {
150 constexpr const char* TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
151 const uint32_t ID_MAX_SIZE = 2 * DEVID_MAX_LENGTH;
152 const uint32_t ABILITYINFO_MAX_LENGTH = 50 * 1024 * 1024;
153 const size_t MAX_DCAMERAS_NUMBER = 32;
154 }
155
SetUpTestCase(void)156 void DCameraHostTest::SetUpTestCase(void)
157 {
158 }
159
TearDownTestCase(void)160 void DCameraHostTest::TearDownTestCase(void)
161 {
162 }
163
SetUp(void)164 void DCameraHostTest::SetUp(void)
165 {
166 }
167
TearDown(void)168 void DCameraHostTest::TearDown(void)
169 {
170 }
171
172 /**
173 * @tc.name: RegisterCameraHdfListener_001
174 * @tc.desc: Verify RegisterCameraHdfListener
175 * @tc.type: FUNC
176 * @tc.require: AR
177 */
178 HWTEST_F(DCameraHostTest, RegisterCameraHdfListener_001, TestSize.Level1)
179 {
180 sptr<IDCameraHdfCallback> callback = nullptr;
181 EXPECT_EQ(DCamRetCode::INVALID_ARGUMENT,
182 DCameraHost::GetInstance()->RegisterCameraHdfListener(TEST_DEVICE_ID, callback));
183 }
184
185 /**
186 * @tc.name: UnRegisterCameraHdfListener_001
187 * @tc.desc: Verify UnRegisterCameraHdfListener
188 * @tc.type: FUNC
189 * @tc.require: AR
190 */
191 HWTEST_F(DCameraHostTest, UnRegisterCameraHdfListener_001, TestSize.Level1)
192 {
193 EXPECT_EQ(DCamRetCode::FAILED, DCameraHost::GetInstance()->UnRegisterCameraHdfListener(TEST_DEVICE_ID));
194 }
195
196 /**
197 * @tc.name: SetCallback_001
198 * @tc.desc: Verify SetCallback
199 * @tc.type: FUNC
200 * @tc.require: AR
201 */
202 HWTEST_F(DCameraHostTest, SetCallback_001, TestSize.Level1)
203 {
204 sptr<HDI::Camera::V1_0::ICameraHostCallback> nullCallback = nullptr;
205 int32_t ret = DCameraHost::GetInstance()->SetCallback(nullCallback);
206 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
207
208 sptr<HDI::Camera::V1_2::ICameraHostCallback> callback = nullptr;
209 ret = DCameraHost::GetInstance()->SetCallback_V1_2(callback);
210 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
211 }
212
213 /**
214 * @tc.name: SetCallback_002
215 * @tc.desc: Verify SetCallback
216 * @tc.type: FUNC
217 * @tc.require: AR
218 */
219 HWTEST_F(DCameraHostTest, SetCallback_002, TestSize.Level1)
220 {
221 sptr<HDI::Camera::V1_0::ICameraHostCallback> callback = sptr<MockCameraHostCallback>(
222 new (std::nothrow) MockCameraHostCallback());
223 int32_t ret = DCameraHost::GetInstance()->SetCallback(callback);
224 EXPECT_EQ(ret, CamRetCode::NO_ERROR);
225
226 sptr<HDI::Camera::V1_2::ICameraHostCallback> callbackV1_2 = sptr<MockCameraHostCallbackV12>(
227 new (std::nothrow) MockCameraHostCallbackV12());
228 ret = DCameraHost::GetInstance()->SetCallback_V1_2(callbackV1_2);
229 EXPECT_EQ(ret, CamRetCode::NO_ERROR);
230 }
231
232 /**
233 * @tc.name: GetCameraIds_001
234 * @tc.desc: Verify the GetCameraIds function when no camera devices.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(DCameraHostTest, GetCameraIds_001, TestSize.Level1)
238 {
239 std::vector<std::string> cameraIds;
240 int32_t ret = DCameraHost::GetInstance()->GetCameraIds(cameraIds);
241 EXPECT_EQ(ret, CamRetCode::NO_ERROR);
242 EXPECT_TRUE(cameraIds.empty());
243 }
244
245 /**
246 * @tc.name: GetCameraAbility_001
247 * @tc.desc: Verify the GetCameraAbility function with invalid cameraId.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(DCameraHostTest, GetCameraAbility_001, TestSize.Level1)
251 {
252 std::string invalidCameraId = "";
253 std::vector<uint8_t> cameraAbility;
254 int32_t ret = DCameraHost::GetInstance()->GetCameraAbility(invalidCameraId, cameraAbility);
255 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
256 }
257
258 /**
259 * @tc.name: GetCameraAbility_002
260 * @tc.desc: Verify the GetCameraAbility function with non-existent cameraId.
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DCameraHostTest, GetCameraAbility_002, TestSize.Level1)
264 {
265 std::string nonExistentCameraId = "non_existent_camera_id";
266 std::vector<uint8_t> cameraAbility;
267 int32_t ret = DCameraHost::GetInstance()->GetCameraAbility(nonExistentCameraId, cameraAbility);
268 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
269 }
270
271 /**
272 * @tc.name: OpenCamera_001
273 * @tc.desc: Verify the OpenCamera function with invalid parameters.
274 * @tc.type: FUNC
275 */
276 HWTEST_F(DCameraHostTest, OpenCamera_001, TestSize.Level1)
277 {
278 std::string invalidCameraId = "";
279 sptr<HDI::Camera::V1_0::ICameraDeviceCallback> nullCallback = nullptr;
280 sptr<HDI::Camera::V1_0::ICameraDevice> device = nullptr;
281
282 int32_t ret = DCameraHost::GetInstance()->OpenCamera(invalidCameraId, nullCallback, device);
283 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
284 }
285
286 /**
287 * @tc.name: OpenCamera_002
288 * @tc.desc: Verify the OpenCamera function with non-existent camera.
289 * @tc.type: FUNC
290 */
291 HWTEST_F(DCameraHostTest, OpenCamera_002, TestSize.Level1)
292 {
293 std::string nonExistentCameraId = "non_existent_camera";
294 sptr<MockCameraDeviceCallback> mockCallback = sptr<MockCameraDeviceCallback>(
295 new (std::nothrow) MockCameraDeviceCallback());
296 sptr<HDI::Camera::V1_0::ICameraDevice> device = nullptr;
297
298 int32_t ret = DCameraHost::GetInstance()->OpenCamera(nonExistentCameraId, mockCallback, device);
299 EXPECT_EQ(ret, CamRetCode::INVALID_ARGUMENT);
300 }
301
302 /**
303 * @tc.name: AddDCameraDevice_001
304 * @tc.desc: Verify the AddDCameraDevice function with invalid DHBase.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(DCameraHostTest, AddDCameraDevice_001, TestSize.Level1)
308 {
309 DHBase invalidDhBase = { "test001", "test001" };
310 std::string sinkAbilityInfo = "test_sink_info";
311 std::string sourceCodecInfo = "test_codec_info";
312 sptr<IDCameraProviderCallback> nullCallback = nullptr;
313
314 DCamRetCode ret = DCameraHost::GetInstance()->AddDCameraDevice(invalidDhBase, sinkAbilityInfo,
315 sourceCodecInfo, nullCallback);
316 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
317
318 std::vector<std::string> cameraIds;
319 int32_t val = DCameraHost::GetInstance()->GetCameraIds(cameraIds);
320 EXPECT_EQ(val, CamRetCode::NO_ERROR);
321
322 std::string cameraId = "test001__test001";
323 std::vector<uint8_t> cameraAbility;
324 val = DCameraHost::GetInstance()->GetCameraAbility(cameraId, cameraAbility);
325 EXPECT_EQ(val, CamRetCode::INVALID_ARGUMENT);
326
327 sptr<MockCameraDeviceCallback> mockCallback = sptr<MockCameraDeviceCallback>(
328 new (std::nothrow) MockCameraDeviceCallback());
329 sptr<HDI::Camera::V1_0::ICameraDevice> device = nullptr;
330
331 val = DCameraHost::GetInstance()->OpenCamera(cameraId, mockCallback, device);
332 EXPECT_EQ(val, CamRetCode::INVALID_ARGUMENT);
333
334 ret = DCameraHost::GetInstance()->RemoveDCameraDevice(invalidDhBase);
335 EXPECT_EQ(ret, DCamRetCode::SUCCESS);
336 }
337
338 /**
339 * @tc.name: AddDCameraDevice_002
340 * @tc.desc: Verify the AddDCameraDevice function with empty sinkAbilityInfo.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(DCameraHostTest, AddDCameraDevice_002, TestSize.Level1)
344 {
345 DHBase dhBase = { "test_dev_id", "test_dh_id" };
346 std::string emptySinkAbilityInfo = "";
347 std::string sourceCodecInfo = "test_codec_info";
348 sptr<IDCameraProviderCallback> nullCallback = nullptr;
349
350 DCamRetCode ret = DCameraHost::GetInstance()->AddDCameraDevice(dhBase, emptySinkAbilityInfo,
351 sourceCodecInfo, nullCallback);
352 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
353 }
354
355 /**
356 * @tc.name: RemoveDCameraDevice_001
357 * @tc.desc: Verify the RemoveDCameraDevice function with invalid DHBase.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(DCameraHostTest, RemoveDCameraDevice_001, TestSize.Level1)
361 {
362 DHBase invalidDhBase = { "", "" };
363 DCamRetCode ret = DCameraHost::GetInstance()->RemoveDCameraDevice(invalidDhBase);
364 EXPECT_EQ(ret, DCamRetCode::SUCCESS);
365 }
366
367 /**
368 * @tc.name: IsCameraIdInvalid_001
369 * @tc.desc: Verify the IsCameraIdInvalid function with empty cameraId.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(DCameraHostTest, IsCameraIdInvalid_001, TestSize.Level1)
373 {
374 std::string emptyCameraId = "";
375 bool ret = DCameraHost::GetInstance()->IsCameraIdInvalid(emptyCameraId);
376 EXPECT_TRUE(ret);
377 }
378
379 /**
380 * @tc.name: IsCameraIdInvalid_002
381 * @tc.desc: Verify the IsCameraIdInvalid function with too long cameraId.
382 * @tc.type: FUNC
383 */
384 HWTEST_F(DCameraHostTest, IsCameraIdInvalid_002, TestSize.Level1)
385 {
386 std::string longCameraId(ID_MAX_SIZE + 1, 'a');
387 bool ret = DCameraHost::GetInstance()->IsCameraIdInvalid(longCameraId);
388 EXPECT_TRUE(ret);
389 }
390
391 /**
392 * @tc.name: UnsupportedMethods_001
393 * @tc.desc: Verify unsupported methods return METHOD_NOT_SUPPORTED.
394 * @tc.type: FUNC
395 */
396 HWTEST_F(DCameraHostTest, UnsupportedMethods_001, TestSize.Level1)
397 {
398 std::string cameraId = "camera_001";
399 OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost resourceCost;
400 int32_t ret = DCameraHost::GetInstance()->GetResourceCost(cameraId, resourceCost);
401 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
402
403 ret = DCameraHost::GetInstance()->NotifyDeviceStateChangeInfo(0, 0);
404 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
405
406 ret = DCameraHost::GetInstance()->SetFlashlight("test_camera", true);
407 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
408
409 ret = DCameraHost::GetInstance()->SetFlashlight_V1_2(0.0f);
410 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
411
412 ret = DCameraHost::GetInstance()->PreCameraSwitch("test_camera");
413 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
414
415 PrelaunchConfig config;
416 ret = DCameraHost::GetInstance()->PrelaunchWithOpMode(config, 0);
417 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
418
419 ret = DCameraHost::GetInstance()->Prelaunch(config);
420 EXPECT_EQ(ret, CamRetCode::METHOD_NOT_SUPPORTED);
421 }
422
423 /**
424 * @tc.name: AddDeviceParamCheck_001
425 * @tc.desc: Verify AddDeviceParamCheck.
426 * @tc.type: FUNC
427 */
428 HWTEST_F(DCameraHostTest, AddDeviceParamCheck_001, TestSize.Level1)
429 {
430 DHBase dhBase = { "", "" };
431 std::string sinkAbilityInfo = "test_sink_info";
432 std::string sourceCodecInfo = "test_codec_info";
433 sptr<IDCameraProviderCallback> nullCallback = nullptr;
434 DCamRetCode ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
435 sourceCodecInfo, nullCallback);
436 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
437 }
438
439 /**
440 * @tc.name: AddDeviceParamCheck_002
441 * @tc.desc: Verify AddDeviceParamCheck.
442 * @tc.type: FUNC
443 */
444 HWTEST_F(DCameraHostTest, AddDeviceParamCheck_002, TestSize.Level1)
445 {
446 DHBase dhBase = { "test_device_id", "test_dh_id" };
447 std::string sinkAbilityInfo = "";
448 std::string sourceCodecInfo = "";
449 sptr<IDCameraProviderCallback> nullCallback = nullptr;
450 DCamRetCode ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
451 sourceCodecInfo, nullCallback);
452 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
453
454 std::string longSinkInfo(ABILITYINFO_MAX_LENGTH + 1, 'a');
455 ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, longSinkInfo,
456 sourceCodecInfo, nullCallback);
457 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
458
459 sinkAbilityInfo = "test_sink_info";
460 ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
461 sourceCodecInfo, nullCallback);
462 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
463
464 std::string longCodecInfo(ABILITYINFO_MAX_LENGTH + 1, 'a');
465 ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
466 longCodecInfo, nullCallback);
467 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
468 }
469
470 /**
471 * @tc.name: AddDeviceParamCheck_003
472 * @tc.desc: Verify AddDeviceParamCheck.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(DCameraHostTest, AddDeviceParamCheck_003, TestSize.Level1)
476 {
477 DHBase dhBase = { "test_device_id", "test_dh_id" };
478 std::string sinkAbilityInfo = "test_sink_info";
479 std::string sourceCodecInfo = "test_codec_info";
480 sptr<IDCameraProviderCallback> nullCallback = nullptr;
481 for (size_t i = 0; i < MAX_DCAMERAS_NUMBER + 1; ++i) {
482 DCameraHost::GetInstance()->dCameraDeviceMap_["camera" + std::to_string(i)] = nullptr;
483 }
484 DCamRetCode ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
485 sourceCodecInfo, nullCallback);
486 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
487 DCameraHost::GetInstance()->dCameraDeviceMap_.clear();
488 }
489
490 /**
491 * @tc.name: AddDeviceParamCheck_004
492 * @tc.desc: Verify AddDeviceParamCheck.
493 * @tc.type: FUNC
494 */
495 HWTEST_F(DCameraHostTest, AddDeviceParamCheck_004, TestSize.Level1)
496 {
497 DHBase dhBase = { "test_device_id", "test_dh_id" };
498 std::string sinkAbilityInfo = "test_sink_info";
499 std::string sourceCodecInfo = "test_codec_info";
500 sptr<IDCameraProviderCallback> nullCallback = nullptr;
501 DCamRetCode ret = DCameraHost::GetInstance()->AddDeviceParamCheck(dhBase, sinkAbilityInfo,
502 sourceCodecInfo, nullCallback);
503 EXPECT_EQ(ret, DCamRetCode::SUCCESS);
504
505 DCameraHost::GetInstance()->NotifyDCameraStatus(dhBase, 0);
506 }
507
508 /**
509 * @tc.name: AddClearRegisterRecipient_001
510 * @tc.desc: Verify AddClearRegisterRecipient.
511 * @tc.type: FUNC
512 */
513 HWTEST_F(DCameraHostTest, AddClearRegisterRecipient_001, TestSize.Level1)
514 {
515 DHLOGI("AddClearRegisterRecipient_001");
516 DHBase dhBase = { "test_device_id", "test_dh_id" };
517 sptr<IRemoteObject> remote = nullptr;
518 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
519 EXPECT_EQ(result, DCamRetCode::SUCCESS);
520 }
521
522 /**
523 * @tc.name: AddClearRegisterRecipient_002
524 * @tc.desc: Verify AddClearRegisterRecipient.
525 * @tc.type: FUNC
526 */
527 HWTEST_F(DCameraHostTest, AddClearRegisterRecipient_002, TestSize.Level1)
528 {
529 DHLOGI("AddClearRegisterRecipient_002");
530 DHBase dhBase = { "test_device_id", "test_dh_id" };
531 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
532 ASSERT_NE(remote, nullptr);
533 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
534 EXPECT_EQ(result, DCamRetCode::SUCCESS);
535 }
536
537 /**
538 * @tc.name: AddClearRegisterRecipient_003
539 * @tc.desc: Verify AddClearRegisterRecipient.
540 * @tc.type: FUNC
541 */
542 HWTEST_F(DCameraHostTest, AddClearRegisterRecipient_003, TestSize.Level1)
543 {
544 DHLOGI("AddClearRegisterRecipient_003");
545 DHBase dhBase = { "test_device_id", "test_dh_id" };
546 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
547 ASSERT_NE(remote, nullptr);
548 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
549 EXPECT_EQ(result, DCamRetCode::SUCCESS);
550 }
551
552 /**
553 * @tc.name: RemoveClearRegisterRecipient_001
554 * @tc.desc: Verify RemoveClearRegisterRecipient.
555 * @tc.type: FUNC
556 */
557 HWTEST_F(DCameraHostTest, RemoveClearRegisterRecipient_001, TestSize.Level1)
558 {
559 DHLOGI("RemoveClearRegisterRecipient_001");
560 DHBase dhBase = { "test_device_id", "test_dh_id" };
561 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
562 ASSERT_NE(remote, nullptr);
563 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
564
565 remote = nullptr;
566 result = DCameraHost::GetInstance()->RemoveClearRegisterRecipient(remote, dhBase);
567 EXPECT_EQ(result, DCamRetCode::SUCCESS);
568 }
569
570 /**
571 * @tc.name: RemoveClearRegisterRecipient_002
572 * @tc.desc: Verify RemoveClearRegisterRecipient.
573 * @tc.type: FUNC
574 */
575 HWTEST_F(DCameraHostTest, RemoveClearRegisterRecipient_002, TestSize.Level1)
576 {
577 DHLOGI("RemoveClearRegisterRecipient_002");
578 DHBase dhBase = { "test_device_id", "test_dh_id" };
579 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
580 ASSERT_NE(remote, nullptr);
581 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
582
583 sptr<IRemoteObject> nullRemote = nullptr;
584 result = DCameraHost::GetInstance()->RemoveClearRegisterRecipient(nullRemote, dhBase);
585 EXPECT_EQ(result, DCamRetCode::SUCCESS);
586 }
587
588 /**
589 * @tc.name: RemoveClearRegisterRecipient_003
590 * @tc.desc: Verify RemoveClearRegisterRecipient.
591 * @tc.type: FUNC
592 */
593 HWTEST_F(DCameraHostTest, RemoveClearRegisterRecipient_003, TestSize.Level1)
594 {
595 DHLOGI("RemoveClearRegisterRecipient_003");
596 DHBase dhBase = { "test_device_id", "test_dh_id" };
597 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
598 ASSERT_NE(remote, nullptr);
599 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
600
601 result = DCameraHost::GetInstance()->RemoveClearRegisterRecipient(remote, dhBase);
602 EXPECT_EQ(result, DCamRetCode::SUCCESS);
603 }
604
605 /**
606 * @tc.name: RemoveClearRegisterRecipient_004
607 * @tc.desc: Verify RemoveClearRegisterRecipient.
608 * @tc.type: FUNC
609 */
610 HWTEST_F(DCameraHostTest, RemoveClearRegisterRecipient_004, TestSize.Level1)
611 {
612 DHLOGI("RemoveClearRegisterRecipient_004");
613 DHBase dhBase = { "test_device_id", "test_dh_id" };
614 sptr<IRemoteObject> remote = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
615 ASSERT_NE(remote, nullptr);
616 int32_t result = DCameraHost::GetInstance()->AddClearRegisterRecipient(remote, dhBase);
617
618 DHBase dhBase2 = { "device_id", "dh_id" };
619 result = DCameraHost::GetInstance()->RemoveClearRegisterRecipient(remote, dhBase2);
620 EXPECT_EQ(result, DCamRetCode::SUCCESS);
621 }
622 }
623 }