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