1 /*
2 * Copyright (c) 2021 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 class DCameraSinkControllerTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 void SetTokenID();
55
56 std::shared_ptr<DCameraSinkController> controller_;
57 std::shared_ptr<ICameraSinkAccessControl> accessControl_;
58 };
59 std::string g_testDeviceIdController;
60
61 const int32_t SLEEP_TIME_MS = 500;
62 const std::string SESSION_FLAG_CONTINUE = "dataContinue";
63 const std::string SESSION_FLAG_SNAPSHOT = "dataSnapshot";
64 const std::string TEST_DEVICE_ID_EMPTY = "";
65
66 const std::string TEST_CAPTURE_INFO_CMD_JSON = R"({
67 "Type": "OPERATION",
68 "dhId": "camrea_0",
69 "Command": "CAPTURE",
70 "Value": [
71 {"Width": 1920, "Height": 1080, "Format": 1,
72 "DataSpace": 1, "IsCapture":true, "EncodeType": 1, "StreamType": 1,
73 "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]}
74 ]
75 })";
76
77 const std::string TEST_CHANNEL_INFO_CMD_CONTINUE_JSON = R"({
78 "Type": "OPERATION",
79 "dhId": "camrea_0",
80 "Command": "CHANNEL_NEG",
81 "Value": {"SourceDevId": "TestDevId",
82 "Detail": [{"DataSessionFlag": "dataContinue", "StreamType": 0}]}
83 })";
84
85 const std::string TEST_EVENT_CMD_JSON = R"({
86 "Type": "MESSAGE",
87 "dhId": "camrea_0",
88 "Command": "STATE_NOTIFY",
89 "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"}
90 })";
91
92 const std::string TEST_INFO_CMD_JSON = R"({
93 "Type": "OPERATION",
94 "dhId": "camrea_0",
95 "Command": "GET_INFO",
96 "Value": {"State": 1}
97 })";
98
99 const std::string TEST_METADATA_SETTING_CMD_JSON = R"({
100 "Type": "MESSAGE",
101 "dhId": "camrea_0",
102 "Command": "UPDATE_METADATA",
103 "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}]
104 })";
105
106 const std::string TEST_OPEN_INFO_CMD_JSON = R"({
107 "Type": "OPERATION",
108 "dhId": "camrea_0",
109 "Command": "OPEN_CHANNEL",
110 "Value": {"SourceDevId": "TestDevId" }
111 })";
112
113 std::vector<DCameraIndex> g_testCamIndex;
114
SetUpTestCase(void)115 void DCameraSinkControllerTest::SetUpTestCase(void)
116 {
117 GetLocalDeviceNetworkId(g_testDeviceIdController);
118 DCameraHandler::GetInstance().Initialize();
119 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
120 g_testCamIndex.push_back(DCameraIndex(g_testDeviceIdController, cameras[0]));
121 }
122
TearDownTestCase(void)123 void DCameraSinkControllerTest::TearDownTestCase(void)
124 {
125 }
126
SetUp(void)127 void DCameraSinkControllerTest::SetUp(void)
128 {
129 accessControl_ = std::make_shared<DCameraSinkAccessControl>();
130 sptr<IDCameraSinkCallback> sinkCallback(new DCameraSinkCallback());
131 controller_ = std::make_shared<DCameraSinkController>(accessControl_, sinkCallback);
132
133 DCameraHandler::GetInstance().Initialize();
134 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
135 controller_->channel_ = std::make_shared<MockCameraChannel>();
136 controller_->operator_ = std::make_shared<MockCameraOperator>();
137 controller_->output_ = std::make_shared<MockDCameraSinkOutput>(cameras[0], controller_->operator_);
138 controller_->srcDevId_ = g_testDeviceIdController;
139 controller_->dhId_ = cameras[0];
140 }
141
TearDown(void)142 void DCameraSinkControllerTest::TearDown(void)
143 {
144 accessControl_ = nullptr;
145 controller_ = nullptr;
146 }
147
SetTokenID()148 void DCameraSinkControllerTest::SetTokenID()
149 {
150 uint64_t tokenId;
151 int32_t numberOfPermissions = 2;
152 const char *perms[numberOfPermissions];
153 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
154 perms[1] = "ohos.permission.CAMERA";
155 NativeTokenInfoParams infoInstance = {
156 .dcapsNum = 0,
157 .permsNum = numberOfPermissions,
158 .aclsNum = 0,
159 .dcaps = NULL,
160 .perms = perms,
161 .acls = NULL,
162 .processName = "dcamera_client_demo",
163 .aplStr = "system_basic",
164 };
165 tokenId = GetAccessTokenId(&infoInstance);
166 SetSelfTokenID(tokenId);
167 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
168 }
169
170 /**
171 * @tc.name: dcamera_sink_controller_test_001
172 * @tc.desc: Verify the Init and UnInit function.
173 * @tc.type: FUNC
174 * @tc.require: AR000GK6MV
175 */
176 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_001, TestSize.Level1)
177 {
178 int32_t ret = controller_->Init(g_testCamIndex);
179 EXPECT_EQ(DCAMERA_OK, ret);
180 EXPECT_EQ(true, controller_->isInit_);
181
182 ret = controller_->UnInit();
183 EXPECT_EQ(DCAMERA_OK, ret);
184 EXPECT_EQ(false, controller_->isInit_);
185 }
186
187 /**
188 * @tc.name: dcamera_sink_controller_test_002
189 * @tc.desc: Verify the GetCameraInfo function.
190 * @tc.type: FUNC
191 * @tc.require: AR000GK6MT
192 */
193 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_002, TestSize.Level1)
194 {
195 DCameraInfoCmd cmd;
196 cmd.value_ = std::make_shared<DCameraInfo>();
197 int32_t ret = controller_->GetCameraInfo(cmd.value_);
198 EXPECT_EQ(DCAMERA_OK, ret);
199 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
200 }
201
202 /**
203 * @tc.name: dcamera_sink_controller_test_003
204 * @tc.desc: Verify the ChannelNeg function.
205 * @tc.type: FUNC
206 * @tc.require: AR000GK6MT
207 */
208 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_003, TestSize.Level1)
209 {
210 DCameraChannelInfoCmd cmd;
211 cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_CONTINUE_JSON);
212 int32_t ret = controller_->ChannelNeg(cmd.value_);
213 EXPECT_EQ(DCAMERA_OK, ret);
214 }
215
216 /**
217 * @tc.name: dcamera_sink_controller_test_004
218 * @tc.desc: Verify the StartCapture function.
219 * @tc.type: FUNC
220 * @tc.require: AR000GK6MU
221 */
222 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_004, TestSize.Level1)
223 {
224 DCameraCaptureInfoCmd cmd;
225 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
226 int32_t ret = controller_->StartCapture(cmd.value_);
227 EXPECT_EQ(DCAMERA_OK, ret);
228 }
229
230 /**
231 * @tc.name: dcamera_sink_controller_test_005
232 * @tc.desc: Verify the UpdateSettings function.
233 * @tc.type: FUNC
234 * @tc.require: AR000GK6N1
235 */
236 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.Level1)
237 {
238 SetTokenID();
239 DCameraCaptureInfoCmd cmd;
240 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
241 int32_t ret = controller_->StartCapture(cmd.value_);
242 EXPECT_EQ(DCAMERA_OK, ret);
243
244 DCameraMetadataSettingCmd cmdMetadata;
245 cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON);
246 ret = controller_->UpdateSettings(cmdMetadata.value_);
247 controller_->OnMetadataResult(cmdMetadata.value_);
248 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
249 }
250
251 /**
252 * @tc.name: dcamera_sink_controller_test_006
253 * @tc.desc: Verify the StopCapture function.
254 * @tc.type: FUNC
255 * @tc.require: AR000GK6N1
256 */
257 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_006, TestSize.Level1)
258 {
259 DCameraCaptureInfoCmd cmd;
260 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
261 int32_t ret = controller_->StartCapture(cmd.value_);
262 EXPECT_EQ(DCAMERA_OK, ret);
263
264 ret = controller_->StopCapture();
265 EXPECT_EQ(DCAMERA_OK, ret);
266 }
267
268 /**
269 * @tc.name: dcamera_sink_controller_test_007
270 * @tc.desc: Verify the DCameraNotify function.
271 * @tc.type: FUNC
272 * @tc.require: AR000GK6MT
273 */
274 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_007, TestSize.Level1)
275 {
276 controller_->srcDevId_ = TEST_DEVICE_ID_EMPTY;
277
278 DCameraEventCmd cmd;
279 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
280 int32_t ret = controller_->DCameraNotify(cmd.value_);
281 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
282 }
283
284 /**
285 * @tc.name: dcamera_sink_controller_test_008
286 * @tc.desc: Verify the DCameraNotify function.
287 * @tc.type: FUNC
288 * @tc.require: AR000GK6MT
289 */
290 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.Level1)
291 {
292 DCameraEventCmd cmd;
293 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
294 int32_t ret = controller_->DCameraNotify(cmd.value_);
295 EXPECT_NE(DCAMERA_OK, ret);
296 }
297
298 /**
299 * @tc.name: dcamera_sink_controller_test_009
300 * @tc.desc: Verify the OnSessionState and GetCameraInfo function.
301 * @tc.type: FUNC
302 * @tc.require: AR000GK6MT
303 */
304 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.Level1)
305 {
306 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING);
307
308 DCameraInfoCmd cmd;
309 cmd.value_ = std::make_shared<DCameraInfo>();
310 int32_t ret = controller_->GetCameraInfo(cmd.value_);
311 EXPECT_EQ(DCAMERA_OK, ret);
312 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTING, cmd.value_->state_);
313 }
314
315 /**
316 * @tc.name: dcamera_sink_controller_test_010
317 * @tc.desc: Verify the OnSessionState function.
318 * @tc.type: FUNC
319 * @tc.require: AR000GK6N1
320 */
321 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.Level1)
322 {
323 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
324
325 DCameraInfoCmd cmd;
326 cmd.value_ = std::make_shared<DCameraInfo>();
327 int32_t ret = controller_->GetCameraInfo(cmd.value_);
328 EXPECT_EQ(DCAMERA_OK, ret);
329 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
330 }
331
332 /**
333 * @tc.name: dcamera_sink_controller_test_011
334 * @tc.desc: Verify the OnSessionState function.
335 * @tc.type: FUNC
336 * @tc.require: AR000GK6N1
337 */
338 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.Level1)
339 {
340 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED);
341 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
342
343 DCameraInfoCmd cmd;
344 cmd.value_ = std::make_shared<DCameraInfo>();
345 int32_t ret = controller_->GetCameraInfo(cmd.value_);
346 EXPECT_EQ(DCAMERA_OK, ret);
347 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
348 }
349
350 /**
351 * @tc.name: dcamera_sink_controller_test_012
352 * @tc.desc: Verify the OpenChannel function.
353 * @tc.type: FUNC
354 * @tc.require: AR000GK6N1
355 */
356 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.Level1)
357 {
358 SetTokenID();
359 DCameraOpenInfoCmd cmd;
360 cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
361 int32_t ret = controller_->OpenChannel(cmd.value_);
362 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
363 }
364
365 /**
366 * @tc.name: dcamera_sink_controller_test_013
367 * @tc.desc: Verify the OpenChannel function.
368 * @tc.type: FUNC
369 * @tc.require: AR000GK6N1
370 */
371 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, TestSize.Level1)
372 {
373 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
374
375 DCameraInfoCmd cmd;
376 cmd.value_ = std::make_shared<DCameraInfo>();
377 int32_t ret = controller_->GetCameraInfo(cmd.value_);
378 EXPECT_EQ(DCAMERA_OK, ret);
379 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
380
381 DCameraOpenInfoCmd cmdOpenInfo;
382 cmdOpenInfo.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
383 ret = controller_->OpenChannel(cmdOpenInfo.value_);
384 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
385 }
386
387 /**
388 * @tc.name: dcamera_sink_controller_test_014
389 * @tc.desc: Verify the CloseChannel function.
390 * @tc.type: FUNC
391 * @tc.require: AR000GK6N1
392 */
393 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.Level1)
394 {
395 int32_t ret = controller_->CloseChannel();
396 EXPECT_EQ(DCAMERA_OK, ret);
397 }
398
399 /**
400 * @tc.name: dcamera_sink_controller_test_015
401 * @tc.desc: Verify the UpdateSettings function.
402 * @tc.type: FUNC
403 * @tc.require: AR000GK6N1
404 */
405 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_015, TestSize.Level1)
406 {
407 SetTokenID();
408 DCameraCaptureInfoCmd cmd;
409 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
410 int32_t ret = controller_->StartCapture(cmd.value_);
411 EXPECT_EQ(DCAMERA_OK, ret);
412
413 DCameraMetadataSettingCmd cmdMetadata;
414 cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON);
415 g_operatorStr = "test015";
416 ret = controller_->UpdateSettings(cmdMetadata.value_);
417 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
418 }
419
420 /**
421 * @tc.name: dcamera_sink_controller_test_016
422 * @tc.desc: Verify the OpenChannel function.
423 * @tc.type: FUNC
424 * @tc.require: AR000GK6N1
425 */
426 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_016, TestSize.Level1)
427 {
428 SetTokenID();
429 DCameraOpenInfoCmd cmd;
430 cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
431 g_channelStr = "test016";
432 int32_t ret = controller_->OpenChannel(cmd.value_);
433 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
434 }
435
436 /**
437 * @tc.name: dcamera_sink_controller_test_017
438 * @tc.desc: Verify the CloseChannel function.
439 * @tc.type: FUNC
440 * @tc.require: AR000GK6N1
441 */
442 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_017, TestSize.Level1)
443 {
444 g_channelStr = "test017";
445 int32_t ret = controller_->CloseChannel();
446 EXPECT_EQ(DCAMERA_OK, ret);
447 }
448
449 /**
450 * @tc.name: dcamera_sink_controller_test_018
451 * @tc.desc: Verify the CloseChannel function.
452 * @tc.type: FUNC
453 * @tc.require: AR000GK6N1
454 */
455 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_018, TestSize.Level1)
456 {
457 g_outputStr = "test018";
458 int32_t ret = controller_->CloseChannel();
459 EXPECT_EQ(DCAMERA_OK, ret);
460 }
461
462 /**
463 * @tc.name: dcamera_sink_controller_test_019
464 * @tc.desc: Verify the Init and UnInit function.
465 * @tc.type: FUNC
466 * @tc.require: AR000GK6MV
467 */
468 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_019, TestSize.Level1)
469 {
470 g_outputStr = "test019";
471 int32_t ret = controller_->UnInit();
472 EXPECT_EQ(DCAMERA_OK, ret);
473 }
474
475 /**
476 * @tc.name: dcamera_sink_controller_test_020
477 * @tc.desc: Verify the Init and UnInit function.
478 * @tc.type: FUNC
479 * @tc.require: AR000GK6MV
480 */
481 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_020, TestSize.Level1)
482 {
483 g_operatorStr = "test020";
484 int32_t ret = controller_->UnInit();
485 EXPECT_EQ(DCAMERA_OK, ret);
486 }
487
488 /**
489 * @tc.name: dcamera_sink_controller_test_021
490 * @tc.desc: Verify the StartCapture function.
491 * @tc.type: FUNC
492 * @tc.require: AR000GK6MU
493 */
494 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_021, TestSize.Level1)
495 {
496 DCameraCaptureInfoCmd cmd;
497 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
498 g_outputStr = "test021";
499 int32_t ret = controller_->StartCapture(cmd.value_);
500 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
501 }
502
503 /**
504 * @tc.name: dcamera_sink_controller_test_022
505 * @tc.desc: Verify the StartCapture function.
506 * @tc.type: FUNC
507 * @tc.require: AR000GK6MU
508 */
509 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_022, TestSize.Level1)
510 {
511 DCameraCaptureInfoCmd cmd;
512 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
513 g_outputStr = "";
514 g_operatorStr = "test022";
515 int32_t ret = controller_->StartCapture(cmd.value_);
516 EXPECT_EQ(DCAMERA_ALLOC_ERROR, ret);
517 }
518
519 /**
520 * @tc.name: dcamera_sink_controller_test_023
521 * @tc.desc: Verify the StartCapture function.
522 * @tc.type: FUNC
523 * @tc.require: AR000GK6MU
524 */
525 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_023, TestSize.Level1)
526 {
527 DCameraCaptureInfoCmd cmd;
528 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
529 g_operatorStr = "test023";
530 int32_t ret = controller_->StartCapture(cmd.value_);
531 EXPECT_EQ(DCAMERA_DEVICE_BUSY, ret);
532 }
533 } // namespace DistributedHardware
534 } // namespace OHOS