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 "mock_camera_channel.h"
26 #include "mock_camera_operator.h"
27 #include "mock_dcamera_sink_output.h"
28
29 #include "dcamera_handler.h"
30 #include "dcamera_metadata_setting_cmd.h"
31 #include "dcamera_sink_access_control.h"
32 #include "dcamera_sink_dev.h"
33 #include "dcamera_utils_tools.h"
34 #include "distributed_camera_errno.h"
35 #include "distributed_hardware_log.h"
36
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace DistributedHardware {
41 class DCameraSinkControllerTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47
48 std::shared_ptr<DCameraSinkController> controller_;
49 std::shared_ptr<ICameraSinkAccessControl> accessControl_;
50 };
51 std::string g_testDeviceIdController;
52
53 const int32_t SLEEP_TIME_MS = 500;
54 const std::string SESSION_FLAG_CONTINUE = "dataContinue";
55 const std::string SESSION_FLAG_SNAPSHOT = "dataSnapshot";
56 const std::string TEST_DEVICE_ID_EMPTY = "";
57
58 const std::string TEST_CAPTURE_INFO_CMD_JSON = R"({
59 "Type": "OPERATION",
60 "dhId": "camrea_0",
61 "Command": "CAPTURE",
62 "Value": [
63 {"Width": 1920, "Height": 1080, "Format": 1,
64 "DataSpace": 1, "IsCapture":true, "EncodeType": 1, "StreamType": 1,
65 "CaptureSettings": [{"SettingType": 1, "SettingValue": "TestSetting"}]}
66 ]
67 })";
68
69 const std::string TEST_CHANNEL_INFO_CMD_CONTINUE_JSON = R"({
70 "Type": "OPERATION",
71 "dhId": "camrea_0",
72 "Command": "CHANNEL_NEG",
73 "Value": {"SourceDevId": "TestDevId",
74 "Detail": [{"DataSessionFlag": "dataContinue", "StreamType": 0}]}
75 })";
76
77 const std::string TEST_EVENT_CMD_JSON = R"({
78 "Type": "MESSAGE",
79 "dhId": "camrea_0",
80 "Command": "STATE_NOTIFY",
81 "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"}
82 })";
83
84 const std::string TEST_INFO_CMD_JSON = R"({
85 "Type": "OPERATION",
86 "dhId": "camrea_0",
87 "Command": "GET_INFO",
88 "Value": {"State": 1}
89 })";
90
91 const std::string TEST_METADATA_SETTING_CMD_JSON = R"({
92 "Type": "MESSAGE",
93 "dhId": "camrea_0",
94 "Command": "UPDATE_METADATA",
95 "Value": [{"SettingType": 1, "SettingValue": "TestSetting"}]
96 })";
97
98 const std::string TEST_OPEN_INFO_CMD_JSON = R"({
99 "Type": "OPERATION",
100 "dhId": "camrea_0",
101 "Command": "OPEN_CHANNEL",
102 "Value": {"SourceDevId": "TestDevId" }
103 })";
104
105 std::vector<DCameraIndex> g_testCamIndex;
106
SetUpTestCase(void)107 void DCameraSinkControllerTest::SetUpTestCase(void)
108 {
109 GetLocalDeviceNetworkId(g_testDeviceIdController);
110 DCameraHandler::GetInstance().Initialize();
111 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
112 g_testCamIndex.push_back(DCameraIndex(g_testDeviceIdController, cameras[0]));
113 }
114
TearDownTestCase(void)115 void DCameraSinkControllerTest::TearDownTestCase(void)
116 {
117 }
118
SetUp(void)119 void DCameraSinkControllerTest::SetUp(void)
120 {
121 accessControl_ = std::make_shared<DCameraSinkAccessControl>();
122 controller_ = std::make_shared<DCameraSinkController>(accessControl_);
123
124 DCameraHandler::GetInstance().Initialize();
125 std::vector<std::string> cameras = DCameraHandler::GetInstance().GetCameras();
126 controller_->channel_ = std::make_shared<MockCameraChannel>();
127 controller_->operator_ = std::make_shared<MockCameraOperator>();
128 controller_->output_ = std::make_shared<MockDCameraSinkOutput>(cameras[0], controller_->operator_);
129 controller_->srcDevId_ = g_testDeviceIdController;
130 controller_->dhId_ = cameras[0];
131 }
132
TearDown(void)133 void DCameraSinkControllerTest::TearDown(void)
134 {
135 accessControl_ = nullptr;
136 controller_ = nullptr;
137 }
138
139 /**
140 * @tc.name: dcamera_sink_controller_test_001
141 * @tc.desc: Verify the Init and UnInit function.
142 * @tc.type: FUNC
143 * @tc.require: AR000GK6MV
144 */
145 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_001, TestSize.Level1)
146 {
147 int32_t ret = controller_->Init(g_testCamIndex);
148 EXPECT_EQ(DCAMERA_OK, ret);
149 EXPECT_EQ(true, controller_->isInit_);
150
151 ret = controller_->UnInit();
152 EXPECT_EQ(DCAMERA_OK, ret);
153 EXPECT_EQ(false, controller_->isInit_);
154 }
155
156 /**
157 * @tc.name: dcamera_sink_controller_test_002
158 * @tc.desc: Verify the GetCameraInfo function.
159 * @tc.type: FUNC
160 * @tc.require: AR000GK6MT
161 */
162 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_002, TestSize.Level1)
163 {
164 DCameraInfoCmd cmd;
165 cmd.value_ = std::make_shared<DCameraInfo>();
166 int32_t ret = controller_->GetCameraInfo(cmd.value_);
167 EXPECT_EQ(DCAMERA_OK, ret);
168 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
169 }
170
171 /**
172 * @tc.name: dcamera_sink_controller_test_003
173 * @tc.desc: Verify the ChannelNeg function.
174 * @tc.type: FUNC
175 * @tc.require: AR000GK6MT
176 */
177 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_003, TestSize.Level1)
178 {
179 DCameraChannelInfoCmd cmd;
180 cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_CONTINUE_JSON);
181 int32_t ret = controller_->ChannelNeg(cmd.value_);
182 EXPECT_EQ(DCAMERA_OK, ret);
183 }
184
185 /**
186 * @tc.name: dcamera_sink_controller_test_004
187 * @tc.desc: Verify the StartCapture function.
188 * @tc.type: FUNC
189 * @tc.require: AR000GK6MU
190 */
191 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_004, TestSize.Level1)
192 {
193 DCameraCaptureInfoCmd cmd;
194 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
195 int32_t ret = controller_->StartCapture(cmd.value_);
196 EXPECT_EQ(DCAMERA_OK, ret);
197 }
198
199 /**
200 * @tc.name: dcamera_sink_controller_test_005
201 * @tc.desc: Verify the UpdateSettings function.
202 * @tc.type: FUNC
203 * @tc.require: AR000GK6N1
204 */
205 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.Level1)
206 {
207 DCameraCaptureInfoCmd cmd;
208 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
209 int32_t ret = controller_->StartCapture(cmd.value_);
210 EXPECT_EQ(DCAMERA_OK, ret);
211
212 DCameraMetadataSettingCmd cmdMetadata;
213 cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON);
214 ret = controller_->UpdateSettings(cmdMetadata.value_);
215 EXPECT_EQ(DCAMERA_OK, ret);
216 }
217
218 /**
219 * @tc.name: dcamera_sink_controller_test_006
220 * @tc.desc: Verify the StopCapture function.
221 * @tc.type: FUNC
222 * @tc.require: AR000GK6N1
223 */
224 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_006, TestSize.Level1)
225 {
226 DCameraCaptureInfoCmd cmd;
227 cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON);
228 int32_t ret = controller_->StartCapture(cmd.value_);
229 EXPECT_EQ(DCAMERA_OK, ret);
230
231 ret = controller_->StopCapture();
232 EXPECT_EQ(DCAMERA_OK, ret);
233 }
234
235 /**
236 * @tc.name: dcamera_sink_controller_test_007
237 * @tc.desc: Verify the DCameraNotify function.
238 * @tc.type: FUNC
239 * @tc.require: AR000GK6MT
240 */
241 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_007, TestSize.Level1)
242 {
243 controller_->srcDevId_ = TEST_DEVICE_ID_EMPTY;
244
245 DCameraEventCmd cmd;
246 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
247 int32_t ret = controller_->DCameraNotify(cmd.value_);
248 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
249 }
250
251 /**
252 * @tc.name: dcamera_sink_controller_test_008
253 * @tc.desc: Verify the DCameraNotify function.
254 * @tc.type: FUNC
255 * @tc.require: AR000GK6MT
256 */
257 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.Level1)
258 {
259 DCameraEventCmd cmd;
260 cmd.Unmarshal(TEST_EVENT_CMD_JSON);
261 int32_t ret = controller_->DCameraNotify(cmd.value_);
262 EXPECT_NE(DCAMERA_OK, ret);
263 }
264
265 /**
266 * @tc.name: dcamera_sink_controller_test_009
267 * @tc.desc: Verify the OnSessionState and GetCameraInfo function.
268 * @tc.type: FUNC
269 * @tc.require: AR000GK6MT
270 */
271 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.Level1)
272 {
273 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING);
274
275 DCameraInfoCmd cmd;
276 cmd.value_ = std::make_shared<DCameraInfo>();
277 int32_t ret = controller_->GetCameraInfo(cmd.value_);
278 EXPECT_EQ(DCAMERA_OK, ret);
279 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTING, cmd.value_->state_);
280 }
281
282 /**
283 * @tc.name: dcamera_sink_controller_test_010
284 * @tc.desc: Verify the OnSessionState function.
285 * @tc.type: FUNC
286 * @tc.require: AR000GK6N1
287 */
288 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.Level1)
289 {
290 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
291
292 DCameraInfoCmd cmd;
293 cmd.value_ = std::make_shared<DCameraInfo>();
294 int32_t ret = controller_->GetCameraInfo(cmd.value_);
295 EXPECT_EQ(DCAMERA_OK, ret);
296 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
297 }
298
299 /**
300 * @tc.name: dcamera_sink_controller_test_011
301 * @tc.desc: Verify the OnSessionState function.
302 * @tc.type: FUNC
303 * @tc.require: AR000GK6N1
304 */
305 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.Level1)
306 {
307 controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED);
308 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
309
310 DCameraInfoCmd cmd;
311 cmd.value_ = std::make_shared<DCameraInfo>();
312 int32_t ret = controller_->GetCameraInfo(cmd.value_);
313 EXPECT_EQ(DCAMERA_OK, ret);
314 EXPECT_EQ(DCAMERA_CHANNEL_STATE_DISCONNECTED, cmd.value_->state_);
315 }
316
317 /**
318 * @tc.name: dcamera_sink_controller_test_012
319 * @tc.desc: Verify the OpenChannel function.
320 * @tc.type: FUNC
321 * @tc.require: AR000GK6N1
322 */
323 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.Level1)
324 {
325 DCameraOpenInfoCmd cmd;
326 cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
327 int32_t ret = controller_->OpenChannel(cmd.value_);
328 EXPECT_EQ(DCAMERA_OK, ret);
329 }
330
331 /**
332 * @tc.name: dcamera_sink_controller_test_013
333 * @tc.desc: Verify the OpenChannel function.
334 * @tc.type: FUNC
335 * @tc.require: AR000GK6N1
336 */
337 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, 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 EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_);
346
347 DCameraOpenInfoCmd cmdOpenInfo;
348 cmdOpenInfo.Unmarshal(TEST_OPEN_INFO_CMD_JSON);
349 ret = controller_->OpenChannel(cmdOpenInfo.value_);
350 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
351 }
352
353 /**
354 * @tc.name: dcamera_sink_controller_test_014
355 * @tc.desc: Verify the CloseChannel function.
356 * @tc.type: FUNC
357 * @tc.require: AR000GK6N1
358 */
359 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.Level1)
360 {
361 int32_t ret = controller_->CloseChannel();
362 EXPECT_EQ(DCAMERA_OK, ret);
363 }
364 } // namespace DistributedHardware
365 } // namespace OHOS