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_config_stream_state.h"
20 #include "dcamera_source_opened_state.h"
21 #include "dcamera_source_capture_state.h"
22 #undef private
23
24 #include "dcamera_source_state.h"
25 #include "dcamera_source_regist_state.h"
26 #include "dcamera_source_state_machine.h"
27 #include "mock_dcamera_source_dev.h"
28 #include "mock_dcamera_source_state_listener.h"
29 #include "anonymous_string.h"
30 #include "distributed_camera_constants.h"
31 #include "distributed_camera_errno.h"
32 #include "distributed_hardware_log.h"
33
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace DistributedHardware {
38 class DCameraSourceConfigStreamStateTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44
45 std::shared_ptr<DCameraSourceDev> camDev_;
46 std::shared_ptr<ICameraStateListener> stateListener_;
47 std::shared_ptr<DCameraSourceStateMachine> stateMachine_;
48 std::shared_ptr<DCameraRegistParam> g_registParam;
49 };
50
51 namespace {
52 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
53 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
54 const std::string TEST_REQID = "0xFFFF";
55 const std::string TEST_SINK_PARAM = "0xFFFF";
56 const std::string TEST_SRC_PARAM = "0xFFFF";
57 }
58
SetUpTestCase(void)59 void DCameraSourceConfigStreamStateTest::SetUpTestCase(void)
60 {
61 }
62
TearDownTestCase(void)63 void DCameraSourceConfigStreamStateTest::TearDownTestCase(void)
64 {
65 }
66
SetUp(void)67 void DCameraSourceConfigStreamStateTest::SetUp(void)
68 {
69 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
70 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
71 stateMachine_ = std::make_shared<DCameraSourceStateMachine>(camDev_);
72 g_registParam = std::make_shared<DCameraRegistParam>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID,
73 TEST_SINK_PARAM, TEST_SRC_PARAM);
74 }
75
TearDown(void)76 void DCameraSourceConfigStreamStateTest::TearDown(void)
77 {
78 stateMachine_ = nullptr;
79 camDev_ = nullptr;
80 stateListener_ = nullptr;
81 g_registParam = nullptr;
82 }
83
84 /**
85 * @tc.name: dcamera_source_config_stream_state_test_001
86 * @tc.desc: Verify source DoUnregisterTask state.
87 * @tc.type: FUNC
88 * @tc.require:
89 */
90 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_001, TestSize.Level1)
91 {
92 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
93 std::shared_ptr<DCameraSourceConfigStreamState> configstate =
94 std::make_shared<DCameraSourceConfigStreamState>(stateMachine_);
95 int32_t ret = configstate->DoUnregisterTask(camDev_, event0);
96 EXPECT_EQ(DCAMERA_OK, ret);
97 }
98
99 /**
100 * @tc.name: dcamera_source_config_stream_state_test_002
101 * @tc.desc: Verify source DoUpdateSettingsTask state.
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_002, TestSize.Level1)
106 {
107 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
108 std::shared_ptr<DCameraSourceConfigStreamState> configstate =
109 std::make_shared<DCameraSourceConfigStreamState>(stateMachine_);
110 int32_t ret = configstate->DoUpdateSettingsTask(camDev_, event0);
111 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
112 }
113
114 /**
115 * @tc.name: dcamera_source_config_stream_state_test_003
116 * @tc.desc: Verify source DoEventNofityTask state.
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_003, TestSize.Level1)
121 {
122 DCameraSourceEvent event0(DCAMERA_EVENT_REGIST, g_registParam);
123 std::shared_ptr<DCameraSourceConfigStreamState> configstate =
124 std::make_shared<DCameraSourceConfigStreamState>(stateMachine_);
125 int32_t ret = configstate->DoEventNofityTask(camDev_, event0);
126 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
127 }
128
129 /**
130 * @tc.name: dcamera_source_config_stream_state_test_004
131 * @tc.desc: Verify source DoUnregisterTask state.
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_004, TestSize.Level1)
136 {
137 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
138 std::shared_ptr<DCameraSourceOpenedState> openState = std::make_shared<DCameraSourceOpenedState>(stateMachine_);
139 int32_t ret = openState->DoUnregisterTask(camDev_, event0);
140 EXPECT_EQ(DCAMERA_OK, ret);
141 }
142
143 /**
144 * @tc.name: dcamera_source_config_stream_state_test_005
145 * @tc.desc: Verify source DoUpdateSettingsTask state.
146 * @tc.type: FUNC
147 * @tc.require:
148 */
149 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_005, TestSize.Level1)
150 {
151 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
152 std::shared_ptr<DCameraSourceOpenedState> openState = std::make_shared<DCameraSourceOpenedState>(stateMachine_);
153 int32_t ret = openState->DoUpdateSettingsTask(camDev_, event0);
154 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
155 }
156
157 /**
158 * @tc.name: dcamera_source_config_stream_state_test_006
159 * @tc.desc: Verify source DoEventNofityTask state.
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_006, TestSize.Level1)
164 {
165 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
166 std::shared_ptr<DCameraSourceOpenedState> openState = std::make_shared<DCameraSourceOpenedState>(stateMachine_);
167 int32_t ret = openState->DoEventNofityTask(camDev_, event0);
168 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
169 }
170
171 /**
172 * @tc.name: dcamera_source_config_stream_state_test_007
173 * @tc.desc: Verify source DoUnregisterTask state.
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_007, TestSize.Level1)
178 {
179 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
180 std::shared_ptr<DCameraSourceCaptureState> captureState =
181 std::make_shared<DCameraSourceCaptureState>(stateMachine_);
182 int32_t ret = captureState->DoUnregisterTask(camDev_, event0);
183 EXPECT_EQ(DCAMERA_OK, ret);
184 }
185
186 /**
187 * @tc.name: dcamera_source_config_stream_state_test_008
188 * @tc.desc: Verify source DoStartCaptureTask state.
189 * @tc.type: FUNC
190 * @tc.require:
191 */
192 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_008, TestSize.Level1)
193 {
194 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
195 std::shared_ptr<DCameraSourceCaptureState> captureState =
196 std::make_shared<DCameraSourceCaptureState>(stateMachine_);
197 int32_t ret = captureState->DoStartCaptureTask(camDev_, event0);
198 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
199 }
200
201 /**
202 * @tc.name: dcamera_source_config_stream_state_test_009
203 * @tc.desc: Verify source DoStopCaptureTask state.
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_009, TestSize.Level1)
208 {
209 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
210 std::shared_ptr<DCameraSourceCaptureState> captureState =
211 std::make_shared<DCameraSourceCaptureState>(stateMachine_);
212 int32_t ret = captureState->DoStopCaptureTask(camDev_, event0);
213 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
214 }
215
216 /**
217 * @tc.name: dcamera_source_config_stream_state_test_010
218 * @tc.desc: Verify source DoUpdateSettingsTask state.
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_010, TestSize.Level1)
223 {
224 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
225 std::shared_ptr<DCameraSourceCaptureState> captureState =
226 std::make_shared<DCameraSourceCaptureState>(stateMachine_);
227 int32_t ret = captureState->DoUpdateSettingsTask(camDev_, event0);
228 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
229 }
230
231 /**
232 * @tc.name: dcamera_source_config_stream_state_test_011
233 * @tc.desc: Verify source DoEventNofityTask state.
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_011, TestSize.Level1)
238 {
239 DCameraSourceEvent event0(DCAMERA_EVENT_OPEN, g_registParam);
240 std::shared_ptr<DCameraSourceCaptureState> captureState =
241 std::make_shared<DCameraSourceCaptureState>(stateMachine_);
242 int32_t ret = captureState->DoEventNofityTask(camDev_, event0);
243 EXPECT_EQ(DCAMERA_NOT_FOUND, ret);
244 }
245 } // namespace DistributedHardware
246 } // namespace OHOS
247