1 /*
2 * Copyright (c) 2021-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 <chrono>
17 #include <gtest/gtest.h>
18 #include <memory>
19 #include <thread>
20
21 #define private public
22 #include "dcamera_sink_controller.h"
23 #undef private
24
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28 #include "softbus_common.h"
29 #include "mock_camera_channel.h"
30 #include "mock_camera_operator.h"
31 #include "mock_dcamera_sink_output.h"
32 #include "dcamera_sink_callback.h"
33 #include "dcamera_handler.h"
34 #include "dcamera_metadata_setting_cmd.h"
35 #include "dcamera_sink_access_control.h"
36 #include "dcamera_sink_dev.h"
37 #include "dcamera_utils_tools.h"
38 #include "distributed_camera_errno.h"
39 #include "distributed_hardware_log.h"
40
41 using namespace testing::ext;
42
43 namespace OHOS {
44 namespace DistributedHardware {
45 std::string g_channelStr = "";
46 std::string g_outputStr = "";
47 std::string g_operatorStr = "";
48
49 class DCameraSinkControllerTest : public testing::Test {
50 public:
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp();
54 void TearDown();
55 void SetTokenID();
56
57 std::shared_ptr<DCameraSinkController> controller_;
58 std::shared_ptr<ICameraSinkAccessControl> accessControl_;
59 };
60 std::string g_testDeviceIdController;
61
62 const int32_t SLEEP_TIME_MS = 500;
63 const int32_t TEST_TWENTY_MS = 20000;
64 const std::string SESSION_FLAG_CONTINUE = "dataContinue";
65 const std::string SESSION_FLAG_SNAPSHOT = "dataSnapshot";
66 const std::string TEST_DEVICE_ID_EMPTY = "";
67
68 const std::string TEST_CAPTURE_INFO_CMD_JSON = R"({
69 "Type": "OPERATION",
70 "dhId": "camrea_0",
71 "Command": "CAPTURE",
72 "Value": [
73 {"Width": 1920, "Height": 1080, "Format": 1,
74 "DataSpace": 1, "IsCapture":true, "EncodeType": 1, "StreamType": 1,
75 "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]}
76 ]
77 })";
78
79 const std::string TEST_CHANNEL_INFO_CMD_CONTINUE_JSON = R"({
80 "Type": "OPERATION",
81 "dhId": "camrea_0",
82 "Command": "CHANNEL_NEG",
83 "Value": {"SourceDevId": "TestDevId",
84 "Detail": [{"DataSessionFlag": "dataContinue", "StreamType": 0}]}
85 })";
86
87 const std::string TEST_EVENT_CMD_JSON = R"({
88 "Type": "MESSAGE",
89 "dhId": "camrea_0",
90 "Command": "STATE_NOTIFY",
91 "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"}
92 })";
93
94 const std::string TEST_INFO_CMD_JSON = R"({
95 "Type": "OPERATION",
96 "dhId": "camrea_0",
97 "Command": "GET_INFO",
98 "Value": {"State": 1}
99 })";
100
101 const std::string TEST_METADATA_SETTING_CMD_JSON = R"({
102 "Type": "MESSAGE",
103 "dhId": "camrea_0",
104 "Command": "UPDATE_METADATA",
105 "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}]
106 })";
107
108 const std::string TEST_OPEN_INFO_CMD_JSON = R"({
109 "Type": "OPERATION",
110 "dhId": "camrea_0",
111 "Command": "OPEN_CHANNEL",
112 "Value": {"SourceDevId": "TestDevId" }
113 })";
114
115 std::vector<DCameraIndex> g_testCamIndex;
116
SetUpTestCase(void)117 void DCameraSinkControllerTest::SetUpTestCase(void)
118 {
119 GetLocalDeviceNetworkId(g_testDeviceIdController);
120 DCameraHandler::GetInstance().Initialize();
121 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
122 g_testCamIndex.push_back(DCameraIndex(g_testDeviceIdController, cameras[0]));
123 }
124
TearDownTestCase(void)125 void DCameraSinkControllerTest::TearDownTestCase(void)
126 {
127 }
128
SetUp(void)129 void DCameraSinkControllerTest::SetUp(void)
130 {
131 accessControl_ = std::make_shared<DCameraSinkAccessControl>();
132 sptr<IDCameraSinkCallback> sinkCallback(new DCameraSinkCallback());
133 controller_ = std::make_shared<DCameraSinkController>(accessControl_, sinkCallback);
134
135 DCameraHandler::GetInstance().Initialize();
136 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
137 controller_->channel_ = std::make_shared<MockCameraChannel>();
138 controller_->operator_ = std::make_shared<MockCameraOperator>();
139 controller_->output_ = std::make_shared<MockDCameraSinkOutput>(cameras[0], controller_->operator_);
140 controller_->srcDevId_ = g_testDeviceIdController;
141 controller_->dhId_ = cameras[0];
142 }
143
TearDown(void)144 void DCameraSinkControllerTest::TearDown(void)
145 {
146 accessControl_ = nullptr;
147 controller_ = nullptr;
148 }
149
SetTokenID()150 void DCameraSinkControllerTest::SetTokenID()
151 {
152 uint64_t tokenId;
153 int32_t numberOfPermissions = 2;
154 const char *perms[numberOfPermissions];
155 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
156 perms[1] = "ohos.permission.CAMERA";
157 NativeTokenInfoParams infoInstance = {
158 .dcapsNum = 0,
159 .permsNum = numberOfPermissions,
160 .aclsNum = 0,
161 .dcaps = NULL,
162 .perms = perms,
163 .acls = NULL,
164 .processName = "dcamera_client_demo",
165 .aplStr = "system_basic",
166 };
167 tokenId = GetAccessTokenId(&infoInstance);
168 SetSelfTokenID(tokenId);
169 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
170 }
171
172 /**
173 * @tc.name: dcamera_sink_controller_test_001
174 * @tc.desc: Verify the Init and UnInit function.
175 * @tc.type: FUNC
176 * @tc.require: AR000GK6MV
177 */
178 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_001, TestSize.Level1)
179 {
180 int32_t ret = controller_->Init(g_testCamIndex);
181 EXPECT_NE(DCAMERA_OK, ret);
182 EXPECT_EQ(true, controller_->isInit_);
183
184 ret = controller_->UnInit();
185 EXPECT_EQ(DCAMERA_OK, ret);
186 EXPECT_EQ(false, controller_->isInit_);
187 }
188
189 /**
190 * @tc.name: dcamera_sink_controller_test_002
191 * @tc.desc: Verify the GetCameraInfo function.
192 * @tc.type: FUNC
193 * @tc.require: AR000GK6MT
194 */
195 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_002, TestSize.Level1)
196 {
197 DCameraInfoCmd cmd;
198 cmd.value_ = std::make_shared<DCameraInfo>();
199 int32_t ret = controller_->GetCameraInfo(cmd.value_);
200 EXPECT_EQ(DCAMERA_OK, ret);
201 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
202 }
203
204 /**
205 * @tc.name: dcamera_sink_controller_test_003
206 * @tc.desc: Verify the ChannelNeg function.
207 * @tc.type: FUNC
208 * @tc.require: AR000GK6MT
209 */
210 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_003, TestSize.Level1)
211 {
212 DCameraChannelInfoCmd cmd;
213 cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_CONTINUE_JSON);
214 int32_t ret = controller_->ChannelNeg(cmd.value_);
215 EXPECT_EQ(DCAMERA_OK, ret);
216 }
217
218 /**
219 * @tc.name: dcamera_sink_controller_test_004
220 * @tc.desc: Verify the StartCapture function.
221 * @tc.type: FUNC
222 * @tc.require: AR000GK6MU
223 */
224 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_004, TestSize.Level1)
225 {
226 DCameraCaptureInfoCmd cmd;
227 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
228 int32_t mode = 0;
229 int32_t ret = controller_->StartCapture(cmd.value_, mode);
230 EXPECT_EQ(DCAMERA_OK, ret);
231 }
232
233 /**
234 * @tc.name: dcamera_sink_controller_test_005
235 * @tc.desc: Verify the UpdateSettings function.
236 * @tc.type: FUNC
237 * @tc.require: AR000GK6N1
238 */
239 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.Level1)
240 {
241 SetTokenID();
242 DCameraCaptureInfoCmd cmd;
243 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
244 int32_t mode = 0;
245 int32_t ret = controller_->StartCapture(cmd.value_, mode);
246 EXPECT_EQ(DCAMERA_OK, ret);
247
248 DCameraMetadataSettingCmd cmdMetadata;
249 cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON);
250 ret = controller_->UpdateSettings(cmdMetadata.value_);
251 controller_->OnMetadataResult(cmdMetadata.value_);
252 g_channelStr = "test005";
253 controller_->OnMetadataResult(cmdMetadata.value_);
254 std::vector<std::shared_ptr<DCameraSettings>> settings;
255 controller_->OnMetadataResult(settings);
256 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
257 }
258
259 /**
260 * @tc.name: dcamera_sink_controller_test_006
261 * @tc.desc: Verify the StopCapture function.
262 * @tc.type: FUNC
263 * @tc.require: AR000GK6N1
264 */
265 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_006, TestSize.Level1)
266 {
267 DCameraCaptureInfoCmd cmd;
268 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
269 int32_t mode = 0;
270 int32_t ret = controller_->StartCapture(cmd.value_, mode);
271 EXPECT_EQ(DCAMERA_OK, ret);
272
273 ret = controller_->StopCapture();
274 EXPECT_EQ(DCAMERA_OK, ret);
275 }
276
277 /**
278 * @tc.name: dcamera_sink_controller_test_007
279 * @tc.desc: Verify the DCameraNotify function.
280 * @tc.type: FUNC
281 * @tc.require: AR000GK6MT
282 */
283 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_007, TestSize.Level1)
284 {
285 controller_->srcDevId_ = TEST_DEVICE_ID_EMPTY;
286
287 DCameraEventCmd cmd;
288 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
289 int32_t ret = controller_->DCameraNotify(cmd.value_);
290 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
291 }
292
293 /**
294 * @tc.name: dcamera_sink_controller_test_008
295 * @tc.desc: Verify the DCameraNotify function.
296 * @tc.type: FUNC
297 * @tc.require: AR000GK6MT
298 */
299 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.Level1)
300 {
301 DCameraEventCmd cmd;
302 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
303 int32_t ret = controller_->DCameraNotify(cmd.value_);
304 EXPECT_NE(DCAMERA_OK, ret);
305 }
306
307 /**
308 * @tc.name: dcamera_sink_controller_test_009
309 * @tc.desc: Verify the OnSessionState and GetCameraInfo function.
310 * @tc.type: FUNC
311 * @tc.require: AR000GK6MT
312 */
313 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.Level1)
314 {
315 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING, "");
316
317 DCameraInfoCmd cmd;
318 cmd.value_ = std::make_shared<DCameraInfo>();
319 int32_t ret = controller_->GetCameraInfo(cmd.value_);
320 EXPECT_EQ(DCAMERA_OK, ret);
321 int32_t state = -1;
322 controller_->OnSessionState(state, "");
323
324 int32_t eventType = 1;
325 int32_t eventReason = 0;
326 std::string detail = "detail";
327 controller_->OnSessionError(eventType, eventReason, detail);
328 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTING, cmd.value_->state_);
329 }
330
331 /**
332 * @tc.name: dcamera_sink_controller_test_010
333 * @tc.desc: Verify the OnSessionState function.
334 * @tc.type: FUNC
335 * @tc.require: AR000GK6N1
336 */
337 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.Level1)
338 {
339 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED, "");
340
341 DCameraInfoCmd cmd;
342 cmd.value_ = std::make_shared<DCameraInfo>();
343 int32_t ret = controller_->GetCameraInfo(cmd.value_);
344 EXPECT_EQ(DCAMERA_OK, ret);
345 size_t capacity = 1;
346 std::vector<std::shared_ptr<DataBuffer>> buffers;
347 controller_->OnDataReceived(buffers);
348 std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
349 buffers.push_back(dataBuffer);
350 controller_->OnDataReceived(buffers);
351 buffers.clear();
352 capacity = controller_->DATABUFF_MAX_SIZE + 1;
353 dataBuffer = std::make_shared<DataBuffer>(capacity);
354 buffers.push_back(dataBuffer);
355 controller_->OnDataReceived(buffers);
356 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
357 }
358
359 /**
360 * @tc.name: dcamera_sink_controller_test_011
361 * @tc.desc: Verify the OnSessionState function.
362 * @tc.type: FUNC
363 * @tc.require: AR000GK6N1
364 */
365 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.Level1)
366 {
367 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED, "");
368 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
369
370 DCameraInfoCmd cmd;
371 cmd.value_ = std::make_shared<DCameraInfo>();
372 int32_t ret = controller_->GetCameraInfo(cmd.value_);
373 EXPECT_EQ(DCAMERA_OK, ret);
374 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
375 }
376
377 /**
378 * @tc.name: dcamera_sink_controller_test_012
379 * @tc.desc: Verify the OpenChannel function.
380 * @tc.type: FUNC
381 * @tc.require: AR000GK6N1
382 */
383 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.Level1)
384 {
385 SetTokenID();
386 DCameraOpenInfoCmd cmd;
387 cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
388 int32_t ret = controller_->OpenChannel(cmd.value_);
389 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
390 }
391
392 /**
393 * @tc.name: dcamera_sink_controller_test_013
394 * @tc.desc: Verify the OpenChannel function.
395 * @tc.type: FUNC
396 * @tc.require: AR000GK6N1
397 */
398 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, TestSize.Level1)
399 {
400 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED, "");
401
402 DCameraInfoCmd cmd;
403 cmd.value_ = std::make_shared<DCameraInfo>();
404 int32_t ret = controller_->GetCameraInfo(cmd.value_);
405 EXPECT_EQ(DCAMERA_OK, ret);
406 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
407
408 DCameraOpenInfoCmd cmdOpenInfo;
409 cmdOpenInfo.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
410 ret = controller_->OpenChannel(cmdOpenInfo.value_);
411 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
412 }
413
414 /**
415 * @tc.name: dcamera_sink_controller_test_014
416 * @tc.desc: Verify the CloseChannel function.
417 * @tc.type: FUNC
418 * @tc.require: AR000GK6N1
419 */
420 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.Level1)
421 {
422 int32_t ret = controller_->CloseChannel();
423 EXPECT_EQ(DCAMERA_OK, ret);
424 controller_->isPageStatus_.store(true);
425 sptr<IDCameraSinkCallback> sinkCallback(new DCameraSinkCallback());
426 EXPECT_EQ(true, controller_->isPageStatus_.load());
427 controller_->sinkCallback_ = sinkCallback;
428 ret = controller_->CloseChannel();
429 EXPECT_EQ(DCAMERA_OK, ret);
430 }
431
432 /**
433 * @tc.name: dcamera_sink_controller_test_015
434 * @tc.desc: Verify the UpdateSettings function.
435 * @tc.type: FUNC
436 * @tc.require: AR000GK6N1
437 */
438 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_015, TestSize.Level1)
439 {
440 SetTokenID();
441 DCameraCaptureInfoCmd cmd;
442 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
443 int32_t mode = 0;
444 int32_t ret = controller_->StartCapture(cmd.value_, mode);
445 EXPECT_EQ(DCAMERA_OK, ret);
446
447 DCameraMetadataSettingCmd cmdMetadata;
448 cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON);
449 g_operatorStr = "test015";
450 ret = controller_->UpdateSettings(cmdMetadata.value_);
451 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
452 }
453
454 /**
455 * @tc.name: dcamera_sink_controller_test_016
456 * @tc.desc: Verify the OpenChannel function.
457 * @tc.type: FUNC
458 * @tc.require: AR000GK6N1
459 */
460 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_016, TestSize.Level1)
461 {
462 SetTokenID();
463 DCameraOpenInfoCmd cmd;
464 cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
465 g_channelStr = "test016";
466 int32_t ret = controller_->OpenChannel(cmd.value_);
467 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
468 }
469
470 /**
471 * @tc.name: dcamera_sink_controller_test_017
472 * @tc.desc: Verify the CloseChannel function.
473 * @tc.type: FUNC
474 * @tc.require: AR000GK6N1
475 */
476 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_017, TestSize.Level1)
477 {
478 g_channelStr = "test017";
479 int32_t ret = controller_->CloseChannel();
480 EXPECT_EQ(DCAMERA_OK, ret);
481 }
482
483 /**
484 * @tc.name: dcamera_sink_controller_test_018
485 * @tc.desc: Verify the CloseChannel function.
486 * @tc.type: FUNC
487 * @tc.require: AR000GK6N1
488 */
489 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_018, TestSize.Level1)
490 {
491 g_outputStr = "test018";
492 int32_t ret = controller_->CloseChannel();
493 EXPECT_EQ(DCAMERA_OK, ret);
494 }
495
496 /**
497 * @tc.name: dcamera_sink_controller_test_019
498 * @tc.desc: Verify the Init and UnInit function.
499 * @tc.type: FUNC
500 * @tc.require: AR000GK6MV
501 */
502 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_019, TestSize.Level1)
503 {
504 g_outputStr = "test019";
505 int32_t ret = controller_->UnInit();
506 EXPECT_EQ(DCAMERA_OK, ret);
507 }
508
509 /**
510 * @tc.name: dcamera_sink_controller_test_020
511 * @tc.desc: Verify the Init and UnInit function.
512 * @tc.type: FUNC
513 * @tc.require: AR000GK6MV
514 */
515 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_020, TestSize.Level1)
516 {
517 g_operatorStr = "test020";
518 int32_t ret = controller_->UnInit();
519 EXPECT_EQ(DCAMERA_OK, ret);
520 }
521
522 /**
523 * @tc.name: dcamera_sink_controller_test_021
524 * @tc.desc: Verify the StartCapture function.
525 * @tc.type: FUNC
526 * @tc.require: AR000GK6MU
527 */
528 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_021, TestSize.Level1)
529 {
530 DCameraCaptureInfoCmd cmd;
531 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
532 g_outputStr = "test021";
533 int32_t mode = 0;
534 int32_t ret = controller_->StartCapture(cmd.value_, mode);
535 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
536 }
537
538 /**
539 * @tc.name: dcamera_sink_controller_test_022
540 * @tc.desc: Verify the StartCapture function.
541 * @tc.type: FUNC
542 * @tc.require: AR000GK6MU
543 */
544 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_022, TestSize.Level1)
545 {
546 DCameraCaptureInfoCmd cmd;
547 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
548 g_outputStr = "";
549 g_operatorStr = "test022";
550 int32_t mode = 0;
551 int32_t ret = controller_->StartCapture(cmd.value_, mode);
552 EXPECT_EQ(DCAMERA_ALLOC_ERROR, ret);
553 }
554
555 /**
556 * @tc.name: dcamera_sink_controller_test_023
557 * @tc.desc: Verify the StartCapture function.
558 * @tc.type: FUNC
559 * @tc.require: AR000GK6MU
560 */
561 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_023, TestSize.Level1)
562 {
563 DCameraCaptureInfoCmd cmd;
564 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
565 g_operatorStr = "test023";
566 int32_t mode = 0;
567 int32_t ret = controller_->StartCapture(cmd.value_, mode);
568 EXPECT_EQ(DCAMERA_DEVICE_BUSY, ret);
569 }
570
571 /**
572 * @tc.name: dcamera_sink_controller_test_024
573 * @tc.desc: Verify the PullUpPage function.
574 * @tc.type: FUNC
575 * @tc.require: AR000GK6MU
576 */
577 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_024, TestSize.Level1)
578 {
579 g_operatorStr = "test024";
580 controller_->isSensitive_ = false;
581 EXPECT_EQ(false, controller_->isSensitive_);
582 usleep(TEST_TWENTY_MS);
583 }
584
585 /**
586 * @tc.name: dcamera_sink_controller_test_025
587 * @tc.desc: Verify the PullUpPage function.
588 * @tc.type: FUNC
589 * @tc.require: AR000GK6MU
590 */
591 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_025, TestSize.Level1)
592 {
593 sptr<IDCameraSinkCallback> sinkCallback(new DCameraSinkCallback());
594 EXPECT_NE(nullptr, sinkCallback);
595 controller_->isSensitive_ = true;
596 controller_->sinkCallback_ = sinkCallback;
597
598 controller_->Init(g_testCamIndex);
599 EXPECT_NE(nullptr, controller_->sinkCotrEventHandler_);
600 std::shared_ptr<std::string> param = std::make_shared<std::string>("");
601 AppExecFwk::InnerEvent::Pointer event =
602 AppExecFwk::InnerEvent::Get(EVENT_FRAME_TRIGGER, param, 0);
603 controller_->sinkCotrEventHandler_->ProcessEvent(event);
604 std::shared_ptr<std::vector<std::shared_ptr<DCameraCaptureInfo>>> infos =
605 std::make_shared<std::vector<std::shared_ptr<DCameraCaptureInfo>>>();
606 AppExecFwk::InnerEvent::Pointer authorizationEvent =
607 AppExecFwk::InnerEvent::Get(EVENT_AUTHORIZATION, infos, 0);
608 controller_->PostAuthorization(*infos);
609 g_outputStr = "test_025";
610 controller_->PostAuthorization(*infos);
611 g_outputStr = "";
612 controller_->sinkCotrEventHandler_->ProcessEvent(authorizationEvent);
613 event = AppExecFwk::InnerEvent::Get(0, param, 0);
614 controller_->sinkCotrEventHandler_->ProcessEvent(event);
615 usleep(TEST_TWENTY_MS);
616 }
617
618 /**
619 * @tc.name: dcamera_sink_controller_test_026
620 * @tc.desc: Verify the Init and UnInit function.
621 * @tc.type: FUNC
622 * @tc.require: AR000GK6MV
623 */
624 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_026, TestSize.Level1)
625 {
626 g_outputStr = "test026";
627 auto outputMock = std::make_shared<MockDCameraSinkOutput>("camera_1", nullptr);
628 EXPECT_NE(DCAMERA_OK, outputMock->Init());
629 usleep(TEST_TWENTY_MS);
630 }
631
632 /**
633 * @tc.name: dcamera_sink_controller_test_027
634 * @tc.desc: Verify the Init and UnInit function.
635 * @tc.type: FUNC
636 * @tc.require: AR000GK6MV
637 */
638 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_027, TestSize.Level1)
639 {
640 g_operatorStr ="test027";
641 EXPECT_EQ(DCAMERA_OK, controller_->UnInit());
642 }
643
644 /**
645 * @tc.name: dcamera_sink_controller_test_028
646 * @tc.desc: Verify HandleReceivedData function.
647 * @tc.type: FUNC
648 * @tc.require: AR000GK6MV
649 */
650 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_028, TestSize.Level1)
651 {
652 size_t capacity = 1;
653 std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
654 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->HandleReceivedData(dataBuffer));
655 }
656
657 /**
658 * @tc.name: dcamera_sink_controller_test_029
659 * @tc.desc: Verify PauseDistributedHardware function.
660 * @tc.type: FUNC
661 * @tc.require: AR000GK6MV
662 */
663 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_029, TestSize.Level1)
664 {
665 std::string netId = "";
666 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId));
667 netId = "netId";
668 EXPECT_EQ(DCAMERA_OK, controller_->PauseDistributedHardware(netId));
669 g_operatorStr = "test029";
670 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId));
671 g_operatorStr = "";
672 controller_->operator_ = nullptr;
673 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId));
674 }
675
676 /**
677 * @tc.name: dcamera_sink_controller_test_030
678 * @tc.desc: Verify ResumeDistributedHardware function.
679 * @tc.type: FUNC
680 * @tc.require: AR000GK6MV
681 */
682 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_030, TestSize.Level1)
683 {
684 std::string netId = "";
685 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId));
686 netId = "netId";
687 EXPECT_EQ(DCAMERA_OK, controller_->ResumeDistributedHardware(netId));
688 g_operatorStr = "test030";
689 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId));
690 g_operatorStr = "";
691 controller_->operator_ = nullptr;
692 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId));
693 }
694
695 /**
696 * @tc.name: dcamera_sink_controller_test_031
697 * @tc.desc: Verify StopDistributedHardware function.
698 * @tc.type: FUNC
699 * @tc.require: AR000GK6MV
700 */
701 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_031, TestSize.Level1)
702 {
703 std::string netId = "";
704 EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->StopDistributedHardware(netId));
705 netId = "netId";
706 EXPECT_NE(DCAMERA_OK, controller_->StopDistributedHardware(netId));
707 }
708
709 /**
710 * @tc.name: dcamera_sink_controller_test_032
711 * @tc.desc: Verify CheckDeviceSecurityLevel function.
712 * @tc.type: FUNC
713 * @tc.require: AR000GK6MV
714 */
715 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_032, TestSize.Level1)
716 {
717 std::string srcNetId = "";
718 std::string dstNetId = "";
719 EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId));
720 }
721
722 /**
723 * @tc.name: dcamera_sink_controller_test_033
724 * @tc.desc: Verify GetDeviceSecurityLevel function.
725 * @tc.type: FUNC
726 * @tc.require: AR000GK6MV
727 */
728 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_033, TestSize.Level1)
729 {
730 std::string udId = "";
731 EXPECT_NE(DCAMERA_OK, controller_->GetDeviceSecurityLevel(udId));
732 }
733
734 /**
735 * @tc.name: dcamera_sink_controller_test_034
736 * @tc.desc: Verify GetUdidByNetworkId function.
737 * @tc.type: FUNC
738 * @tc.require: AR000GK6MV
739 */
740 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_034, TestSize.Level1)
741 {
742 std::string netId = "";
743 EXPECT_EQ("", controller_->GetUdidByNetworkId(netId));
744 netId = "netId";
745 EXPECT_EQ("", controller_->GetUdidByNetworkId(netId));
746 }
747 } // namespace DistributedHardware
748 } // namespace OHOS