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 <gtest/gtest.h>
17 #include <memory>
18 #define private public
19 #include "dcamera_source_state.h"
20 #undef private
21
22 #include "dcamera_source_capture_state.h"
23 #include "dcamera_source_config_stream_state.h"
24 #include "dcamera_source_init_state.h"
25 #include "dcamera_source_opened_state.h"
26 #include "dcamera_source_regist_state.h"
27 #include "dcamera_source_state_factory.h"
28 #include "dcamera_source_state_machine.h"
29 #include "mock_dcamera_source_dev.h"
30 #include "mock_dcamera_source_state_listener.h"
31
32 #include "anonymous_string.h"
33 #include "distributed_camera_constants.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 DCameraSourceStateMachineTest : 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<DCameraSourceDev> camDev_;
49 std::shared_ptr<ICameraStateListener> stateListener_;
50 std::shared_ptr<DCameraSourceStateMachine> stateMachine_;
51
52 private:
53 static void SetStreamInfos();
54 static void SetCaptureInfos();
55 };
56
57 namespace {
58 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
59 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
60 const std::string TEST_REQID = "0xFFFF";
61 const std::string TEST_PARAM = "0xFFFF";
62 const int32_t TEST_WIDTH = 1920;
63 const int32_t TEST_HEIGTH = 1080;
64 const int32_t TEST_STREAMID = 2;
65 }
66
67 std::vector<std::shared_ptr<DCStreamInfo>> g_streamInfosSnap;
68 std::vector<std::shared_ptr<DCCaptureInfo>> g_captureInfoSnap;
69 std::vector<std::shared_ptr<DCameraSettings>> g_cameraSettingSnap;
70 std::vector<int> g_streamIdSnap;
71 std::shared_ptr<DCameraEvent> g_camEvent;
72 std::shared_ptr<DCameraRegistParam> g_registParam;
73 DCameraIndex g_camIndex;
74
SetUpTestCase(void)75 void DCameraSourceStateMachineTest::SetUpTestCase(void)
76 {
77 SetStreamInfos();
78 SetCaptureInfos();
79 }
80
SetStreamInfos()81 void DCameraSourceStateMachineTest::SetStreamInfos()
82 {
83 g_camIndex.devId_ = TEST_DEVICE_ID;
84 g_camIndex.dhId_ = TEST_CAMERA_DH_ID_0;
85 g_camEvent = std::make_shared<DCameraEvent>();
86 std::shared_ptr<DCStreamInfo> streamInfo1 = std::make_shared<DCStreamInfo>();
87 streamInfo1->streamId_ = 1;
88 streamInfo1->width_ = TEST_WIDTH;
89 streamInfo1->height_ = TEST_HEIGTH;
90 streamInfo1->stride_ = 1;
91 streamInfo1->format_ = 1;
92 streamInfo1->dataspace_ = 1;
93 streamInfo1->encodeType_ = ENCODE_TYPE_JPEG;
94 streamInfo1->type_ = SNAPSHOT_FRAME;
95
96 std::shared_ptr<DCStreamInfo> streamInfo2 = std::make_shared<DCStreamInfo>();
97 streamInfo2->streamId_ = TEST_STREAMID;
98 streamInfo2->width_ = TEST_WIDTH;
99 streamInfo2->height_ = TEST_HEIGTH;
100 streamInfo2->stride_ = 1;
101 streamInfo2->format_ = 1;
102 streamInfo2->dataspace_ = 1;
103 streamInfo2->encodeType_ = ENCODE_TYPE_JPEG;
104 streamInfo2->type_ = SNAPSHOT_FRAME;
105 g_streamInfosSnap.push_back(streamInfo1);
106 g_streamInfosSnap.push_back(streamInfo2);
107 }
108
SetCaptureInfos()109 void DCameraSourceStateMachineTest::SetCaptureInfos()
110 {
111 std::shared_ptr<DCCaptureInfo> captureInfo1 = std::make_shared<DCCaptureInfo>();
112 captureInfo1->streamIds_.push_back(1);
113 captureInfo1->width_ = TEST_WIDTH;
114 captureInfo1->height_ = TEST_HEIGTH;
115 captureInfo1->stride_ = 1;
116 captureInfo1->format_ = 1;
117 captureInfo1->dataspace_ = 1;
118 captureInfo1->encodeType_ = ENCODE_TYPE_H265;
119 captureInfo1->type_ = CONTINUOUS_FRAME;
120
121 std::shared_ptr<DCCaptureInfo> captureInfo2 = std::make_shared<DCCaptureInfo>();
122 captureInfo2->streamIds_.push_back(1);
123 captureInfo2->width_ = TEST_WIDTH;
124 captureInfo2->height_ = TEST_HEIGTH;
125 captureInfo2->stride_ = 1;
126 captureInfo2->format_ = 1;
127 captureInfo2->dataspace_ = 1;
128 captureInfo2->encodeType_ = ENCODE_TYPE_H265;
129 captureInfo2->type_ = CONTINUOUS_FRAME;
130 g_captureInfoSnap.push_back(captureInfo1);
131 g_captureInfoSnap.push_back(captureInfo2);
132
133 std::shared_ptr<DCameraSettings> camSettings1 = std::make_shared<DCameraSettings>();
134 camSettings1->type_ = UPDATE_METADATA;
135 camSettings1->value_ = "SettingValue";
136
137 std::shared_ptr<DCameraSettings> camSettings2 = std::make_shared<DCameraSettings>();
138 camSettings2->type_ = ENABLE_METADATA;
139 camSettings2->value_ = "SettingValue";
140 g_cameraSettingSnap.push_back(camSettings1);
141 g_cameraSettingSnap.push_back(camSettings2);
142
143 g_streamIdSnap.push_back(1);
144 g_streamIdSnap.push_back(TEST_STREAMID);
145
146 g_registParam = std::make_shared<DCameraRegistParam>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, TEST_PARAM);
147 }
148
TearDownTestCase(void)149 void DCameraSourceStateMachineTest::TearDownTestCase(void)
150 {
151 }
152
SetUp(void)153 void DCameraSourceStateMachineTest::SetUp(void)
154 {
155 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
156 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
157 stateMachine_ = std::make_shared<DCameraSourceStateMachine>(camDev_);
158 }
159
TearDown(void)160 void DCameraSourceStateMachineTest::TearDown(void)
161 {
162 stateMachine_ = nullptr;
163 camDev_ = nullptr;
164 stateListener_ = nullptr;
165 }
166
167 /**
168 * @tc.name: dcamera_source_state_machine_test_001
169 * @tc.desc: Verify source init state.
170 * @tc.type: FUNC
171 * @tc.require: AR000GK6MC
172 */
173 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, TestSize.Level1)
174 {
175 DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam);
176 DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam);
177 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
178 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
179 EXPECT_EQ(DCAMERA_OK, ret);
180
181 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
182 EXPECT_EQ(DCAMERA_OK, ret);
183 }
184
185 /**
186 * @tc.name: dcamera_source_state_machine_test_002
187 * @tc.desc: Verify source regist state.
188 * @tc.type: FUNC
189 * @tc.require: AR000GK6MC
190 */
191 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, TestSize.Level1)
192 {
193 DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam);
194 DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam);
195 DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex);
196 DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex);
197 DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
198 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
199 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
200 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
201 EXPECT_EQ(DCAMERA_OK, ret);
202
203 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
204 EXPECT_EQ(DCAMERA_OK, ret);
205
206 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
207 EXPECT_EQ(DCAMERA_OK, ret);
208
209 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
210 EXPECT_EQ(DCAMERA_OK, ret);
211
212 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
213 EXPECT_EQ(DCAMERA_OK, ret);
214 }
215
216 /**
217 * @tc.name: dcamera_source_state_machine_test_003
218 * @tc.desc: Verify source open state.
219 * @tc.type: FUNC
220 * @tc.require: AR000GK6MD
221 */
222 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, TestSize.Level1)
223 {
224 DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam);
225 DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam);
226 DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex);
227 DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex);
228 DCameraSourceEvent event4(*camDev_, DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
229 DCameraSourceEvent event5(*camDev_, DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
230 DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
231 DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
232 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
233 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
234 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
235 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
236 EXPECT_EQ(DCAMERA_OK, ret);
237
238 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
239 EXPECT_EQ(DCAMERA_OK, ret);
240
241 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
242 EXPECT_EQ(DCAMERA_OK, ret);
243
244 ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
245 EXPECT_EQ(DCAMERA_OK, ret);
246
247 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
248 EXPECT_EQ(DCAMERA_OK, ret);
249
250 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
251 EXPECT_EQ(DCAMERA_OK, ret);
252
253 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
254 EXPECT_EQ(DCAMERA_OK, ret);
255
256 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
257 EXPECT_EQ(DCAMERA_OK, ret);
258 }
259
260 /**
261 * @tc.name: dcamera_source_state_machine_test_004
262 * @tc.desc: Verify source config Stream state.
263 * @tc.type: FUNC
264 * @tc.require: AR000GK6ME
265 */
266 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, TestSize.Level1)
267 {
268 DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam);
269 DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam);
270 DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex);
271 DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex);
272 DCameraSourceEvent event4(*camDev_, DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
273 DCameraSourceEvent event5(*camDev_, DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
274 DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
275 DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
276 DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
277 DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
278 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
279 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
280 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
281 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
282 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
283 EXPECT_EQ(DCAMERA_OK, ret);
284
285 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
286 EXPECT_EQ(DCAMERA_OK, ret);
287
288 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
289 EXPECT_EQ(DCAMERA_OK, ret);
290
291 ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
292 EXPECT_EQ(DCAMERA_OK, ret);
293
294 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
295 EXPECT_EQ(DCAMERA_OK, ret);
296
297 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
298 EXPECT_EQ(DCAMERA_OK, ret);
299
300 ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
301 EXPECT_EQ(DCAMERA_OK, ret);
302
303 ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
304 EXPECT_EQ(DCAMERA_OK, ret);
305
306 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
307 EXPECT_EQ(DCAMERA_OK, ret);
308
309 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
310 EXPECT_EQ(DCAMERA_OK, ret);
311 }
312
313 /**
314 * @tc.name: dcamera_source_state_machine_test_005
315 * @tc.desc: Verify source capture state.
316 * @tc.type: FUNC
317 * @tc.require: AR000GK6ME
318 */
319 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, TestSize.Level1)
320 {
321 DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam);
322 DCameraSourceEvent event1(*camDev_, DCAMERA_EVENT_UNREGIST, g_registParam);
323 DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex);
324 DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex);
325 DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
326 DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
327 DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
328 DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
329 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
330 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
331 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
332 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
333 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
334 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
335 EXPECT_EQ(DCAMERA_OK, ret);
336
337 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
338 EXPECT_EQ(DCAMERA_OK, ret);
339
340 ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
341 EXPECT_EQ(DCAMERA_OK, ret);
342
343 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
344 EXPECT_EQ(DCAMERA_OK, ret);
345
346 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
347 EXPECT_EQ(DCAMERA_OK, ret);
348
349 ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
350 EXPECT_EQ(DCAMERA_OK, ret);
351
352 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
353 EXPECT_EQ(DCAMERA_OK, ret);
354
355 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
356 EXPECT_EQ(DCAMERA_OK, ret);
357 }
358 } // namespace DistributedHardware
359 } // namespace OHOS
360