1 /*
2 * Copyright (c) 2022 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
18 #include "dcamera_provider_callback_impl.h"
19 #include "distributed_camera_constants.h"
20 #include "distributed_camera_errno.h"
21 #include "distributed_hardware_log.h"
22 #include "mock_dcamera_source_dev.h"
23 #include "mock_dcamera_source_state_listener.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace DistributedHardware {
29 class DCameraProviderCallbackImplTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35
36 std::shared_ptr<IDCameraProviderCallback> testProviderCallback_;
37 std::shared_ptr<DCameraSourceDev> camDev_;
38 std::shared_ptr<ICameraStateListener> stateListener_;
39
40 private:
41 static void SetStreamInfos();
42 static void SetCaptureInfos();
43 };
44
45 namespace {
46 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
47 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
48 const std::string TEST_REQID = "0xFFFF";
49 const std::string TEST_PARAM = "0xFFFF";
50 const int32_t TEST_WIDTH = 1920;
51 const int32_t TEST_HEIGTH = 1080;
52 const int32_t TEST_STREAMID = 2;
53 const int32_t SLEEP_TIME = 200000;
54 std::vector<DCStreamInfo> g_streamInfosSnap;
55 std::vector<DCCaptureInfo> g_captureInfoSnap;
56 std::vector<DCameraSettings> g_cameraSettingSnap;
57 std::vector<int> g_streamIdSnap;
58 }
59
SetUpTestCase(void)60 void DCameraProviderCallbackImplTest::SetUpTestCase(void)
61 {
62 SetStreamInfos();
63 SetCaptureInfos();
64 }
65
SetStreamInfos()66 void DCameraProviderCallbackImplTest::SetStreamInfos()
67 {
68 DCStreamInfo streamInfo1;
69 streamInfo1.streamId_ = 1;
70 streamInfo1.width_ = TEST_WIDTH;
71 streamInfo1.height_ = TEST_HEIGTH;
72 streamInfo1.stride_ = 1;
73 streamInfo1.format_ = 1;
74 streamInfo1.dataspace_ = 1;
75 streamInfo1.encodeType_ = ENCODE_TYPE_JPEG;
76 streamInfo1.type_ = SNAPSHOT_FRAME;
77
78 DCStreamInfo streamInfo2;
79 streamInfo2.streamId_ = TEST_STREAMID;
80 streamInfo2.width_ = TEST_WIDTH;
81 streamInfo2.height_ = TEST_HEIGTH;
82 streamInfo2.stride_ = 1;
83 streamInfo2.format_ = 1;
84 streamInfo2.dataspace_ = 1;
85 streamInfo2.encodeType_ = ENCODE_TYPE_JPEG;
86 streamInfo2.type_ = SNAPSHOT_FRAME;
87 g_streamInfosSnap.push_back(streamInfo1);
88 g_streamInfosSnap.push_back(streamInfo2);
89 }
90
SetCaptureInfos()91 void DCameraProviderCallbackImplTest::SetCaptureInfos()
92 {
93 DCCaptureInfo captureInfo1;
94 captureInfo1.streamIds_.push_back(1);
95 captureInfo1.width_ = TEST_WIDTH;
96 captureInfo1.height_ = TEST_HEIGTH;
97 captureInfo1.stride_ = 1;
98 captureInfo1.format_ = 1;
99 captureInfo1.dataspace_ = 1;
100 captureInfo1.encodeType_ = ENCODE_TYPE_H265;
101 captureInfo1.type_ = CONTINUOUS_FRAME;
102
103 DCCaptureInfo captureInfo2;
104 captureInfo2.streamIds_.push_back(1);
105 captureInfo2.width_ = TEST_WIDTH;
106 captureInfo2.height_ = TEST_HEIGTH;
107 captureInfo2.stride_ = 1;
108 captureInfo2.format_ = 1;
109 captureInfo2.dataspace_ = 1;
110 captureInfo2.encodeType_ = ENCODE_TYPE_H265;
111 captureInfo2.type_ = CONTINUOUS_FRAME;
112 g_captureInfoSnap.push_back(captureInfo1);
113 g_captureInfoSnap.push_back(captureInfo2);
114
115 DCameraSettings camSettings1;
116 camSettings1.type_ = UPDATE_METADATA;
117 camSettings1.value_ = "SettingValue";
118
119 DCameraSettings camSettings2;
120 camSettings2.type_ = ENABLE_METADATA;
121 camSettings2.value_ = "SettingValue";
122 g_cameraSettingSnap.push_back(camSettings1);
123 g_cameraSettingSnap.push_back(camSettings2);
124
125 g_streamIdSnap.push_back(1);
126 g_streamIdSnap.push_back(TEST_STREAMID);
127 }
128
TearDownTestCase(void)129 void DCameraProviderCallbackImplTest::TearDownTestCase(void)
130 {
131 }
132
SetUp(void)133 void DCameraProviderCallbackImplTest::SetUp(void)
134 {
135 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
136 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
137 camDev_->InitDCameraSourceDev();
138 testProviderCallback_ = std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_);
139 }
140
TearDown(void)141 void DCameraProviderCallbackImplTest::TearDown(void)
142 {
143 usleep(SLEEP_TIME);
144 testProviderCallback_ = nullptr;
145 camDev_ = nullptr;
146 stateListener_ = nullptr;
147 }
148
149 /**
150 * @tc.name: dcamera_provider_callback_impl_test_001
151 * @tc.desc: Verify OpenSession CloseSession func.
152 * @tc.type: FUNC
153 * @tc.require: issue
154 */
155 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_001, TestSize.Level1)
156 {
157 EXPECT_EQ(false, testProviderCallback_ == nullptr);
158
159 DHBase dhBase;
160 int32_t ret = testProviderCallback_->OpenSession(dhBase);
161 EXPECT_EQ(FAILED, ret);
162
163 ret = testProviderCallback_->CloseSession(dhBase);
164 EXPECT_EQ(FAILED, ret);
165 }
166
167 /**
168 * @tc.name: dcamera_provider_callback_impl_test_002
169 * @tc.desc: Verify OpenSession CloseSession func.
170 * @tc.type: FUNC
171 * @tc.require: issue
172 */
173 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_002, TestSize.Level1)
174 {
175 EXPECT_EQ(false, testProviderCallback_ == nullptr);
176 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
177 int32_t ret = testProviderCallback_->OpenSession(dhBase);
178 EXPECT_EQ(SUCCESS, ret);
179
180 ret = testProviderCallback_->CloseSession(dhBase);
181 EXPECT_EQ(SUCCESS, ret);
182 }
183
184 /**
185 * @tc.name: dcamera_provider_callback_impl_test_003
186 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
187 * @tc.type: FUNC
188 * @tc.require: issue
189 */
190 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_003, TestSize.Level1)
191 {
192 EXPECT_EQ(false, testProviderCallback_ == nullptr);
193
194 DHBase dhBase;
195 std::vector<DCStreamInfo> streamInfos;
196 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, streamInfos);
197 EXPECT_EQ(FAILED, ret);
198
199 std::vector<int> streamIds;
200 ret = testProviderCallback_->ReleaseStreams(dhBase, streamIds);
201 EXPECT_EQ(FAILED, ret);
202 }
203
204 /**
205 * @tc.name: dcamera_provider_callback_impl_test_004
206 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
207 * @tc.type: FUNC
208 * @tc.require: issue
209 */
210 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_004, TestSize.Level1)
211 {
212 EXPECT_EQ(false, testProviderCallback_ == nullptr);
213
214 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
215 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, g_streamInfosSnap);
216 EXPECT_EQ(SUCCESS, ret);
217
218 ret = testProviderCallback_->ReleaseStreams(dhBase, g_streamIdSnap);
219 EXPECT_EQ(SUCCESS, ret);
220 }
221
222 /**
223 * @tc.name: dcamera_provider_callback_impl_test_005
224 * @tc.desc: Verify StartCapture StopCapture func.
225 * @tc.type: FUNC
226 * @tc.require: issue
227 */
228 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_005, TestSize.Level1)
229 {
230 EXPECT_EQ(false, testProviderCallback_ == nullptr);
231
232 DHBase dhBase;
233 std::vector<DCCaptureInfo> captureInfos;
234 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
235 EXPECT_EQ(FAILED, ret);
236
237 std::vector<int> streamIds;
238 ret = testProviderCallback_->StopCapture(dhBase, streamIds);
239 EXPECT_EQ(FAILED, ret);
240 }
241
242 /**
243 * @tc.name: dcamera_provider_callback_impl_test_006
244 * @tc.desc: Verify StartCapture StopCapture func.
245 * @tc.type: FUNC
246 * @tc.require: issue
247 */
248 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_006, TestSize.Level1)
249 {
250 EXPECT_EQ(false, testProviderCallback_ == nullptr);
251
252 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
253 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
254 EXPECT_EQ(SUCCESS, ret);
255
256 ret = testProviderCallback_->StopCapture(dhBase, g_streamIdSnap);
257 EXPECT_EQ(SUCCESS, ret);
258 }
259
260 /**
261 * @tc.name: dcamera_provider_callback_impl_test_007
262 * @tc.desc: Verify UpdateSettings func.
263 * @tc.type: FUNC
264 * @tc.require: issue
265 */
266 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_007, TestSize.Level1)
267 {
268 EXPECT_EQ(false, testProviderCallback_ == nullptr);
269
270 DHBase dhBase;
271 int32_t ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
272 EXPECT_EQ(FAILED, ret);
273 }
274
275 /**
276 * @tc.name: dcamera_provider_callback_impl_test_008
277 * @tc.desc: Verify UpdateSettings func.
278 * @tc.type: FUNC
279 * @tc.require: issue
280 */
281 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_008, TestSize.Level1)
282 {
283 EXPECT_EQ(false, testProviderCallback_ == nullptr);
284
285 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
286 int32_t ret = testProviderCallback_->OpenSession(dhBase);
287 EXPECT_EQ(SUCCESS, ret);
288
289 ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
290 EXPECT_EQ(SUCCESS, ret);
291
292 ret = testProviderCallback_->CloseSession(dhBase);
293 EXPECT_EQ(SUCCESS, ret);
294 }
295 } // namespace DistributedHardware
296 } // namespace OHOS
297