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