1 /*
2 * Copyright (c) 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
18 #include "dcamera_host.h"
19 #include "dcamera_provider.h"
20 #include "dcamera_test_utils.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedHardware {
26 class DcameraProviderTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp(void);
31 void TearDown(void);
32 };
33
34 constexpr const char* TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
35 const uint32_t ABILITYINFO_MAX_LENGTH = 50 * 1024 * 1024;
36
SetUpTestCase(void)37 void DcameraProviderTest::SetUpTestCase(void)
38 {
39 }
40
TearDownTestCase(void)41 void DcameraProviderTest::TearDownTestCase(void)
42 {
43 }
44
SetUp(void)45 void DcameraProviderTest::SetUp(void)
46 {
47 }
48
TearDown(void)49 void DcameraProviderTest::TearDown(void)
50 {
51 }
52
53 /**
54 * @tc.name: GetAbilityInfo_001
55 * @tc.desc: Verify GetAbilityInfo
56 * @tc.type: FUNC
57 * @tc.require: AR
58 */
59 HWTEST_F(DcameraProviderTest, GetAbilityInfo_001, TestSize.Level1)
60 {
61 std::string abilityInfo;
62 std::string sinkAbilityInfo;
63 std::string sourceCodecInfo;
64 auto ret = DCameraProvider::GetInstance()->GetAbilityInfo(abilityInfo, sinkAbilityInfo, sourceCodecInfo);
65 EXPECT_EQ(ret, false);
66
67 abilityInfo = "not a json object";
68 ret = DCameraProvider::GetInstance()->GetAbilityInfo(abilityInfo, sinkAbilityInfo, sourceCodecInfo);
69 EXPECT_EQ(ret, false);
70
71 abilityInfo = "{\"SourceCodec\": {}}";
72 ret = DCameraProvider::GetInstance()->GetAbilityInfo(abilityInfo, sinkAbilityInfo, sourceCodecInfo);
73 EXPECT_EQ(ret, false);
74
75 abilityInfo = "{\"SinkAbility\": \"not an object\", \"SourceCodec\": {}}";
76 ret = DCameraProvider::GetInstance()->GetAbilityInfo(abilityInfo, sinkAbilityInfo, sourceCodecInfo);
77 EXPECT_EQ(ret, false);
78 }
79
80 /**
81 * @tc.name: EnableDCameraDevice_001
82 * @tc.desc: Verify EnableDCameraDevice
83 * @tc.type: FUNC
84 * @tc.require: AR
85 */
86 HWTEST_F(DcameraProviderTest, EnableDCameraDevice_001, TestSize.Level1)
87 {
88 DHBase dhBase;
89 std::string abilityInfo;
90 sptr<IDCameraProviderCallback> callbackObj = nullptr;
91 auto ret = DCameraProvider::GetInstance()->EnableDCameraDevice(dhBase, abilityInfo, callbackObj);
92 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
93 }
94
95 /**
96 * @tc.name: EnableDCameraDevice_002
97 * @tc.desc: Verify EnableDCameraDevice
98 * @tc.type: FUNC
99 * @tc.require: AR
100 */
101 HWTEST_F(DcameraProviderTest, EnableDCameraDevice_002, TestSize.Level1)
102 {
103 DHBase dhBase;
104 std::string abilityInfo;
105 sptr<IDCameraProviderCallback> callbackObj = nullptr;
106 dhBase.deviceId_ = "deviceId";
107 dhBase.dhId_ = "dhId";
108 auto ret = DCameraProvider::GetInstance()->EnableDCameraDevice(dhBase, abilityInfo, callbackObj);
109 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
110 }
111
112 /**
113 * @tc.name: EnableDCameraDevice_003
114 * @tc.desc: Verify EnableDCameraDevice
115 * @tc.type: FUNC
116 * @tc.require: AR
117 */
118 HWTEST_F(DcameraProviderTest, EnableDCameraDevice_003, TestSize.Level1)
119 {
120 DHBase dhBase;
121 std::string abilityInfo(ABILITYINFO_MAX_LENGTH + 1, 'a');
122 sptr<IDCameraProviderCallback> callbackObj = nullptr;
123 dhBase.deviceId_ = "deviceId";
124 dhBase.dhId_ = "dhId";
125 auto ret = DCameraProvider::GetInstance()->EnableDCameraDevice(dhBase, abilityInfo, callbackObj);
126 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
127 }
128
129 /**
130 * @tc.name: EnableDCameraDevice_004
131 * @tc.desc: Verify EnableDCameraDevice
132 * @tc.type: FUNC
133 * @tc.require: AR
134 */
135 HWTEST_F(DcameraProviderTest, EnableDCameraDevice_004, TestSize.Level1)
136 {
137 DHBase dhBase;
138 std::string abilityInfo = "abilityInfo";
139 sptr<IDCameraProviderCallback> callbackObj = nullptr;
140 dhBase.deviceId_ = "deviceId";
141 dhBase.dhId_ = "dhId";
142 auto ret = DCameraProvider::GetInstance()->EnableDCameraDevice(dhBase, abilityInfo, callbackObj);
143 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
144 }
145
146 /**
147 * @tc.name: DisableDCameraDevice_001
148 * @tc.desc: Verify DisableDCameraDevice
149 * @tc.type: FUNC
150 * @tc.require: AR
151 */
152 HWTEST_F(DcameraProviderTest, DisableDCameraDevice_001, TestSize.Level1)
153 {
154 DHBase dhBase;
155 auto ret = DCameraProvider::GetInstance()->DisableDCameraDevice(dhBase);
156 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
157 }
158
159 /**
160 * @tc.name: DisableDCameraDevice_002
161 * @tc.desc: Verify DisableDCameraDevice
162 * @tc.type: FUNC
163 * @tc.require: AR
164 */
165 HWTEST_F(DcameraProviderTest, DisableDCameraDevice_002, TestSize.Level1)
166 {
167 DHBase dhBase;
168 dhBase.deviceId_ = "deviceId";
169 dhBase.dhId_ = "dhId";
170 auto ret = DCameraProvider::GetInstance()->DisableDCameraDevice(dhBase);
171 EXPECT_NE(ret, DCamRetCode::DEVICE_NOT_INIT);
172 }
173
174 /**
175 * @tc.name: AcquireBuffer_001
176 * @tc.desc: Verify AcquireBuffer
177 * @tc.type: FUNC
178 * @tc.require: AR
179 */
180 HWTEST_F(DcameraProviderTest, AcquireBuffer_001, TestSize.Level1)
181 {
182 DHBase dhBase;
183 int32_t streamId = 0;
184 DCameraBuffer buffer;
185 auto ret = DCameraProvider::GetInstance()->AcquireBuffer(dhBase, streamId, buffer);
186 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
187 }
188
189 /**
190 * @tc.name: AcquireBuffer_002
191 * @tc.desc: Verify AcquireBuffer
192 * @tc.type: FUNC
193 * @tc.require: AR
194 */
195 HWTEST_F(DcameraProviderTest, AcquireBuffer_002, TestSize.Level1)
196 {
197 DHBase dhBase;
198 int32_t streamId = -1;
199 DCameraBuffer buffer;
200 dhBase.deviceId_ = "deviceId";
201 dhBase.dhId_ = "dhId";
202 auto ret = DCameraProvider::GetInstance()->AcquireBuffer(dhBase, streamId, buffer);
203 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
204 }
205
206 /**
207 * @tc.name: AcquireBuffer_003
208 * @tc.desc: Verify AcquireBuffer
209 * @tc.type: FUNC
210 * @tc.require: AR
211 */
212 HWTEST_F(DcameraProviderTest, AcquireBuffer_003, TestSize.Level1)
213 {
214 DHBase dhBase;
215 int32_t streamId = 1;
216 DCameraBuffer buffer;
217 dhBase.deviceId_ = "deviceId";
218 dhBase.dhId_ = "dhId";
219 auto ret = DCameraProvider::GetInstance()->AcquireBuffer(dhBase, streamId, buffer);
220 EXPECT_NE(ret, DCamRetCode::SUCCESS);
221 }
222
223 /**
224 * @tc.name: ShutterBuffer_001
225 * @tc.desc: Verify ShutterBuffer
226 * @tc.type: FUNC
227 * @tc.require: AR
228 */
229 HWTEST_F(DcameraProviderTest, ShutterBuffer_001, TestSize.Level1)
230 {
231 DHBase dhBase;
232 int32_t streamId = 0;
233 DCameraBuffer buffer;
234 auto ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer);
235 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
236 }
237
238 /**
239 * @tc.name: ShutterBuffer_002
240 * @tc.desc: Verify ShutterBuffer
241 * @tc.type: FUNC
242 * @tc.require: AR
243 */
244 HWTEST_F(DcameraProviderTest, ShutterBuffer_002, TestSize.Level1)
245 {
246 DHBase dhBase;
247 int32_t streamId = 0;
248 DCameraBuffer buffer;
249 buffer.index_ = -1;
250 dhBase.deviceId_ = "deviceId";
251 dhBase.dhId_ = "dhId";
252 auto ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer);
253 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
254
255 buffer.index_ = 1;
256 buffer.size_ = -1;
257 ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer);
258 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
259 }
260
261 /**
262 * @tc.name: ShutterBuffer_003
263 * @tc.desc: Verify ShutterBuffer
264 * @tc.type: FUNC
265 * @tc.require: AR
266 */
267 HWTEST_F(DcameraProviderTest, ShutterBuffer_003, TestSize.Level1)
268 {
269 DHBase dhBase;
270 int32_t streamId = -1;
271 DCameraBuffer buffer;
272 buffer.index_ = 1;
273 buffer.size_ = 1;
274 dhBase.deviceId_ = "deviceId";
275 dhBase.dhId_ = "dhId";
276 auto ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer);
277 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
278
279 streamId = 1;
280 ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer);
281 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
282 }
283
284 /**
285 * @tc.name: OnSettingsResult_001
286 * @tc.desc: Verify OnSettingsResult
287 * @tc.type: FUNC
288 * @tc.require: AR
289 */
290 HWTEST_F(DcameraProviderTest, OnSettingsResult_001, TestSize.Level1)
291 {
292 DHBase dhBase;
293 DCameraSettings result;
294 auto ret = DCameraProvider::GetInstance()->OnSettingsResult(dhBase, result);
295 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
296 }
297
298 /**
299 * @tc.name: OnSettingsResult_002
300 * @tc.desc: Verify OnSettingsResult
301 * @tc.type: FUNC
302 * @tc.require: AR
303 */
304 HWTEST_F(DcameraProviderTest, OnSettingsResult_002, TestSize.Level1)
305 {
306 DHBase dhBase;
307 DCameraSettings result;
308 dhBase.deviceId_ = "deviceId";
309 dhBase.dhId_ = "dhId";
310 auto ret = DCameraProvider::GetInstance()->OnSettingsResult(dhBase, result);
311 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
312 }
313
314 /**
315 * @tc.name: OnSettingsResult_003
316 * @tc.desc: Verify OnSettingsResult
317 * @tc.type: FUNC
318 * @tc.require: AR
319 */
320 HWTEST_F(DcameraProviderTest, OnSettingsResult_003, TestSize.Level1)
321 {
322 DHBase dhBase;
323 DCameraSettings result;
324 dhBase.deviceId_ = "deviceId";
325 dhBase.dhId_ = "dhId";
326 result.value_ = "value";
327 auto ret = DCameraProvider::GetInstance()->OnSettingsResult(dhBase, result);
328 EXPECT_NE(ret, DCamRetCode::SUCCESS);
329 }
330
331 /**
332 * @tc.name: Notify_001
333 * @tc.desc: Verify Notify
334 * @tc.type: FUNC
335 * @tc.require: AR
336 */
337 HWTEST_F(DcameraProviderTest, Notify_001, TestSize.Level1)
338 {
339 DHBase dhBase;
340 DCameraHDFEvent event;
341 auto ret = DCameraProvider::GetInstance()->Notify(dhBase, event);
342 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
343 }
344
345 /**
346 * @tc.name: Notify_002
347 * @tc.desc: Verify Notify
348 * @tc.type: FUNC
349 * @tc.require: AR
350 */
351 HWTEST_F(DcameraProviderTest, Notify_002, TestSize.Level1)
352 {
353 DHBase dhBase;
354 DCameraHDFEvent event;
355 dhBase.deviceId_ = "deviceId";
356 dhBase.dhId_ = "dhId";
357 auto ret = DCameraProvider::GetInstance()->Notify(dhBase, event);
358 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
359 }
360
361 /**
362 * @tc.name: Notify_003
363 * @tc.desc: Verify Notify
364 * @tc.type: FUNC
365 * @tc.require: AR
366 */
367 HWTEST_F(DcameraProviderTest, Notify_003, TestSize.Level1)
368 {
369 DHBase dhBase;
370 DCameraHDFEvent event;
371 std::string str(ABILITYINFO_MAX_LENGTH + 1, 'a');
372 dhBase.deviceId_ = "deviceId";
373 dhBase.dhId_ = "dhId";
374 event.content_ = str;
375 auto ret = DCameraProvider::GetInstance()->Notify(dhBase, event);
376 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
377 }
378
379 /**
380 * @tc.name: Notify_004
381 * @tc.desc: Verify Notify
382 * @tc.type: FUNC
383 * @tc.require: AR
384 */
385 HWTEST_F(DcameraProviderTest, Notify_004, TestSize.Level1)
386 {
387 DHBase dhBase;
388 DCameraHDFEvent event;
389 dhBase.deviceId_ = "deviceId";
390 dhBase.dhId_ = "dhId";
391 event.content_ = "content";
392 auto ret = DCameraProvider::GetInstance()->Notify(dhBase, event);
393 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
394 }
395
396 /**
397 * @tc.name: RegisterCameraHdfListener_001
398 * @tc.desc: Verify RegisterCameraHdfListener
399 * @tc.type: FUNC
400 * @tc.require: AR
401 */
402 HWTEST_F(DcameraProviderTest, RegisterCameraHdfListener_001, TestSize.Level1)
403 {
404 sptr<IDCameraHdfCallback> callback = nullptr;
405 EXPECT_EQ(DCamRetCode::INVALID_ARGUMENT,
406 DCameraProvider::GetInstance()->RegisterCameraHdfListener(TEST_DEVICE_ID, callback));
407 }
408
409 /**
410 * @tc.name: UnRegisterCameraHdfListener_001
411 * @tc.desc: Verify UnRegisterCameraHdfListener
412 * @tc.type: FUNC
413 * @tc.require: AR
414 */
415 HWTEST_F(DcameraProviderTest, UnRegisterCameraHdfListener_001, TestSize.Level1)
416 {
417 EXPECT_EQ(DCamRetCode::FAILED,
418 DCameraProvider::GetInstance()->UnRegisterCameraHdfListener(TEST_DEVICE_ID));
419 }
420
421 /**
422 * @tc.name: OpenSession_001
423 * @tc.desc: Verify OpenSession
424 * @tc.type: FUNC
425 * @tc.require: AR
426 */
427 HWTEST_F(DcameraProviderTest, OpenSession_001, TestSize.Level1)
428 {
429 DHBase dhBase;
430 DCameraHost::GetInstance()->dCameraDeviceMap_.clear();
431 auto ret = DCameraProvider::GetInstance()->OpenSession(dhBase);
432 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
433 }
434
435 /**
436 * @tc.name: CloseSession_001
437 * @tc.desc: Verify CloseSession
438 * @tc.type: FUNC
439 * @tc.require: AR
440 */
441 HWTEST_F(DcameraProviderTest, CloseSession_001, TestSize.Level1)
442 {
443 DHBase dhBase;
444 auto ret = DCameraProvider::GetInstance()->CloseSession(dhBase);
445 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
446 }
447
448 /**
449 * @tc.name: ConfigureStreams_001
450 * @tc.desc: Verify ConfigureStreams
451 * @tc.type: FUNC
452 * @tc.require: AR
453 */
454 HWTEST_F(DcameraProviderTest, ConfigureStreams_001, TestSize.Level1)
455 {
456 DHBase dhBase;
457 std::vector<DCStreamInfo> streamInfos;
458 auto ret = DCameraProvider::GetInstance()->ConfigureStreams(dhBase, streamInfos);
459 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
460 }
461
462 /**
463 * @tc.name: ReleaseStreams_001
464 * @tc.desc: Verify ReleaseStreams
465 * @tc.type: FUNC
466 * @tc.require: AR
467 */
468 HWTEST_F(DcameraProviderTest, ReleaseStreams_001, TestSize.Level1)
469 {
470 DHBase dhBase;
471 std::vector<int> streamInfos;
472 auto ret = DCameraProvider::GetInstance()->ReleaseStreams(dhBase, streamInfos);
473 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
474 }
475
476 /**
477 * @tc.name: StartCapture_001
478 * @tc.desc: Verify StartCapture
479 * @tc.type: FUNC
480 * @tc.require: AR
481 */
482 HWTEST_F(DcameraProviderTest, StartCapture_001, TestSize.Level1)
483 {
484 DHBase dhBase;
485 std::vector<DCCaptureInfo> streamInfos;
486 auto ret = DCameraProvider::GetInstance()->StartCapture(dhBase, streamInfos);
487 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
488 }
489
490 /**
491 * @tc.name: StopCapture_001
492 * @tc.desc: Verify StopCapture
493 * @tc.type: FUNC
494 * @tc.require: AR
495 */
496 HWTEST_F(DcameraProviderTest, StopCapture_001, TestSize.Level1)
497 {
498 DHBase dhBase;
499 std::vector<int> streamInfos;
500 auto ret = DCameraProvider::GetInstance()->StopCapture(dhBase, streamInfos);
501 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
502 }
503
504 /**
505 * @tc.name: UpdateSettings_001
506 * @tc.desc: Verify UpdateSettings
507 * @tc.type: FUNC
508 * @tc.require: AR
509 */
510 HWTEST_F(DcameraProviderTest, UpdateSettings_001, TestSize.Level1)
511 {
512 DHBase dhBase;
513 std::vector<DCameraSettings> settings;
514 auto ret = DCameraProvider::GetInstance()->UpdateSettings(dhBase, settings);
515 EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT);
516 }
517
518 /**
519 * @tc.name: GetDCameraDevice_001
520 * @tc.desc: Verify GetDCameraDevice
521 * @tc.type: FUNC
522 * @tc.require: AR
523 */
524 HWTEST_F(DcameraProviderTest, GetDCameraDevice_001, TestSize.Level1)
525 {
526 DHBase dhBase;
527 auto ret = DCameraProvider::GetInstance()->GetDCameraDevice(dhBase);
528 EXPECT_EQ(ret, nullptr);
529 }
530 }
531 }