1 /*
2 * Copyright (c) 2022-2025 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 }
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 g_streamInfosSnap.clear();
136 g_captureInfoSnap.clear();
137 g_cameraSettingSnap.clear();
138 g_streamIdSnap.clear();
139
140 SetStreamInfos();
141 SetCaptureInfos();
142
143 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
144 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
145 camDev_->InitDCameraSourceDev();
146 testProviderCallback_ = std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_);
147 }
148
TearDown(void)149 void DCameraProviderCallbackImplTest::TearDown(void)
150 {
151 usleep(SLEEP_TIME);
152 testProviderCallback_ = nullptr;
153 camDev_ = nullptr;
154 stateListener_ = nullptr;
155 }
156
157 /**
158 * @tc.name: dcamera_provider_callback_impl_test_001
159 * @tc.desc: Verify OpenSession CloseSession func.
160 * @tc.type: FUNC
161 * @tc.require: issue
162 */
163 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_001, TestSize.Level0)
164 {
165 EXPECT_EQ(false, testProviderCallback_ == nullptr);
166
167 DHBase dhBase;
168 int32_t ret = testProviderCallback_->OpenSession(dhBase);
169 EXPECT_EQ(FAILED, ret);
170
171 ret = testProviderCallback_->CloseSession(dhBase);
172 EXPECT_EQ(FAILED, ret);
173 }
174
175 /**
176 * @tc.name: dcamera_provider_callback_impl_test_002
177 * @tc.desc: Verify OpenSession CloseSession func.
178 * @tc.type: FUNC
179 * @tc.require: issue
180 */
181 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_002, TestSize.Level0)
182 {
183 EXPECT_EQ(false, testProviderCallback_ == nullptr);
184 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
185 int32_t ret = testProviderCallback_->OpenSession(dhBase);
186 EXPECT_EQ(SUCCESS, ret);
187
188 ret = testProviderCallback_->CloseSession(dhBase);
189 EXPECT_EQ(SUCCESS, ret);
190 }
191
192 /**
193 * @tc.name: dcamera_provider_callback_impl_test_003
194 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
195 * @tc.type: FUNC
196 * @tc.require: issue
197 */
198 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_003, TestSize.Level0)
199 {
200 EXPECT_EQ(false, testProviderCallback_ == nullptr);
201
202 DHBase dhBase;
203 std::vector<DCStreamInfo> streamInfos;
204 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, streamInfos);
205 EXPECT_EQ(FAILED, ret);
206
207 std::vector<int> streamIds;
208 ret = testProviderCallback_->ReleaseStreams(dhBase, streamIds);
209 EXPECT_EQ(FAILED, ret);
210 }
211
212 /**
213 * @tc.name: dcamera_provider_callback_impl_test_004
214 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
215 * @tc.type: FUNC
216 * @tc.require: issue
217 */
218 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_004, TestSize.Level0)
219 {
220 EXPECT_EQ(false, testProviderCallback_ == nullptr);
221
222 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
223 int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, g_streamInfosSnap);
224 EXPECT_EQ(SUCCESS, ret);
225
226 ret = testProviderCallback_->ReleaseStreams(dhBase, g_streamIdSnap);
227 EXPECT_EQ(SUCCESS, ret);
228 }
229
230 /**
231 * @tc.name: dcamera_provider_callback_impl_test_005
232 * @tc.desc: Verify StartCapture StopCapture func.
233 * @tc.type: FUNC
234 * @tc.require: issue
235 */
236 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_005, TestSize.Level0)
237 {
238 EXPECT_EQ(false, testProviderCallback_ == nullptr);
239
240 DHBase dhBase;
241 std::vector<DCCaptureInfo> captureInfos;
242 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
243 EXPECT_EQ(FAILED, ret);
244
245 std::vector<int> streamIds;
246 ret = testProviderCallback_->StopCapture(dhBase, streamIds);
247 EXPECT_EQ(FAILED, ret);
248 }
249
250 /**
251 * @tc.name: dcamera_provider_callback_impl_test_006
252 * @tc.desc: Verify StartCapture StopCapture func.
253 * @tc.type: FUNC
254 * @tc.require: issue
255 */
256 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_006, TestSize.Level0)
257 {
258 EXPECT_EQ(false, testProviderCallback_ == nullptr);
259
260 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
261 int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap);
262 EXPECT_EQ(SUCCESS, ret);
263
264 ret = testProviderCallback_->StopCapture(dhBase, g_streamIdSnap);
265 EXPECT_EQ(SUCCESS, ret);
266 }
267
268 /**
269 * @tc.name: dcamera_provider_callback_impl_test_007
270 * @tc.desc: Verify UpdateSettings func.
271 * @tc.type: FUNC
272 * @tc.require: issue
273 */
274 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_007, TestSize.Level0)
275 {
276 EXPECT_EQ(false, testProviderCallback_ == nullptr);
277
278 DHBase dhBase;
279 int32_t ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
280 EXPECT_EQ(FAILED, ret);
281 }
282
283 /**
284 * @tc.name: dcamera_provider_callback_impl_test_008
285 * @tc.desc: Verify UpdateSettings func.
286 * @tc.type: FUNC
287 * @tc.require: issue
288 */
289 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_008, TestSize.Level0)
290 {
291 EXPECT_EQ(false, testProviderCallback_ == nullptr);
292
293 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
294 int32_t ret = testProviderCallback_->OpenSession(dhBase);
295 EXPECT_EQ(SUCCESS, ret);
296
297 ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap);
298 EXPECT_EQ(SUCCESS, ret);
299
300 ret = testProviderCallback_->CloseSession(dhBase);
301 EXPECT_EQ(SUCCESS, ret);
302 }
303
304 /**
305 * @tc.name: dcamera_provider_callback_impl_test_009
306 * @tc.desc: Verify OpenSession CloseSession func.
307 * @tc.type: FUNC
308 * @tc.require: issue
309 */
310 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_009, TestSize.Level0)
311 {
312 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
313 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
314 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
315 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
316 int32_t ret = testProviderCallback->OpenSession(dhBase);
317 EXPECT_EQ(FAILED, ret);
318
319 ret = testProviderCallback->CloseSession(dhBase);
320 EXPECT_EQ(FAILED, ret);
321 }
322
323 /**
324 * @tc.name: dcamera_provider_callback_impl_test_010
325 * @tc.desc: Verify UpdateSettings func.
326 * @tc.type: FUNC
327 * @tc.require: issue
328 */
329 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_010, TestSize.Level0)
330 {
331 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
332 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
333 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
334 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
335 int32_t ret = testProviderCallback->UpdateSettings(dhBase, g_cameraSettingSnap);
336
337 EXPECT_EQ(FAILED, ret);
338 }
339
340 /**
341 * @tc.name: dcamera_provider_callback_impl_test_011
342 * @tc.desc: Verify ConfigureStreams ReleaseStreams func.
343 * @tc.type: FUNC
344 * @tc.require: issue
345 */
346 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_011, TestSize.Level0)
347 {
348 EXPECT_EQ(false, testProviderCallback_ == nullptr);
349
350 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
351 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
352 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
353 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
354 std::vector<DCStreamInfo> streamInfos;
355 DCStreamInfo streamInfo11;
356 streamInfo11.streamId_ = 1;
357 streamInfo11.width_ = TEST_WIDTH;
358 streamInfo11.height_ = TEST_HEIGTH;
359 streamInfo11.stride_ = 1;
360 streamInfo11.format_ = 1;
361 streamInfo11.dataspace_ = 1;
362 streamInfo11.encodeType_ = ENCODE_TYPE_JPEG;
363 streamInfo11.type_ = SNAPSHOT_FRAME;
364 streamInfos.push_back(streamInfo11);
365 int32_t ret = testProviderCallback->ConfigureStreams(dhBase, streamInfos);
366 EXPECT_EQ(FAILED, ret);
367
368 std::vector<int> streamIds;
369 ret = testProviderCallback->ReleaseStreams(dhBase, streamIds);
370 EXPECT_EQ(FAILED, ret);
371 }
372
373 /**
374 * @tc.name: dcamera_provider_callback_impl_test_012
375 * @tc.desc: Verify CheckStreamInfo func.
376 * @tc.type: FUNC
377 * @tc.require: issue
378 */
379 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_012, TestSize.Level1)
380 {
381 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
382 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_);
383 DCStreamInfo stream;
384 stream.streamId_ = 1;
385 stream.width_ = TEST_WIDTH;
386 stream.height_ = TEST_HEIGTH;
387 stream.stride_ = 1;
388 stream.format_ = 1;
389 stream.dataspace_ = 1;
390 stream.encodeType_ = ENCODE_TYPE_JPEG;
391 stream.type_ = SNAPSHOT_FRAME;
392 int32_t ret = testProviderCallback->CheckStreamInfo(stream);
393 EXPECT_EQ(true, ret);
394 stream.streamId_ = -1;
395 ret = testProviderCallback->CheckStreamInfo(stream);
396 EXPECT_EQ(false, ret);
397 stream.streamId_ = 1;
398 stream.height_ = -1;
399 ret = testProviderCallback->CheckStreamInfo(stream);
400 EXPECT_EQ(false, ret);
401 stream.streamId_ = 1;
402 stream.height_ = TEST_HEIGTH;
403 stream.width_ = -1;
404 ret = testProviderCallback->CheckStreamInfo(stream);
405 EXPECT_EQ(false, ret);
406 stream.height_ = testProviderCallback->RESOLUTION_MAX_WIDTH;
407 stream.width_ = testProviderCallback->RESOLUTION_MAX_WIDTH + 1;
408 ret = testProviderCallback->CheckStreamInfo(stream);
409 EXPECT_EQ(false, ret);
410 stream.width_ = TEST_WIDTH;
411 stream.height_ = TEST_HEIGTH;
412 stream.stride_ = -1;
413 ret = testProviderCallback->CheckStreamInfo(stream);
414 EXPECT_EQ(false, ret);
415 stream.stride_ = 1;
416 stream.dataspace_ = -1;
417 ret = testProviderCallback->CheckStreamInfo(stream);
418 EXPECT_EQ(false, ret);
419 stream.format_ = -1;
420 stream.dataspace_ = 1;
421 ret = testProviderCallback->CheckStreamInfo(stream);
422 EXPECT_EQ(false, ret);
423 }
424
425 /**
426 * @tc.name: dcamera_provider_callback_impl_test_013
427 * @tc.desc: Verify StartCapture StopCapture func.
428 * @tc.type: FUNC
429 * @tc.require: issue
430 */
431 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_013, TestSize.Level0)
432 {
433 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
434 std::vector<DCCaptureInfo> captureInfos;
435 DCCaptureInfo captureInfo13;
436 captureInfo13.streamIds_.push_back(1);
437 captureInfo13.width_ = TEST_WIDTH;
438 captureInfo13.height_ = TEST_HEIGTH;
439 captureInfo13.stride_ = 1;
440 captureInfo13.format_ = 1;
441 captureInfo13.dataspace_ = 1;
442 captureInfo13.encodeType_ = ENCODE_TYPE_H265;
443 captureInfo13.type_ = CONTINUOUS_FRAME;
444 std::shared_ptr<DCameraSourceDev> camDev = nullptr;
445 std::shared_ptr<DCameraProviderCallbackImpl> testProviderCallback =
446 std::make_shared<DCameraProviderCallbackImpl>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev);
447 int32_t ret = testProviderCallback->StartCapture(dhBase, captureInfos);
448 EXPECT_EQ(FAILED, ret);
449
450 std::vector<int> streamIds;
451 ret = testProviderCallback->StopCapture(dhBase, streamIds);
452 EXPECT_EQ(FAILED, ret);
453 }
454
455 /**
456 * @tc.name: dcamera_provider_callback_impl_test_014
457 * @tc.desc: Verify NotifyEvent func.
458 * @tc.type: FUNC
459 * @tc.require: issue
460 */
461 HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_014, TestSize.Level0)
462 {
463 DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0};
464 DCameraHDFEvent event;
465 event.type_ = DCameraEventType::DCAMERE_GETFULLCAP;
466 int32_t ret = testProviderCallback_->NotifyEvent(dhBase, event);
467 EXPECT_EQ(SUCCESS, ret);
468 event.type_ = DCameraEventType::DCAMERA_MESSAGE;
469 ret = testProviderCallback_->NotifyEvent(dhBase, event);
470 EXPECT_EQ(SUCCESS, ret);
471 }
472 } // namespace DistributedHardware
473 } // namespace OHOS
474