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_source_input.h"
19 #include "distributed_camera_errno.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedHardware {
25 class DCameraSourceInputTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31
32 std::shared_ptr<DCameraSourceInput> testInput_;
33 std::shared_ptr<EventBus> eventBus_;
34 private:
35 static void SetStreamInfos();
36 static void SetCaptureInfos();
37 };
38
39 namespace {
40 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
41 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
42 const int32_t TEST_WIDTH = 1920;
43 const int32_t TEST_HEIGTH = 1080;
44 const int32_t TEST_STREAMID = 2;
45 const int32_t TEST_SLEEP_SEC = 200000;
46 std::vector<std::shared_ptr<DCStreamInfo>> g_streamInfos;
47 std::vector<std::shared_ptr<DCCaptureInfo>> g_captureInfos;
48 std::vector<std::shared_ptr<DCameraSettings>> g_cameraSettings;
49 std::vector<int> g_streamIds;
50 std::vector<DCameraIndex> g_camIndexs;
51 }
52
SetUpTestCase(void)53 void DCameraSourceInputTest::SetUpTestCase(void)
54 {
55 SetStreamInfos();
56 SetCaptureInfos();
57 }
58
SetStreamInfos()59 void DCameraSourceInputTest::SetStreamInfos()
60 {
61 DCameraIndex camIndex1(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0);
62 g_camIndexs.push_back(camIndex1);
63 std::shared_ptr<DCStreamInfo> streamInfo1 = std::make_shared<DCStreamInfo>();
64 streamInfo1->streamId_ = 1;
65 streamInfo1->width_ = TEST_WIDTH;
66 streamInfo1->height_ = TEST_HEIGTH;
67 streamInfo1->stride_ = 1;
68 streamInfo1->format_ = 1;
69 streamInfo1->dataspace_ = 1;
70 streamInfo1->encodeType_ = ENCODE_TYPE_JPEG;
71 streamInfo1->type_ = SNAPSHOT_FRAME;
72
73 std::shared_ptr<DCStreamInfo> streamInfo2 = std::make_shared<DCStreamInfo>();
74 streamInfo2->streamId_ = TEST_STREAMID;
75 streamInfo2->width_ = TEST_WIDTH;
76 streamInfo2->height_ = TEST_HEIGTH;
77 streamInfo2->stride_ = 1;
78 streamInfo2->format_ = 1;
79 streamInfo2->dataspace_ = 1;
80 streamInfo2->encodeType_ = ENCODE_TYPE_JPEG;
81 streamInfo2->type_ = SNAPSHOT_FRAME;
82 g_streamInfos.push_back(streamInfo1);
83 g_streamInfos.push_back(streamInfo2);
84 }
85
SetCaptureInfos()86 void DCameraSourceInputTest::SetCaptureInfos()
87 {
88 std::shared_ptr<DCCaptureInfo> captureInfo1 = std::make_shared<DCCaptureInfo>();
89 captureInfo1->streamIds_.push_back(1);
90 captureInfo1->width_ = TEST_WIDTH;
91 captureInfo1->height_ = TEST_HEIGTH;
92 captureInfo1->stride_ = 1;
93 captureInfo1->format_ = 1;
94 captureInfo1->dataspace_ = 1;
95 captureInfo1->encodeType_ = ENCODE_TYPE_H265;
96 captureInfo1->type_ = CONTINUOUS_FRAME;
97
98 std::shared_ptr<DCCaptureInfo> captureInfo2 = std::make_shared<DCCaptureInfo>();
99 captureInfo2->streamIds_.push_back(1);
100 captureInfo2->width_ = TEST_WIDTH;
101 captureInfo2->height_ = TEST_HEIGTH;
102 captureInfo2->stride_ = 1;
103 captureInfo2->format_ = 1;
104 captureInfo2->dataspace_ = 1;
105 captureInfo2->encodeType_ = ENCODE_TYPE_H265;
106 captureInfo2->type_ = CONTINUOUS_FRAME;
107 g_captureInfos.push_back(captureInfo1);
108 g_captureInfos.push_back(captureInfo2);
109
110 std::shared_ptr<DCameraSettings> camSettings1 = std::make_shared<DCameraSettings>();
111 camSettings1->type_ = UPDATE_METADATA;
112 camSettings1->value_ = "SettingValue";
113
114 std::shared_ptr<DCameraSettings> camSettings2 = std::make_shared<DCameraSettings>();
115 camSettings2->type_ = ENABLE_METADATA;
116 camSettings2->value_ = "SettingValue";
117 g_cameraSettings.push_back(camSettings1);
118 g_cameraSettings.push_back(camSettings2);
119
120 g_streamIds.push_back(1);
121 g_streamIds.push_back(TEST_STREAMID);
122 }
123
TearDownTestCase(void)124 void DCameraSourceInputTest::TearDownTestCase(void)
125 {
126 }
127
SetUp(void)128 void DCameraSourceInputTest::SetUp(void)
129 {
130 eventBus_ = std::make_shared<EventBus>("TestInputHandler");
131 testInput_ = std::make_shared<DCameraSourceInput>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, eventBus_);
132 }
133
TearDown(void)134 void DCameraSourceInputTest::TearDown(void)
135 {
136 usleep(TEST_SLEEP_SEC);
137 eventBus_ = nullptr;
138 testInput_ = nullptr;
139 }
140
141 /**
142 * @tc.name: dcamera_source_input_test_001
143 * @tc.desc: Verify source inptut Init.
144 * @tc.type: FUNC
145 * @tc.require: Issue Number
146 */
147 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_001, TestSize.Level1)
148 {
149 EXPECT_EQ(false, testInput_ == nullptr);
150
151 int32_t rc = testInput_->Init();
152 EXPECT_EQ(rc, DCAMERA_OK);
153 }
154
155 /**
156 * @tc.name: dcamera_source_input_test_002
157 * @tc.desc: Verify source inptut UnInit.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_002, TestSize.Level1)
162 {
163 EXPECT_EQ(false, testInput_ == nullptr);
164
165 int32_t rc = testInput_->Init();
166 EXPECT_EQ(rc, DCAMERA_OK);
167
168 rc = testInput_->UnInit();
169 EXPECT_EQ(rc, DCAMERA_OK);
170 }
171
172 /**
173 * @tc.name: dcamera_source_input_test_003
174 * @tc.desc: Verify source inptut ConfigStreams.
175 * @tc.type: FUNC
176 * @tc.require: Issue Number
177 */
178 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_003, TestSize.Level1)
179 {
180 EXPECT_EQ(false, testInput_ == nullptr);
181
182 int32_t rc = testInput_->Init();
183 EXPECT_EQ(rc, DCAMERA_OK);
184
185 rc = testInput_->ConfigStreams(g_streamInfos);
186 EXPECT_EQ(rc, DCAMERA_OK);
187
188 rc = testInput_->UnInit();
189 EXPECT_EQ(rc, DCAMERA_OK);
190 }
191
192 /**
193 * @tc.name: dcamera_source_input_test_004
194 * @tc.desc: Verify source inptut ReleaseStreams.
195 * @tc.type: FUNC
196 * @tc.require: Issue Number
197 */
198 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_004, TestSize.Level1)
199 {
200 EXPECT_EQ(false, testInput_ == nullptr);
201
202 int32_t rc = testInput_->Init();
203 EXPECT_EQ(rc, DCAMERA_OK);
204
205 rc = testInput_->ConfigStreams(g_streamInfos);
206 EXPECT_EQ(rc, DCAMERA_OK);
207
208 bool isAllRelease = true;
209 rc = testInput_->ReleaseStreams(g_streamIds, isAllRelease);
210 EXPECT_EQ(rc, DCAMERA_OK);
211
212 rc = testInput_->UnInit();
213 EXPECT_EQ(rc, DCAMERA_OK);
214 }
215
216 /**
217 * @tc.name: dcamera_source_input_test_005
218 * @tc.desc: Verify source inptut ReleaseAllStreams.
219 * @tc.type: FUNC
220 * @tc.require: Issue Number
221 */
222 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_005, TestSize.Level1)
223 {
224 EXPECT_EQ(false, testInput_ == nullptr);
225
226 int32_t rc = testInput_->Init();
227 EXPECT_EQ(rc, DCAMERA_OK);
228
229 rc = testInput_->ConfigStreams(g_streamInfos);
230 EXPECT_EQ(rc, DCAMERA_OK);
231
232 rc = testInput_->ReleaseAllStreams();
233 EXPECT_EQ(rc, DCAMERA_OK);
234
235 rc = testInput_->UnInit();
236 EXPECT_EQ(rc, DCAMERA_OK);
237 }
238
239 /**
240 * @tc.name: dcamera_source_input_test_006
241 * @tc.desc: Verify source inptut StartCapture.
242 * @tc.type: FUNC
243 * @tc.require: Issue Number
244 */
245 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_006, TestSize.Level1)
246 {
247 EXPECT_EQ(false, testInput_ == nullptr);
248
249 int32_t rc = testInput_->Init();
250 EXPECT_EQ(rc, DCAMERA_OK);
251
252 rc = testInput_->StartCapture(g_captureInfos);
253 EXPECT_EQ(rc, DCAMERA_OK);
254
255 rc = testInput_->UnInit();
256 EXPECT_EQ(rc, DCAMERA_OK);
257 }
258
259 /**
260 * @tc.name: dcamera_source_input_test_007
261 * @tc.desc: Verify source inptut StopCapture.
262 * @tc.type: FUNC
263 * @tc.require: Issue Number
264 */
265 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_007, TestSize.Level1)
266 {
267 EXPECT_EQ(false, testInput_ == nullptr);
268
269 int32_t rc = testInput_->Init();
270 EXPECT_EQ(rc, DCAMERA_OK);
271
272 rc = testInput_->StartCapture(g_captureInfos);
273 EXPECT_EQ(rc, DCAMERA_OK);
274
275 bool isAllStop = true;
276 rc = testInput_->StopCapture(g_streamIds, isAllStop);
277 EXPECT_EQ(rc, DCAMERA_OK);
278
279 rc = testInput_->UnInit();
280 EXPECT_EQ(rc, DCAMERA_OK);
281 }
282
283 /**
284 * @tc.name: dcamera_source_input_test_008
285 * @tc.desc: Verify source inptut StopAllCapture.
286 * @tc.type: FUNC
287 * @tc.require: Issue Number
288 */
289 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_008, TestSize.Level1)
290 {
291 EXPECT_EQ(false, testInput_ == nullptr);
292
293 int32_t rc = testInput_->Init();
294 EXPECT_EQ(rc, DCAMERA_OK);
295
296 rc = testInput_->StartCapture(g_captureInfos);
297 EXPECT_EQ(rc, DCAMERA_OK);
298
299 rc = testInput_->StopAllCapture();
300 EXPECT_EQ(rc, DCAMERA_OK);
301
302 rc = testInput_->UnInit();
303 EXPECT_EQ(rc, DCAMERA_OK);
304 }
305
306 /**
307 * @tc.name: dcamera_source_input_test_009
308 * @tc.desc: Verify source inptut OpenChannel.
309 * @tc.type: FUNC
310 * @tc.require: Issue Number
311 */
312 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_009, TestSize.Level1)
313 {
314 EXPECT_EQ(false, testInput_ == nullptr);
315
316 int32_t rc = testInput_->Init();
317 EXPECT_EQ(rc, DCAMERA_OK);
318
319 rc = testInput_->OpenChannel(g_camIndexs);
320 EXPECT_NE(rc, DCAMERA_OK);
321 rc = testInput_->UnInit();
322 EXPECT_EQ(rc, DCAMERA_OK);
323 }
324
325 /**
326 * @tc.name: dcamera_source_input_test_010
327 * @tc.desc: Verify source inptut CloseChannel.
328 * @tc.type: FUNC
329 * @tc.require: Issue Number
330 */
331 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_010, TestSize.Level1)
332 {
333 EXPECT_EQ(false, testInput_ == nullptr);
334
335 int32_t rc = testInput_->Init();
336 EXPECT_EQ(rc, DCAMERA_OK);
337
338 rc = testInput_->OpenChannel(g_camIndexs);
339 EXPECT_NE(rc, DCAMERA_OK);
340 rc = testInput_->CloseChannel();
341 EXPECT_EQ(rc, DCAMERA_OK);
342
343 rc = testInput_->UnInit();
344 EXPECT_EQ(rc, DCAMERA_OK);
345 }
346
347 /**
348 * @tc.name: dcamera_source_input_test_011
349 * @tc.desc: Verify source inptut UpdateSettings.
350 * @tc.type: FUNC
351 * @tc.require: Issue Number
352 */
353 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_011, TestSize.Level1)
354 {
355 EXPECT_EQ(false, testInput_ == nullptr);
356
357 int32_t rc = testInput_->Init();
358 EXPECT_EQ(rc, DCAMERA_OK);
359
360 rc = testInput_->UpdateSettings(g_cameraSettings);
361 EXPECT_EQ(rc, DCAMERA_OK);
362
363 rc = testInput_->UnInit();
364 EXPECT_EQ(rc, DCAMERA_OK);
365 }
366 } // namespace DistributedHardware
367 } // namespace OHOS
368