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