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 std::string g_regisStateStr = "";
42 std::string g_openStateStr = "";
43 std::string g_captureStateStr = "";
44 class DCameraSourceStateMachineTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50
51 std::shared_ptr<DCameraSourceDev> camDev_;
52 std::shared_ptr<ICameraStateListener> stateListener_;
53 std::shared_ptr<DCameraSourceStateMachine> stateMachine_;
54
55 private:
56 static void SetStreamInfos();
57 static void SetCaptureInfos();
58 };
59
60 namespace {
61 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
62 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
63 const std::string TEST_REQID = "0xFFFF";
64 const std::string TEST_SINK_PARAM = "0xFFFF";
65 const std::string TEST_SRC_PARAM = "0xFFFF";
66 const int32_t TEST_WIDTH = 1920;
67 const int32_t TEST_HEIGTH = 1080;
68 const int32_t TEST_STREAMID = 2;
69 }
70
71 std::vector<std::shared_ptr<DCStreamInfo>> g_streamInfosSnap;
72 std::vector<std::shared_ptr<DCCaptureInfo>> g_captureInfoSnap;
73 std::vector<std::shared_ptr<DCameraSettings>> g_cameraSettingSnap;
74 std::vector<int> g_streamIdSnap;
75 std::shared_ptr<DCameraEvent> g_camEvent;
76 std::shared_ptr<DCameraRegistParam> g_registParam;
77 DCameraIndex g_camIndex;
78
SetUpTestCase(void)79 void DCameraSourceStateMachineTest::SetUpTestCase(void)
80 {
81 }
82
SetStreamInfos()83 void DCameraSourceStateMachineTest::SetStreamInfos()
84 {
85 g_camIndex.devId_ = TEST_DEVICE_ID;
86 g_camIndex.dhId_ = TEST_CAMERA_DH_ID_0;
87 g_camEvent = std::make_shared<DCameraEvent>();
88 std::shared_ptr<DCStreamInfo> streamInfo1 = std::make_shared<DCStreamInfo>();
89 streamInfo1->streamId_ = 1;
90 streamInfo1->width_ = TEST_WIDTH;
91 streamInfo1->height_ = TEST_HEIGTH;
92 streamInfo1->stride_ = 1;
93 streamInfo1->format_ = 1;
94 streamInfo1->dataspace_ = 1;
95 streamInfo1->encodeType_ = ENCODE_TYPE_JPEG;
96 streamInfo1->type_ = SNAPSHOT_FRAME;
97
98 std::shared_ptr<DCStreamInfo> streamInfo2 = std::make_shared<DCStreamInfo>();
99 streamInfo2->streamId_ = TEST_STREAMID;
100 streamInfo2->width_ = TEST_WIDTH;
101 streamInfo2->height_ = TEST_HEIGTH;
102 streamInfo2->stride_ = 1;
103 streamInfo2->format_ = 1;
104 streamInfo2->dataspace_ = 1;
105 streamInfo2->encodeType_ = ENCODE_TYPE_JPEG;
106 streamInfo2->type_ = SNAPSHOT_FRAME;
107 g_streamInfosSnap.push_back(streamInfo1);
108 g_streamInfosSnap.push_back(streamInfo2);
109 }
110
SetCaptureInfos()111 void DCameraSourceStateMachineTest::SetCaptureInfos()
112 {
113 std::shared_ptr<DCCaptureInfo> captureInfo1 = std::make_shared<DCCaptureInfo>();
114 captureInfo1->streamIds_.push_back(1);
115 captureInfo1->width_ = TEST_WIDTH;
116 captureInfo1->height_ = TEST_HEIGTH;
117 captureInfo1->stride_ = 1;
118 captureInfo1->format_ = 1;
119 captureInfo1->dataspace_ = 1;
120 captureInfo1->encodeType_ = ENCODE_TYPE_H265;
121 captureInfo1->type_ = CONTINUOUS_FRAME;
122
123 std::shared_ptr<DCCaptureInfo> captureInfo2 = std::make_shared<DCCaptureInfo>();
124 captureInfo2->streamIds_.push_back(1);
125 captureInfo2->width_ = TEST_WIDTH;
126 captureInfo2->height_ = TEST_HEIGTH;
127 captureInfo2->stride_ = 1;
128 captureInfo2->format_ = 1;
129 captureInfo2->dataspace_ = 1;
130 captureInfo2->encodeType_ = ENCODE_TYPE_H265;
131 captureInfo2->type_ = CONTINUOUS_FRAME;
132 g_captureInfoSnap.push_back(captureInfo1);
133 g_captureInfoSnap.push_back(captureInfo2);
134
135 std::shared_ptr<DCameraSettings> camSettings1 = std::make_shared<DCameraSettings>();
136 camSettings1->type_ = UPDATE_METADATA;
137 camSettings1->value_ = "SettingValue";
138
139 std::shared_ptr<DCameraSettings> camSettings2 = std::make_shared<DCameraSettings>();
140 camSettings2->type_ = ENABLE_METADATA;
141 camSettings2->value_ = "SettingValue";
142 g_cameraSettingSnap.push_back(camSettings1);
143 g_cameraSettingSnap.push_back(camSettings2);
144
145 g_streamIdSnap.push_back(1);
146 g_streamIdSnap.push_back(TEST_STREAMID);
147
148 g_registParam = std::make_shared<DCameraRegistParam>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID,
149 TEST_SINK_PARAM, TEST_SRC_PARAM);
150 }
151
TearDownTestCase(void)152 void DCameraSourceStateMachineTest::TearDownTestCase(void)
153 {
154 }
155
SetUp(void)156 void DCameraSourceStateMachineTest::SetUp(void)
157 {
158 g_streamInfosSnap.clear();
159 g_captureInfoSnap.clear();
160 g_cameraSettingSnap.clear();
161 g_streamIdSnap.clear();
162 g_camEvent = nullptr;
163 g_registParam = nullptr;
164 g_camIndex = {}; // Reset struct to default
165 g_regisStateStr = "";
166 g_openStateStr = "";
167 g_captureStateStr = "";
168
169 SetStreamInfos();
170 SetCaptureInfos();
171
172 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
173 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
174 stateMachine_ = std::make_shared<DCameraSourceStateMachine>(camDev_);
175 }
176
TearDown(void)177 void DCameraSourceStateMachineTest::TearDown(void)
178 {
179 stateMachine_ = nullptr;
180 camDev_ = nullptr;
181 stateListener_ = nullptr;
182 }
183
184 /**
185 * @tc.name: dcamera_source_state_machine_test_001
186 * @tc.desc: Verify source init state.
187 * @tc.type: FUNC
188 * @tc.require: AR000GK6MC
189 */
190 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_001, TestSize.Level1)
191 {
192 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
193 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
194 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
195 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
196 EXPECT_EQ(DCAMERA_OK, ret);
197
198 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
199 EXPECT_EQ(DCAMERA_OK, ret);
200 }
201
202 /**
203 * @tc.name: dcamera_source_state_machine_test_002
204 * @tc.desc: Verify source regist state.
205 * @tc.type: FUNC
206 * @tc.require: AR000GK6MC
207 */
208 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_002, TestSize.Level1)
209 {
210 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
211 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
212 DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
213 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
214 DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
215 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
216 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
217 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
218 EXPECT_EQ(DCAMERA_OK, ret);
219
220 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
221 EXPECT_EQ(DCAMERA_OK, ret);
222
223 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
224 EXPECT_EQ(DCAMERA_OK, ret);
225
226 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
227 EXPECT_EQ(DCAMERA_OK, ret);
228
229 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
230 EXPECT_EQ(DCAMERA_OK, ret);
231 }
232
233 /**
234 * @tc.name: dcamera_source_state_machine_test_003
235 * @tc.desc: Verify source open state.
236 * @tc.type: FUNC
237 * @tc.require: AR000GK6MD
238 */
239 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_003, TestSize.Level1)
240 {
241 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
242 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
243 DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
244 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
245 DCameraSourceEvent event4(DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
246 DCameraSourceEvent event5(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
247 DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
248 DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
249 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
250 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
251 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
252 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
253 EXPECT_EQ(DCAMERA_OK, ret);
254
255 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
256 EXPECT_EQ(DCAMERA_OK, ret);
257
258 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
259 EXPECT_EQ(DCAMERA_OK, ret);
260
261 ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
262 EXPECT_EQ(DCAMERA_OK, ret);
263
264 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
265 EXPECT_EQ(DCAMERA_OK, ret);
266
267 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
268 EXPECT_EQ(DCAMERA_OK, ret);
269
270 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
271 EXPECT_EQ(DCAMERA_OK, ret);
272
273 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
274 EXPECT_EQ(DCAMERA_OK, ret);
275 }
276
277 /**
278 * @tc.name: dcamera_source_state_machine_test_004
279 * @tc.desc: Verify source config Stream state.
280 * @tc.type: FUNC
281 * @tc.require: AR000GK6ME
282 */
283 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, TestSize.Level1)
284 {
285 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
286 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
287 DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
288 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
289 DCameraSourceEvent event4(DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
290 DCameraSourceEvent event5(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
291 DCameraSourceEvent event6(DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
292 DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
293 DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
294 DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
295 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
296 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
297 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
298 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
299 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
300 EXPECT_EQ(DCAMERA_OK, ret);
301
302 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
303 EXPECT_EQ(DCAMERA_OK, ret);
304
305 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event4);
306 EXPECT_EQ(DCAMERA_OK, ret);
307
308 ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
309 EXPECT_EQ(DCAMERA_OK, ret);
310
311 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
312 EXPECT_EQ(DCAMERA_OK, ret);
313
314 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
315 EXPECT_EQ(DCAMERA_OK, ret);
316
317 ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
318 EXPECT_EQ(DCAMERA_OK, ret);
319
320 ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event5);
321 EXPECT_EQ(DCAMERA_OK, ret);
322
323 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
324 EXPECT_EQ(DCAMERA_OK, ret);
325
326 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
327 EXPECT_EQ(DCAMERA_OK, ret);
328 }
329
330 /**
331 * @tc.name: dcamera_source_state_machine_test_005
332 * @tc.desc: Verify source capture state.
333 * @tc.type: FUNC
334 * @tc.require: AR000GK6ME
335 */
336 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, TestSize.Level1)
337 {
338 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
339 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
340 DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
341 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
342 DCameraSourceEvent event6(DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
343 DCameraSourceEvent event7(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
344 DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
345 DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
346 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
347 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
348 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
349 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
350 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
351 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
352 EXPECT_EQ(DCAMERA_OK, ret);
353
354 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event2);
355 EXPECT_EQ(DCAMERA_OK, ret);
356
357 ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event6);
358 EXPECT_EQ(DCAMERA_OK, ret);
359
360 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
361 EXPECT_EQ(DCAMERA_OK, ret);
362
363 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
364 EXPECT_EQ(DCAMERA_OK, ret);
365
366 ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event7);
367 EXPECT_EQ(DCAMERA_OK, ret);
368
369 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
370 EXPECT_EQ(DCAMERA_OK, ret);
371
372 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
373 EXPECT_EQ(DCAMERA_OK, ret);
374 }
375
376 /**
377 * @tc.name: dcamera_source_state_machine_test_006
378 * @tc.desc: Verify source state machine.
379 * @tc.type: FUNC
380 * @tc.require: AR000GK6MC
381 */
382 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_006, TestSize.Level1)
383 {
384 int32_t ret = DCAMERA_OK;
385 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
386 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
387 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
388 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
389 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
390 stateMachine_ ->UpdateState(static_cast<DCameraStateType>(-1));
391 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
392 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_camIndex);
393 ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
394 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
395 }
396
397 /**
398 * @tc.name: dcamera_source_state_machine_test_007
399 * @tc.desc: Verify source regist state machine.
400 * @tc.type: FUNC
401 * @tc.require: AR000GK6MC
402 */
403 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_007, TestSize.Level1)
404 {
405 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_camIndex);
406 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_camIndex);
407 DCameraSourceEvent event2(DCAMERA_EVENT_NOFIFY, g_camIndex);
408 DCameraSourceEvent event3(DCAMERA_EVENT_GET_FULLCAPS, g_camIndex);
409 DCameraSourceEvent event4(static_cast<DCAMERA_EVENT>(-1), g_camIndex);
410 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
411 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
412 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
413
414 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
415 ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
416 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
417
418 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
419 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
420
421 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event2);
422 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
423
424 ret = stateMachine_ ->Execute(DCAMERA_EVENT_GET_FULLCAPS, event3);
425 EXPECT_EQ(DCAMERA_OK, ret);
426
427 ret = stateMachine_ ->Execute(static_cast<DCAMERA_EVENT>(-1), event4);
428 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
429 }
430
431 /**
432 * @tc.name: dcamera_source_state_machine_test_008
433 * @tc.desc: Verify source regist state machine.
434 * @tc.type: FUNC
435 * @tc.require: AR000GK6MC
436 */
437 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_008, TestSize.Level1)
438 {
439 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
440 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
441 DCameraSourceEvent event2(DCAMERA_EVENT_NOFIFY, g_camEvent);
442 DCameraSourceEvent event3(DCAMERA_EVENT_OPEN, g_camIndex);
443
444 g_regisStateStr = "test008";
445 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
446 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
447 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
448 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
449
450 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
451 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
452
453 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event2);
454 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
455
456 ret = stateMachine_ ->Execute(DCAMERA_EVENT_OPEN, event3);
457 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
458 }
459
460 /**
461 * @tc.name: dcamera_source_state_machine_test_009
462 * @tc.desc: Verify source open state machine.
463 * @tc.type: FUNC
464 * @tc.require: AR000GK6MC
465 */
466 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_009, TestSize.Level1)
467 {
468 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_camIndex);
469 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_camIndex);
470 DCameraSourceEvent event2(DCAMERA_EVENT_CONFIG_STREAMS, g_camIndex);
471 DCameraSourceEvent event3(DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
472 DCameraSourceEvent event4(static_cast<DCAMERA_EVENT>(-1), g_camIndex);
473 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
474 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
475 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
476 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
477 EXPECT_EQ(DCAMERA_OK, ret);
478
479 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event2);
480 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
481
482 ret = stateMachine_ ->Execute(DCAMERA_EVENT_RELEASE_STREAMS, event3);
483 EXPECT_EQ(DCAMERA_OK, ret);
484
485 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
486 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
487
488 ret = stateMachine_ ->Execute(static_cast<DCAMERA_EVENT>(-1), event4);
489 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
490 }
491
492 /**
493 * @tc.name: dcamera_source_state_machine_test_010
494 * @tc.desc: Verify source open state machine.
495 * @tc.type: FUNC
496 * @tc.require: AR000GK6MC
497 */
498 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_010, TestSize.Level1)
499 {
500 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
501 DCameraSourceEvent event2(DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
502 DCameraSourceEvent event3(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
503 DCameraSourceEvent event4(DCAMERA_EVENT_CLOSE, g_camIndex);
504 DCameraSourceEvent event5(DCAMERA_EVENT_NOFIFY, g_camEvent);
505
506 g_openStateStr = "test010";
507 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
508 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
509 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
510
511 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
512 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
513
514 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CONFIG_STREAMS, event2);
515 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
516
517 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event3);
518 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
519
520 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event4);
521 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
522
523 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event4);
524 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
525 }
526
527 /**
528 * @tc.name: dcamera_source_state_machine_test_011
529 * @tc.desc: Verify source open state machine.
530 * @tc.type: FUNC
531 * @tc.require: AR000GK6MC
532 */
533 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_011, TestSize.Level1)
534 {
535 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
536
537 g_openStateStr = "test011";
538 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
539 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
540 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
541
542 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
543 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
544 }
545
546 /**
547 * @tc.name: dcamera_source_state_machine_test_012
548 * @tc.desc: Verify source open state machine.
549 * @tc.type: FUNC
550 * @tc.require: AR000GK6MC
551 */
552 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_012, TestSize.Level1)
553 {
554 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
555
556 g_openStateStr = "test012";
557 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
558 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
559 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
560
561 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
562 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
563 }
564
565 /**
566 * @tc.name: dcamera_source_state_machine_test_013
567 * @tc.desc: Verify source capture state machine.
568 * @tc.type: FUNC
569 * @tc.require: AR000GK6MC
570 */
571 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_013, TestSize.Level1)
572 {
573 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
574 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_camIndex);
575 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
576 DCameraSourceEvent event4(static_cast<DCAMERA_EVENT>(-1), g_camIndex);
577 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
578 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
579 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
580 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
581 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
582 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_REGIST, event0);
583 EXPECT_EQ(DCAMERA_OK, ret);
584
585 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
586 EXPECT_EQ(DCAMERA_OK, ret);
587
588 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
589 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
590
591 ret = stateMachine_ ->Execute(static_cast<DCAMERA_EVENT>(-1), event4);
592 EXPECT_EQ(DCAMERA_WRONG_STATE, ret);
593 }
594
595 /**
596 * @tc.name: dcamera_source_state_machine_test_014
597 * @tc.desc: Verify source capture state machine.
598 * @tc.type: FUNC
599 * @tc.require: AR000GK6MC
600 */
601 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_014, TestSize.Level1)
602 {
603 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
604 DCameraSourceEvent event2(DCAMERA_EVENT_OPEN, g_camIndex);
605 DCameraSourceEvent event3(DCAMERA_EVENT_CLOSE, g_camIndex);
606 DCameraSourceEvent event4(DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
607 DCameraSourceEvent event5(DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
608 DCameraSourceEvent event8(DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
609 DCameraSourceEvent event9(DCAMERA_EVENT_NOFIFY, g_camEvent);
610
611 g_captureStateStr = "test014";
612 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
613 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
614 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
615 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
616 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
617
618 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
619 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
620
621 ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event3);
622 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
623
624 ret = stateMachine_ ->Execute(DCAMERA_EVENT_START_CAPTURE, event4);
625 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
626
627 ret = stateMachine_ ->Execute(DCAMERA_EVENT_STOP_CAPTURE, event5);
628 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
629
630 ret = stateMachine_ ->Execute(DCAMERA_EVENT_UPDATE_SETTINGS, event8);
631 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
632
633 ret = stateMachine_ ->Execute(DCAMERA_EVENT_NOFIFY, event9);
634 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
635 }
636
637 /**
638 * @tc.name: dcamera_source_state_machine_test_015
639 * @tc.desc: Verify source capture state machine.
640 * @tc.type: FUNC
641 * @tc.require: AR000GK6MC
642 */
643 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_015, TestSize.Level1)
644 {
645 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
646
647 g_captureStateStr = "test015";
648 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
649 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
650 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
651 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
652 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
653
654 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
655 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
656 }
657
658 /**
659 * @tc.name: dcamera_source_state_machine_test_016
660 * @tc.desc: Verify source capture state machine.
661 * @tc.type: FUNC
662 * @tc.require: AR000GK6MC
663 */
664 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_016, TestSize.Level1)
665 {
666 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
667
668 g_captureStateStr = "test016";
669 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
670 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
671 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
672 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
673 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
674
675 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
676 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
677 }
678
679 /**
680 * @tc.name: dcamera_source_state_machine_test_017
681 * @tc.desc: Verify source capture state machine.
682 * @tc.type: FUNC
683 * @tc.require: AR000GK6MC
684 */
685 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_017, TestSize.Level1)
686 {
687 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
688
689 g_captureStateStr = "test017";
690 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
691 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
692 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
693 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
694 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
695
696 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
697 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
698 }
699
700 /**
701 * @tc.name: dcamera_source_state_machine_test_018
702 * @tc.desc: Verify source capture state machine.
703 * @tc.type: FUNC
704 * @tc.require: AR000GK6MC
705 */
706 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_018, TestSize.Level1)
707 {
708 DCameraSourceEvent event1(DCAMERA_EVENT_UNREGIST, g_registParam);
709
710 g_captureStateStr = "test018";
711 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
712 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
713 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
714 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
715 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
716
717 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_UNREGIST, event1);
718 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
719 }
720
721 /**
722 * @tc.name: dcamera_source_state_machine_test_019
723 * @tc.desc: Verify source capture state machine.
724 * @tc.type: FUNC
725 * @tc.require: AR000GK6MC
726 */
727 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_019, TestSize.Level1)
728 {
729 DCameraSourceEvent event1(DCAMERA_EVENT_CLOSE, g_camIndex);
730
731 g_captureStateStr = "test019";
732 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
733 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
734 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
735 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
736 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
737
738 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event1);
739 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
740 }
741
742 /**
743 * @tc.name: dcamera_source_state_machine_test_020
744 * @tc.desc: Verify source capture state machine.
745 * @tc.type: FUNC
746 * @tc.require: AR000GK6MC
747 */
748 HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_020, TestSize.Level1)
749 {
750 DCameraSourceEvent event1(DCAMERA_EVENT_CLOSE, g_camIndex);
751
752 g_captureStateStr = "test020";
753 stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
754 stateMachine_ ->UpdateState(DCAMERA_STATE_REGIST);
755 stateMachine_ ->UpdateState(DCAMERA_STATE_OPENED);
756 stateMachine_ ->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
757 stateMachine_ ->UpdateState(DCAMERA_STATE_CAPTURE);
758
759 int32_t ret = stateMachine_ ->Execute(DCAMERA_EVENT_CLOSE, event1);
760 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
761 }
762 } // namespace DistributedHardware
763 } // namespace OHOS
764