1 /*
2 * Copyright (c) 2022-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 #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_ = CONTINUOUS_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 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
194 rc = testInput_->ConfigStreams(streamInfos);
195 EXPECT_EQ(rc, DCAMERA_OK);
196
197 rc = testInput_->UnInit();
198 EXPECT_EQ(rc, DCAMERA_OK);
199 }
200
201 /**
202 * @tc.name: dcamera_source_input_test_004
203 * @tc.desc: Verify source inptut ReleaseStreams.
204 * @tc.type: FUNC
205 * @tc.require: Issue Number
206 */
207 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_004, TestSize.Level1)
208 {
209 EXPECT_EQ(false, testInput_ == nullptr);
210
211 int32_t rc = testInput_->Init();
212 EXPECT_EQ(rc, DCAMERA_OK);
213
214 rc = testInput_->ConfigStreams(g_streamInfos);
215 EXPECT_EQ(rc, DCAMERA_OK);
216
217 bool isAllRelease = true;
218 rc = testInput_->ReleaseStreams(g_streamIds, isAllRelease);
219 EXPECT_EQ(rc, DCAMERA_OK);
220
221 rc = testInput_->UnInit();
222 EXPECT_EQ(rc, DCAMERA_OK);
223 }
224
225 /**
226 * @tc.name: dcamera_source_input_test_005
227 * @tc.desc: Verify source inptut ReleaseAllStreams.
228 * @tc.type: FUNC
229 * @tc.require: Issue Number
230 */
231 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_005, TestSize.Level1)
232 {
233 EXPECT_EQ(false, testInput_ == nullptr);
234
235 int32_t rc = testInput_->Init();
236 EXPECT_EQ(rc, DCAMERA_OK);
237
238 rc = testInput_->ConfigStreams(g_streamInfos);
239 EXPECT_EQ(rc, DCAMERA_OK);
240
241 rc = testInput_->ReleaseAllStreams();
242 EXPECT_EQ(rc, DCAMERA_OK);
243
244 rc = testInput_->UnInit();
245 EXPECT_EQ(rc, DCAMERA_OK);
246 }
247
248 /**
249 * @tc.name: dcamera_source_input_test_006
250 * @tc.desc: Verify source inptut StartCapture.
251 * @tc.type: FUNC
252 * @tc.require: Issue Number
253 */
254 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_006, TestSize.Level1)
255 {
256 EXPECT_EQ(false, testInput_ == nullptr);
257
258 int32_t rc = testInput_->Init();
259 EXPECT_EQ(rc, DCAMERA_OK);
260
261 rc = testInput_->StartCapture(g_captureInfos);
262 EXPECT_EQ(rc, DCAMERA_OK);
263
264 rc = testInput_->UnInit();
265 EXPECT_EQ(rc, DCAMERA_OK);
266 }
267
268 /**
269 * @tc.name: dcamera_source_input_test_007
270 * @tc.desc: Verify source inptut StopCapture.
271 * @tc.type: FUNC
272 * @tc.require: Issue Number
273 */
274 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_007, TestSize.Level1)
275 {
276 EXPECT_EQ(false, testInput_ == nullptr);
277
278 int32_t rc = testInput_->Init();
279 EXPECT_EQ(rc, DCAMERA_OK);
280
281 rc = testInput_->StartCapture(g_captureInfos);
282 EXPECT_EQ(rc, DCAMERA_OK);
283
284 bool isAllStop = true;
285 rc = testInput_->StopCapture(g_streamIds, isAllStop);
286 EXPECT_EQ(rc, DCAMERA_OK);
287
288 rc = testInput_->UnInit();
289 EXPECT_EQ(rc, DCAMERA_OK);
290 }
291
292 /**
293 * @tc.name: dcamera_source_input_test_008
294 * @tc.desc: Verify source inptut StopAllCapture.
295 * @tc.type: FUNC
296 * @tc.require: Issue Number
297 */
298 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_008, TestSize.Level1)
299 {
300 EXPECT_EQ(false, testInput_ == nullptr);
301
302 int32_t rc = testInput_->Init();
303 EXPECT_EQ(rc, DCAMERA_OK);
304
305 rc = testInput_->StartCapture(g_captureInfos);
306 EXPECT_EQ(rc, DCAMERA_OK);
307
308 rc = testInput_->StopAllCapture();
309 EXPECT_EQ(rc, DCAMERA_OK);
310
311 rc = testInput_->UnInit();
312 EXPECT_EQ(rc, DCAMERA_OK);
313 }
314
315 /**
316 * @tc.name: dcamera_source_input_test_009
317 * @tc.desc: Verify source inptut OpenChannel.
318 * @tc.type: FUNC
319 * @tc.require: Issue Number
320 */
321 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_009, TestSize.Level1)
322 {
323 EXPECT_EQ(false, testInput_ == nullptr);
324
325 int32_t rc = testInput_->Init();
326 EXPECT_EQ(rc, DCAMERA_OK);
327
328 rc = camDev_->InitDCameraSourceDev();
329 EXPECT_EQ(rc, DCAMERA_OK);
330
331 rc = testInput_->OpenChannel(g_camIndexs);
332 EXPECT_NE(rc, DCAMERA_OK);
333 rc = testInput_->UnInit();
334 EXPECT_EQ(rc, DCAMERA_OK);
335 }
336
337 /**
338 * @tc.name: dcamera_source_input_test_010
339 * @tc.desc: Verify source inptut CloseChannel.
340 * @tc.type: FUNC
341 * @tc.require: Issue Number
342 */
343 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_010, TestSize.Level1)
344 {
345 EXPECT_EQ(false, testInput_ == nullptr);
346
347 int32_t rc = testInput_->Init();
348 EXPECT_EQ(rc, DCAMERA_OK);
349
350 rc = camDev_->InitDCameraSourceDev();
351 EXPECT_EQ(rc, DCAMERA_OK);
352
353 rc = testInput_->OpenChannel(g_camIndexs);
354 EXPECT_NE(rc, DCAMERA_OK);
355 rc = testInput_->CloseChannel();
356 EXPECT_EQ(rc, DCAMERA_OK);
357
358 rc = testInput_->UnInit();
359 EXPECT_EQ(rc, DCAMERA_OK);
360 }
361
362 /**
363 * @tc.name: dcamera_source_input_test_011
364 * @tc.desc: Verify source inptut UpdateSettings.
365 * @tc.type: FUNC
366 * @tc.require: Issue Number
367 */
368 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_011, TestSize.Level1)
369 {
370 EXPECT_EQ(false, testInput_ == nullptr);
371
372 int32_t rc = testInput_->Init();
373 EXPECT_EQ(rc, DCAMERA_OK);
374
375 rc = testInput_->UpdateSettings(g_cameraSettings);
376 EXPECT_EQ(rc, DCAMERA_OK);
377
378 rc = testInput_->UnInit();
379 EXPECT_EQ(rc, DCAMERA_OK);
380 }
381
382 /**
383 * @tc.name: dcamera_source_input_test_012
384 * @tc.desc: Verify source inptut OnDataReceived.
385 * @tc.type: FUNC
386 * @tc.require: Issue Number
387 */
388 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_012, TestSize.Level1)
389 {
390 int32_t rc = testInput_->Init();
391 std::vector<std::shared_ptr<DataBuffer>> buffers;
392 size_t capacity = 1;
393 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
394 buffers.push_back(buffer);
395 testInput_->OnDataReceived(DCStreamType::SNAPSHOT_FRAME, buffers);
396 EXPECT_EQ(rc, DCAMERA_OK);
397 }
398
399 /**
400 * @tc.name: dcamera_source_input_test_014
401 * @tc.desc: Verify source inptut EstablishContinuousFrameSession.
402 * @tc.type: FUNC
403 * @tc.require: Issue Number
404 */
405 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_014, TestSize.Level1)
406 {
407 int32_t rc = testInput_->Init();
408 rc = camDev_->InitDCameraSourceDev();
409 EXPECT_EQ(rc, DCAMERA_OK);
410
411 rc = testInput_->EstablishContinuousFrameSession(g_camIndexs);
412 EXPECT_NE(rc, DCAMERA_OK);
413 }
414
415 /**
416 * @tc.name: dcamera_source_input_test_015
417 * @tc.desc: Verify source inptut EstablishSnapshotFrameSession.
418 * @tc.type: FUNC
419 * @tc.require: Issue Number
420 */
421 HWTEST_F(DCameraSourceInputTest, dcamera_source_input_test_015, TestSize.Level1)
422 {
423 int32_t rc = testInput_->Init();
424 rc = camDev_->InitDCameraSourceDev();
425 EXPECT_EQ(rc, DCAMERA_OK);
426
427 testInput_->FinshFrameAsyncTrace(DCStreamType::CONTINUOUS_FRAME);
428 testInput_->FinshFrameAsyncTrace(DCStreamType::SNAPSHOT_FRAME);
429 int32_t state = 0;
430 testInput_->OnSessionState(DCStreamType::CONTINUOUS_FRAME, state);
431 state = 1;
432 testInput_->OnSessionState(DCStreamType::CONTINUOUS_FRAME, state);
433 state = 2;
434 testInput_->OnSessionState(DCStreamType::CONTINUOUS_FRAME, state);
435 rc = testInput_->EstablishSnapshotFrameSession(g_camIndexs);
436 EXPECT_NE(rc, DCAMERA_OK);
437 }
438 } // namespace DistributedHardware
439 } // namespace OHOS
440