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 #define private public
18 #include "dcamera_provider_callback_impl.h"
19 #undef private
20
21 #include "distributed_camera_constants.h"
22 #include "distributed_camera_errno.h"
23 #include "distributed_hardware_log.h"
24 #include "mock_dcamera_source_dev.h"
25 #include "mock_dcamera_source_state_listener.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 class DCameraProviderCallbackImplTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37
38 std::shared_ptr<IDCameraProviderCallback> testProviderCallback_;
39 std::shared_ptr<DCameraSourceDev> camDev_;
40 std::shared_ptr<ICameraStateListener> stateListener_;
41
42 private:
43 static void SetStreamInfos();
44 static void SetCaptureInfos();
45 };
46
47 namespace {
48 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
49 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
50 const std::string TEST_REQID = "0xFFFF";
51 const std::string TEST_PARAM = "0xFFFF";
52 const int32_t TEST_WIDTH = 1920;
53 const int32_t TEST_HEIGTH = 1080;
54 const int32_t TEST_STREAMID = 2;
55 const int32_t SLEEP_TIME = 200000;
56 std::vector<DCStreamInfo> g_streamInfosSnap;
57 std::vector<DCCaptureInfo> g_captureInfoSnap;
58 std::vector<DCameraSettings> g_cameraSettingSnap;
59 std::vector<int> g_streamIdSnap;
60 }
61
SetUpTestCase(void)62 void DCameraProviderCallbackImplTest::SetUpTestCase(void)
63 {
64 SetStreamInfos();
65 SetCaptureInfos();
66 }
67
SetStreamInfos()68 void DCameraProviderCallbackImplTest::SetStreamInfos()
69 {
70 DCStreamInfo streamInfo1;
71 streamInfo1.streamId_ = 1;
72 streamInfo1.width_ = TEST_WIDTH;
73 streamInfo1.height_ = TEST_HEIGTH;
74 streamInfo1.stride_ = 1;
75 streamInfo1.format_ = 1;
76 streamInfo1.dataspace_ = 1;
77 streamInfo1.encodeType_ = ENCODE_TYPE_JPEG;
78 streamInfo1.type_ = SNAPSHOT_FRAME;
79
80 DCStreamInfo streamInfo2;
81 streamInfo2.streamId_ = TEST_STREAMID;
82 streamInfo2.width_ = TEST_WIDTH;
83 streamInfo2.height_ = TEST_HEIGTH;
84 streamInfo2.stride_ = 1;
85 streamInfo2.format_ = 1;
86 streamInfo2.dataspace_ = 1;
87 streamInfo2.encodeType_ = ENCODE_TYPE_JPEG;
88 streamInfo2.type_ = SNAPSHOT_FRAME;
89 g_streamInfosSnap.push_back(streamInfo1);
90 g_streamInfosSnap.push_back(streamInfo2);
91 }
92
SetCaptureInfos()93 void DCameraProviderCallbackImplTest::SetCaptureInfos()
94 {
95 DCCaptureInfo captureInfo1;
96 captureInfo1.streamIds_.push_back(1);
97 captureInfo1.width_ = TEST_WIDTH;
98 captureInfo1.height_ = TEST_HEIGTH;
99 captureInfo1.stride_ = 1;
100 captureInfo1.format_ = 1;
101 captureInfo1.dataspace_ = 1;
102 captureInfo1.encodeType_ = ENCODE_TYPE_H265;
103 captureInfo1.type_ = CONTINUOUS_FRAME;
104
105 DCCaptureInfo captureInfo2;
106 captureInfo2.streamIds_.push_back(1);
107 captureInfo2.width_ = TEST_WIDTH;
108 captureInfo2.height_ = TEST_HEIGTH;
109 captureInfo2.stride_ = 1;
110 captureInfo2.format_ = 1;
111 captureInfo2.dataspace_ = 1;
112 captureInfo2.encodeType_ = ENCODE_TYPE_H265;
113 captureInfo2.type_ = CONTINUOUS_FRAME;
114 g_captureInfoSnap.push_back(captureInfo1);
115 g_captureInfoSnap.push_back(captureInfo2);
116
117 DCameraSettings camSettings1;
118 camSettings1.type_ = UPDATE_METADATA;
119 camSettings1.value_ = "SettingValue";
120
121 DCameraSettings camSettings2;
122 camSettings2.type_ = ENABLE_METADATA;
123 camSettings2.value_ = "SettingValue";
124 g_cameraSettingSnap.push_back(camSettings1);
125 g_cameraSettingSnap.push_back(camSettings2);
126
127 g_streamIdSnap.push_back(1);
128 g_streamIdSnap.push_back(TEST_STREAMID);
129 }
130
TearDownTestCase(void)131 void DCameraProviderCallbackImplTest::TearDownTestCase(void)
132 {
133 }
134
SetUp(void)135 void DCameraProviderCallbackImplTest::SetUp(void)
136 {
137 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
138 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
139 camDev_->InitDCameraSourceDev();
140 testProviderCallback_ = std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_);
141 }
142
TearDown(void)143 void DCameraProviderCallbackImplTest::TearDown(void)
144 {
145 usleep(SLEEP_TIME);
146 testProviderCallback_ = nullptr;
147 camDev_ = nullptr;
148 stateListener_ = nullptr;
149 }
150
151 /**
152 * @tc.name: dcamera_provider_callback_impl_test_001
153 * @tc.desc: Verify OpenSession CloseSession func.
154 * @tc.type: FUNC
155 * @tc.require: issue
156 */
157 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_001, TestSize.Level1)
158 {
159 EXPECT_EQ(false, testProviderCallback_ == nullptr);
160
161 DHBase dhBase;
162 int32_t ret = testProviderCallback_->OpenSession(dhBase);
163 EXPECT_EQ(FAILED, ret);
164
165 ret = testProviderCallback_->CloseSession(dhBase);
166 EXPECT_EQ(FAILED, ret);
167 }
168
169 /**
170 * @tc.name: dcamera_provider_callback_impl_test_002
171 * @tc.desc: Verify OpenSession CloseSession func.
172 * @tc.type: FUNC
173 * @tc.require: issue
174 */
175 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_002, TestSize.Level1)
176 {
177 EXPECT_EQ(false, testProviderCallback_ == nullptr);
178 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
179 int32_t ret = testProviderCallback_->OpenSession(dhBase);
180 EXPECT_EQ(SUCCESS, ret);
181
182 ret = testProviderCallback_->CloseSession(dhBase);
183 EXPECT_EQ(SUCCESS, ret);
184 }
185
186 /**
187 * @tc.name: dcamera_provider_callback_impl_test_003
188 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
189 * @tc.type: FUNC
190 * @tc.require: issue
191 */
192 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_003, TestSize.Level1)
193 {
194 EXPECT_EQ(false, testProviderCallback_ == nullptr);
195
196 DHBase dhBase;
197 std::vector<DCStreamInfo> streamInfos;
198 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, streamInfos);
199 EXPECT_EQ(FAILED, ret);
200
201 std::vector<int> streamIds;
202 ret = testProviderCallback_->ReleaseStreams(dhBase, streamIds);
203 EXPECT_EQ(FAILED, ret);
204 }
205
206 /**
207 * @tc.name: dcamera_provider_callback_impl_test_004
208 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
209 * @tc.type: FUNC
210 * @tc.require: issue
211 */
212 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_004, TestSize.Level1)
213 {
214 EXPECT_EQ(false, testProviderCallback_ == nullptr);
215
216 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
217 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, g_streamInfosSnap);
218 EXPECT_EQ(SUCCESS, ret);
219
220 ret = testProviderCallback_->ReleaseStreams(dhBase, g_streamIdSnap);
221 EXPECT_EQ(SUCCESS, ret);
222 }
223
224 /**
225 * @tc.name: dcamera_provider_callback_impl_test_005
226 * @tc.desc: Verify StartCapture StopCapture func.
227 * @tc.type: FUNC
228 * @tc.require: issue
229 */
230 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_005, TestSize.Level1)
231 {
232 EXPECT_EQ(false, testProviderCallback_ == nullptr);
233
234 DHBase dhBase;
235 std::vector<DCCaptureInfo> captureInfos;
236 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
237 EXPECT_EQ(FAILED, ret);
238
239 std::vector<int> streamIds;
240 ret = testProviderCallback_->StopCapture(dhBase, streamIds);
241 EXPECT_EQ(FAILED, ret);
242 }
243
244 /**
245 * @tc.name: dcamera_provider_callback_impl_test_006
246 * @tc.desc: Verify StartCapture StopCapture func.
247 * @tc.type: FUNC
248 * @tc.require: issue
249 */
250 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_006, TestSize.Level1)
251 {
252 EXPECT_EQ(false, testProviderCallback_ == nullptr);
253
254 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
255 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
256 EXPECT_EQ(SUCCESS, ret);
257
258 ret = testProviderCallback_->StopCapture(dhBase, g_streamIdSnap);
259 EXPECT_EQ(SUCCESS, ret);
260 }
261
262 /**
263 * @tc.name: dcamera_provider_callback_impl_test_007
264 * @tc.desc: Verify UpdateSettings func.
265 * @tc.type: FUNC
266 * @tc.require: issue
267 */
268 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_007, TestSize.Level1)
269 {
270 EXPECT_EQ(false, testProviderCallback_ == nullptr);
271
272 DHBase dhBase;
273 int32_t ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
274 EXPECT_EQ(FAILED, ret);
275 }
276
277 /**
278 * @tc.name: dcamera_provider_callback_impl_test_008
279 * @tc.desc: Verify UpdateSettings func.
280 * @tc.type: FUNC
281 * @tc.require: issue
282 */
283 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_008, TestSize.Level1)
284 {
285 EXPECT_EQ(false, testProviderCallback_ == nullptr);
286
287 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
288 int32_t ret = testProviderCallback_->OpenSession(dhBase);
289 EXPECT_EQ(SUCCESS, ret);
290
291 ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
292 EXPECT_EQ(SUCCESS, ret);
293
294 ret = testProviderCallback_->CloseSession(dhBase);
295 EXPECT_EQ(SUCCESS, ret);
296 }
297
298 /**
299 * @tc.name: dcamera_provider_callback_impl_test_009
300 * @tc.desc: Verify OpenSession CloseSession func.
301 * @tc.type: FUNC
302 * @tc.require: issue
303 */
304 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_009, TestSize.Level1)
305 {
306 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
307 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
308 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
309 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
310 int32_t ret = testProviderCallback->OpenSession(dhBase);
311 EXPECT_EQ(FAILED, ret);
312
313 ret = testProviderCallback->CloseSession(dhBase);
314 EXPECT_EQ(FAILED, ret);
315 }
316
317 /**
318 * @tc.name: dcamera_provider_callback_impl_test_010
319 * @tc.desc: Verify UpdateSettings func.
320 * @tc.type: FUNC
321 * @tc.require: issue
322 */
323 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_010, TestSize.Level1)
324 {
325 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
326 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
327 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
328 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
329 int32_t ret = testProviderCallback->UpdateSettings(dhBase, g_cameraSettingSnap);
330
331 EXPECT_EQ(FAILED, ret);
332 }
333
334 /**
335 * @tc.name: dcamera_provider_callback_impl_test_011
336 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
337 * @tc.type: FUNC
338 * @tc.require: issue
339 */
340 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_011, TestSize.Level1)
341 {
342 EXPECT_EQ(false, testProviderCallback_ == nullptr);
343
344 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
345 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
346 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
347 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
348 std::vector<DCStreamInfo> streamInfos;
349 DCStreamInfo streamInfo11;
350 streamInfo11.streamId_ = 1;
351 streamInfo11.width_ = TEST_WIDTH;
352 streamInfo11.height_ = TEST_HEIGTH;
353 streamInfo11.stride_ = 1;
354 streamInfo11.format_ = 1;
355 streamInfo11.dataspace_ = 1;
356 streamInfo11.encodeType_ = ENCODE_TYPE_JPEG;
357 streamInfo11.type_ = SNAPSHOT_FRAME;
358 streamInfos.push_back(streamInfo11);
359 int32_t ret = testProviderCallback->ConfigureStreams(dhBase, streamInfos);
360 EXPECT_EQ(FAILED, ret);
361
362 std::vector<int> streamIds;
363 ret = testProviderCallback->ReleaseStreams(dhBase, streamIds);
364 EXPECT_EQ(FAILED, ret);
365 }
366
367 /**
368 * @tc.name: dcamera_provider_callback_impl_test_012
369 * @tc.desc: Verify CheckStreamInfo func.
370 * @tc.type: FUNC
371 * @tc.require: issue
372 */
373 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_012, TestSize.Level1)
374 {
375 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
376 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_);
377 DCStreamInfo stream;
378 stream.streamId_ = 1;
379 stream.width_ = TEST_WIDTH;
380 stream.height_ = TEST_HEIGTH;
381 stream.stride_ = 1;
382 stream.format_ = 1;
383 stream.dataspace_ = 1;
384 stream.encodeType_ = ENCODE_TYPE_JPEG;
385 stream.type_ = SNAPSHOT_FRAME;
386 int32_t ret = testProviderCallback->CheckStreamInfo(stream);
387 EXPECT_EQ(true, ret);
388 stream.streamId_ = -1;
389 ret = testProviderCallback->CheckStreamInfo(stream);
390 EXPECT_EQ(false, ret);
391 stream.streamId_ = 1;
392 stream.height_ = -1;
393 ret = testProviderCallback->CheckStreamInfo(stream);
394 EXPECT_EQ(false, ret);
395 stream.streamId_ = 1;
396 stream.height_ = TEST_HEIGTH;
397 stream.width_ = -1;
398 ret = testProviderCallback->CheckStreamInfo(stream);
399 EXPECT_EQ(false, ret);
400 stream.height_ = testProviderCallback->RESOLUTION_MAX_WIDTH;
401 stream.width_ = testProviderCallback->RESOLUTION_MAX_WIDTH + 1;
402 ret = testProviderCallback->CheckStreamInfo(stream);
403 EXPECT_EQ(false, ret);
404 stream.width_ = TEST_WIDTH;
405 stream.height_ = TEST_HEIGTH;
406 stream.stride_ = -1;
407 ret = testProviderCallback->CheckStreamInfo(stream);
408 EXPECT_EQ(false, ret);
409 stream.stride_ = 1;
410 stream.dataspace_ = -1;
411 ret = testProviderCallback->CheckStreamInfo(stream);
412 EXPECT_EQ(false, ret);
413 stream.format_ = -1;
414 stream.dataspace_ = 1;
415 ret = testProviderCallback->CheckStreamInfo(stream);
416 EXPECT_EQ(false, ret);
417 }
418
419 /**
420 * @tc.name: dcamera_provider_callback_impl_test_013
421 * @tc.desc: Verify StartCapture StopCapture func.
422 * @tc.type: FUNC
423 * @tc.require: issue
424 */
425 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_013, TestSize.Level1)
426 {
427 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
428 std::vector<DCCaptureInfo> captureInfos;
429 DCCaptureInfo captureInfo13;
430 captureInfo13.streamIds_.push_back(1);
431 captureInfo13.width_ = TEST_WIDTH;
432 captureInfo13.height_ = TEST_HEIGTH;
433 captureInfo13.stride_ = 1;
434 captureInfo13.format_ = 1;
435 captureInfo13.dataspace_ = 1;
436 captureInfo13.encodeType_ = ENCODE_TYPE_H265;
437 captureInfo13.type_ = CONTINUOUS_FRAME;
438 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
439 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
440 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
441 int32_t ret = testProviderCallback->StartCapture(dhBase, captureInfos);
442 EXPECT_EQ(FAILED, ret);
443
444 std::vector<int> streamIds;
445 ret = testProviderCallback->StopCapture(dhBase, streamIds);
446 EXPECT_EQ(FAILED, ret);
447 }
448
449 /**
450 * @tc.name: dcamera_provider_callback_impl_test_014
451 * @tc.desc: Verify NotifyEvent func.
452 * @tc.type: FUNC
453 * @tc.require: issue
454 */
455 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_014, TestSize.Level1)
456 {
457 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
458 DCameraHDFEvent event;
459 event.type_ = DCameraEventType::DCAMERE_GETFULLCAP;
460 int32_t ret = testProviderCallback_->NotifyEvent(dhBase, event);
461 EXPECT_EQ(SUCCESS, ret);
462 event.type_ = DCameraEventType::DCAMERA_MESSAGE;
463 ret = testProviderCallback_->NotifyEvent(dhBase, event);
464 EXPECT_EQ(SUCCESS, ret);
465 }
466 } // namespace DistributedHardware
467 } // namespace OHOS
468