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