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
18 #define private public
19 #include "dcamera_source_dev.h"
20 #undef private
21
22 #include "accesstoken_kit.h"
23 #include "dcamera_source_state.h"
24 #include "dcamera_utils_tools.h"
25 #include "distributed_camera_errno.h"
26 #include "dcamera_source_dev.h"
27 #include "mock_dcamera_source_dev.h"
28 #include "mock_dcamera_source_controller.h"
29 #include "mock_dcamera_source_input.h"
30 #include "mock_dcamera_source_state_listener.h"
31 #include "nativetoken_kit.h"
32 #include "token_setproc.h"
33
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace DistributedHardware {
38 class DCameraSourceDevTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 void SetTokenID();
45
46 std::shared_ptr<DCameraSourceDev> camDev_;
47 std::shared_ptr<ICameraStateListener> stateListener_;
48 std::shared_ptr<ICameraController> controller_;
49 };
50
51 namespace {
52 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
53 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
54 const std::string TEST_REQID = "";
55 const std::string TEST_VER = "1.0";
56 const std::string TEST_SINK_ATTRS = "";
57 const std::string TEST_SRC_ATTRS = "";
58 const int32_t TEST_WIDTH = 1920;
59 const int32_t TEST_HEIGTH = 1080;
60 const int32_t TEST_SLEEP_SEC = 200000;
61 std::string TEST_EVENT_CMD_JSON = R"({
62 "Type": "MESSAGE",
63 "dhId": "camrea_0",
64 "Command": "STATE_NOTIFY",
65 "Value": {"EventType": 1, "EventResult": 1, "EventContent": "TestContent"}
66 })";
67 }
68
SetTokenID()69 void DCameraSourceDevTest::SetTokenID()
70 {
71 uint64_t tokenId;
72 const char *perms[2];
73 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
74 perms[1] = "ohos.permission.CAMERA";
75 NativeTokenInfoParams infoInstance = {
76 .dcapsNum = 0,
77 .permsNum = 2,
78 .aclsNum = 0,
79 .dcaps = NULL,
80 .perms = perms,
81 .acls = NULL,
82 .processName = "dcamera_source_dev_test",
83 .aplStr = "system_basic",
84 };
85 tokenId = GetAccessTokenId(&infoInstance);
86 SetSelfTokenID(tokenId);
87 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
88 }
89
SetUpTestCase(void)90 void DCameraSourceDevTest::SetUpTestCase(void)
91 {
92 }
93
TearDownTestCase(void)94 void DCameraSourceDevTest::TearDownTestCase(void)
95 {
96 }
97
SetUp(void)98 void DCameraSourceDevTest::SetUp(void)
99 {
100 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
101 camDev_ = std::make_shared<DCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
102 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
103 }
104
TearDown(void)105 void DCameraSourceDevTest::TearDown(void)
106 {
107 usleep(TEST_SLEEP_SEC);
108 camDev_ = nullptr;
109 stateListener_ = nullptr;
110 }
111
112 /**
113 * @tc.name: dcamera_source_dev_test_001
114 * @tc.desc: Verify source dev InitDCameraSourceDev.
115 * @tc.type: FUNC
116 * @tc.require: Issue Number
117 */
118 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_001, TestSize.Level1)
119 {
120 int32_t ret = camDev_->InitDCameraSourceDev();
121 EXPECT_EQ(DCAMERA_OK, ret);
122 }
123
124 /**
125 * @tc.name: dcamera_source_dev_test_002
126 * @tc.desc: Verify source dev RegisterDistributedHardware.
127 * @tc.type: FUNC
128 * @tc.require: Issue Number
129 */
130 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_002, TestSize.Level1)
131 {
132 camDev_->InitDCameraSourceDev();
133 EnableParam param;
134 param.sinkVersion = TEST_VER;
135 param.sinkAttrs = TEST_SINK_ATTRS;
136 param.sourceAttrs = TEST_SRC_ATTRS;
137 param.sourceVersion = TEST_VER;
138 int32_t ret = camDev_->RegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, param);
139 EXPECT_EQ(DCAMERA_OK, ret);
140 }
141
142 /**
143 * @tc.name: dcamera_source_dev_test_003
144 * @tc.desc: Verify source dev UnRegisterDistributedHardware.
145 * @tc.type: FUNC
146 * @tc.require: Issue Number
147 */
148 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_003, TestSize.Level1)
149 {
150 camDev_->InitDCameraSourceDev();
151 int32_t ret = camDev_->UnRegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID);
152 EXPECT_EQ(DCAMERA_OK, ret);
153 }
154
155 /**
156 * @tc.name: dcamera_source_dev_test_004
157 * @tc.desc: Verify source dev DCameraNotify.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_004, TestSize.Level1)
162 {
163 camDev_->InitDCameraSourceDev();
164 int32_t ret = camDev_->DCameraNotify(TEST_EVENT_CMD_JSON);
165 EXPECT_EQ(DCAMERA_OK, ret);
166 }
167
168 /**
169 * @tc.name: dcamera_source_dev_test_005
170 * @tc.desc: Verify source dev OpenSession.
171 * @tc.type: FUNC
172 * @tc.require: Issue Number
173 */
174 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_005, TestSize.Level1)
175 {
176 DCameraIndex index;
177 index.devId_ = TEST_DEVICE_ID;
178 index.dhId_ = TEST_CAMERA_DH_ID_0;
179 camDev_->InitDCameraSourceDev();
180 int32_t ret = camDev_->OpenSession(index);
181 EXPECT_EQ(DCAMERA_OK, ret);
182 }
183
184 /**
185 * @tc.name: dcamera_source_dev_test_006
186 * @tc.desc: Verify source dev CloseSession.
187 * @tc.type: FUNC
188 * @tc.require: Issue Number
189 */
190 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_006, TestSize.Level1)
191 {
192 DCameraIndex index;
193 index.devId_ = TEST_DEVICE_ID;
194 index.dhId_ = TEST_CAMERA_DH_ID_0;
195 camDev_->InitDCameraSourceDev();
196 int32_t ret = camDev_->CloseSession(index);
197 EXPECT_EQ(DCAMERA_OK, ret);
198 }
199
200 /**
201 * @tc.name: dcamera_source_dev_test_007
202 * @tc.desc: Verify source dev ConfigCameraStreams.
203 * @tc.type: FUNC
204 * @tc.require: Issue Number
205 */
206 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_007, TestSize.Level1)
207 {
208 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
209 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
210 streamInfo->streamId_ = 1;
211 streamInfo->width_ = TEST_WIDTH;
212 streamInfo->height_ = TEST_HEIGTH;
213 streamInfo->stride_ = 1;
214 streamInfo->format_ = 1;
215 streamInfo->dataspace_ = 1;
216 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
217 streamInfo->type_ = SNAPSHOT_FRAME;
218 streamInfos.push_back(streamInfo);
219 camDev_->InitDCameraSourceDev();
220 int32_t ret = camDev_->ConfigCameraStreams(streamInfos);
221 EXPECT_EQ(DCAMERA_OK, ret);
222 }
223
224 /**
225 * @tc.name: dcamera_source_dev_test_008
226 * @tc.desc: Verify source dev ReleaseCameraStreams.
227 * @tc.type: FUNC
228 * @tc.require: Issue Number
229 */
230 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_008, TestSize.Level1)
231 {
232 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
233 std::vector<int> streamIds;
234 int streamId = 1;
235 streamIds.push_back(streamId);
236 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
237 streamInfo->streamId_ = 1;
238 streamInfo->width_ = TEST_WIDTH;
239 streamInfo->height_ = TEST_HEIGTH;
240 streamInfo->stride_ = 1;
241 streamInfo->format_ = 1;
242 streamInfo->dataspace_ = 1;
243 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
244 streamInfo->type_ = SNAPSHOT_FRAME;
245 streamInfos.push_back(streamInfo);
246 camDev_->InitDCameraSourceDev();
247 int32_t ret = camDev_->ConfigCameraStreams(streamInfos);
248 ret = camDev_->ReleaseCameraStreams(streamIds);
249 EXPECT_EQ(DCAMERA_OK, ret);
250 }
251
252 /**
253 * @tc.name: dcamera_source_dev_test_009
254 * @tc.desc: Verify source dev StartCameraCapture.
255 * @tc.type: FUNC
256 * @tc.require: Issue Number
257 */
258 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_009, TestSize.Level1)
259 {
260 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
261 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
262 captureInfo->streamIds_.push_back(1);
263 captureInfo->width_ = TEST_WIDTH;
264 captureInfo->height_ = TEST_HEIGTH;
265 captureInfo->stride_ = 1;
266 captureInfo->format_ = 1;
267 captureInfo->dataspace_ = 1;
268 captureInfo->encodeType_ = ENCODE_TYPE_H265;
269 captureInfo->type_ = CONTINUOUS_FRAME;
270 captureInfos.push_back(captureInfo);
271 camDev_->InitDCameraSourceDev();
272 int32_t ret = camDev_->StartCameraCapture(captureInfos);
273 EXPECT_EQ(DCAMERA_OK, ret);
274 }
275
276 /**
277 * @tc.name: dcamera_source_dev_test_010
278 * @tc.desc: Verify source dev StopCameraCapture.
279 * @tc.type: FUNC
280 * @tc.require: Issue Number
281 */
282 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_010, TestSize.Level1)
283 {
284 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
285 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
286 int streamId = 1;
287 captureInfo->streamIds_.push_back(streamId);
288 captureInfo->width_ = TEST_WIDTH;
289 captureInfo->height_ = TEST_HEIGTH;
290 captureInfo->stride_ = 1;
291 captureInfo->format_ = 1;
292 captureInfo->dataspace_ = 1;
293 captureInfo->encodeType_ = ENCODE_TYPE_H265;
294 captureInfo->type_ = CONTINUOUS_FRAME;
295 captureInfos.push_back(captureInfo);
296 camDev_->InitDCameraSourceDev();
297 int32_t ret = camDev_->StartCameraCapture(captureInfos);
298 std::vector<int> streamIds;
299 streamIds.push_back(streamId);
300 ret = camDev_->StopCameraCapture(streamIds);
301 EXPECT_EQ(DCAMERA_OK, ret);
302 }
303
304 /**
305 * @tc.name: dcamera_source_dev_test_011
306 * @tc.desc: Verify source dev UpdateCameraSettings.
307 * @tc.type: FUNC
308 * @tc.require: Issue Number
309 */
310 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_011, TestSize.Level1)
311 {
312 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
313 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
314 int streamId = 1;
315 captureInfo->streamIds_.push_back(streamId);
316 captureInfo->width_ = TEST_WIDTH;
317 captureInfo->height_ = TEST_HEIGTH;
318 captureInfo->stride_ = 1;
319 captureInfo->format_ = 1;
320 captureInfo->dataspace_ = 1;
321 captureInfo->encodeType_ = ENCODE_TYPE_H265;
322 captureInfo->type_ = CONTINUOUS_FRAME;
323 captureInfos.push_back(captureInfo);
324 camDev_->InitDCameraSourceDev();
325 int32_t ret = camDev_->StartCameraCapture(captureInfos);
326 std::vector<std::shared_ptr<DCameraSettings>> settings;
327 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
328 setting->type_ = DCSettingsType::DISABLE_METADATA;
329 setting->value_ = "UpdateSettingsTest";
330 settings.push_back(setting);
331 ret = camDev_->UpdateCameraSettings(settings);
332 std::vector<int> streamIds;
333 streamIds.push_back(streamId);
334 camDev_->StopCameraCapture(streamIds);
335 EXPECT_EQ(DCAMERA_OK, ret);
336 }
337
338 /**
339 * @tc.name: dcamera_source_dev_test_012
340 * @tc.desc: Verify source dev GetStateInfo.
341 * @tc.type: FUNC
342 * @tc.require: Issue Number
343 */
344 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_012, TestSize.Level1)
345 {
346 std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
347 DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent);
348 camDev_->InitDCameraSourceDev();
349 camDev_->GetVersion();
350 int32_t ret = camDev_->GetStateInfo();
351 EXPECT_EQ(DCAMERA_OK, ret);
352 }
353
354 /**
355 * @tc.name: dcamera_source_dev_test_013
356 * @tc.desc: Verify source dev Register.
357 * @tc.type: FUNC
358 * @tc.require: Issue Number
359 */
360 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_013, TestSize.Level1)
361 {
362 std::vector<DCameraIndex> indexs;
363 DCameraIndex index;
364 index.devId_ = TEST_DEVICE_ID;
365 index.dhId_ = TEST_CAMERA_DH_ID_0;
366 indexs.push_back(index);
367 camDev_->InitDCameraSourceDev();
368 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
369 camDev_->controller_->Init(indexs);
370 camDev_->input_->Init();
371 std::string devId = TEST_DEVICE_ID;
372 std::string dhId = TEST_CAMERA_DH_ID_0;
373 std::string reqId = TEST_REQID;
374 std::string sinkParams = TEST_VER;
375 std::string srcParams = TEST_VER;
376 std::shared_ptr<DCameraRegistParam> param = std::make_shared<DCameraRegistParam>(devId, dhId, reqId, sinkParams,
377 srcParams);
378 int32_t ret = camDev_->Register(param);
379 EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
380 }
381
382 /**
383 * @tc.name: dcamera_source_dev_test_014
384 * @tc.desc: Verify source dev UnRegister.
385 * @tc.type: FUNC
386 * @tc.require: Issue Number
387 */
388 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_014, TestSize.Level1)
389 {
390 camDev_->InitDCameraSourceDev();
391 std::string devId = TEST_DEVICE_ID;
392 std::string dhId = TEST_CAMERA_DH_ID_0;
393 std::string reqId = TEST_REQID;
394 std::string sinkParams = TEST_VER;
395 std::string srcParams = TEST_VER;
396 std::shared_ptr<DCameraRegistParam> param = std::make_shared<DCameraRegistParam>(devId, dhId, reqId, sinkParams,
397 srcParams);
398 int32_t ret = camDev_->UnRegister(param);
399 EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
400 }
401
402 /**
403 * @tc.name: dcamera_source_dev_test_015
404 * @tc.desc: Verify source dev OpenCamera.
405 * @tc.type: FUNC
406 * @tc.require: Issue Number
407 */
408 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015, TestSize.Level1)
409 {
410 SetTokenID();
411 std::vector<DCameraIndex> indexs;
412 camDev_->InitDCameraSourceDev();
413 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
414 int32_t ret = camDev_->controller_->Init(indexs);
415 camDev_->input_->Init();
416 DCameraIndex index;
417 index.devId_ = TEST_DEVICE_ID;
418 index.dhId_ = TEST_CAMERA_DH_ID_0;
419 indexs.push_back(index);
420 ret = camDev_->OpenCamera();
421 ret = camDev_->CloseCamera();
422 EXPECT_EQ(DCAMERA_OK, ret);
423 }
424
425 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015_1, TestSize.Level1)
426 {
427 SetTokenID();
428 std::vector<DCameraIndex> indexs;
429 camDev_->InitDCameraSourceDev();
430 camDev_->controller_ = std::make_shared<MockDCameraSourceControllerRetErr>();
431 int32_t ret = camDev_->controller_->Init(indexs);
432 camDev_->input_->Init();
433 DCameraIndex index;
434 index.devId_ = TEST_DEVICE_ID;
435 index.dhId_ = TEST_CAMERA_DH_ID_0;
436 indexs.push_back(index);
437 ret = camDev_->OpenCamera();
438 EXPECT_NE(ERR_DH_CAMERA_BASE, ret);
439 ret = camDev_->CloseCamera();
440 EXPECT_EQ(DCAMERA_OK, ret);
441 }
442
443 /**
444 * @tc.name: dcamera_source_dev_test_016
445 * @tc.desc: Verify source dev ConfigStreams.
446 * @tc.type: FUNC
447 * @tc.require: Issue Number
448 */
449 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_016, TestSize.Level1)
450 {
451 camDev_->InitDCameraSourceDev();
452 std::vector<DCameraIndex> indexs;
453 DCameraIndex index;
454 index.devId_ = TEST_DEVICE_ID;
455 index.dhId_ = TEST_CAMERA_DH_ID_0;
456 indexs.push_back(index);
457 camDev_->InitDCameraSourceDev();
458 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
459 camDev_->controller_->Init(indexs);
460 camDev_->input_->Init();
461 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
462 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
463 streamInfo->streamId_ = 1;
464 streamInfo->width_ = TEST_WIDTH;
465 streamInfo->height_ = TEST_HEIGTH;
466 streamInfo->stride_ = 1;
467 streamInfo->format_ = 1;
468 streamInfo->dataspace_ = 1;
469 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
470 streamInfo->type_ = SNAPSHOT_FRAME;
471 streamInfos.push_back(streamInfo);
472 int32_t ret = camDev_->ConfigStreams(streamInfos);
473 EXPECT_NE(ERR_DH_CAMERA_BASE, ret);
474 }
475
476 /**
477 * @tc.name: dcamera_source_dev_test_017
478 * @tc.desc: Verify source dev ReleaseStreams.
479 * @tc.type: FUNC
480 * @tc.require: Issue Number
481 */
482 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_017, TestSize.Level1)
483 {
484 camDev_->InitDCameraSourceDev();
485 std::vector<DCameraIndex> indexs;
486 DCameraIndex index;
487 index.devId_ = TEST_DEVICE_ID;
488 index.dhId_ = TEST_CAMERA_DH_ID_0;
489 indexs.push_back(index);
490 camDev_->InitDCameraSourceDev();
491 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
492 camDev_->controller_->Init(indexs);
493 camDev_->input_->Init();
494 std::vector<std::shared_ptr<DCStreamInfo>> streamInfos;
495 std::shared_ptr<DCStreamInfo> streamInfo = std::make_shared<DCStreamInfo>();
496 streamInfo->streamId_ = 1;
497 streamInfo->width_ = TEST_WIDTH;
498 streamInfo->height_ = TEST_HEIGTH;
499 streamInfo->stride_ = 1;
500 streamInfo->format_ = 1;
501 streamInfo->dataspace_ = 1;
502 streamInfo->encodeType_ = ENCODE_TYPE_JPEG;
503 streamInfo->type_ = SNAPSHOT_FRAME;
504 streamInfos.push_back(streamInfo);
505 int32_t ret = camDev_->ConfigStreams(streamInfos);
506 std::vector<int> streamIds;
507 int32_t streamId = 1;
508 streamIds.push_back(streamId);
509 bool isAllRelease = true;
510 ret = camDev_->ReleaseStreams(streamIds, isAllRelease);
511 isAllRelease = false;
512 ret = camDev_->ReleaseStreams(streamIds, isAllRelease);
513 EXPECT_EQ(DCAMERA_OK, ret);
514 }
515
516 /**
517 * @tc.name: dcamera_source_dev_test_018
518 * @tc.desc: Verify source dev ReleaseAllStreams.
519 * @tc.type: FUNC
520 * @tc.require: Issue Number
521 */
522 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_018, TestSize.Level1)
523 {
524 camDev_->InitDCameraSourceDev();
525 std::vector<DCameraIndex> indexs;
526 DCameraIndex index;
527 index.devId_ = TEST_DEVICE_ID;
528 index.dhId_ = TEST_CAMERA_DH_ID_0;
529 indexs.push_back(index);
530 camDev_->InitDCameraSourceDev();
531 camDev_->controller_->Init(indexs);
532 camDev_->input_->Init();
533 int32_t ret = camDev_->ReleaseAllStreams();
534 EXPECT_EQ(DCAMERA_OK, ret);
535 }
536
537 /**
538 * @tc.name: dcamera_source_dev_test_019
539 * @tc.desc: Verify source dev StartCapture.
540 * @tc.type: FUNC
541 * @tc.require: Issue Number
542 */
543 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_019, TestSize.Level1)
544 {
545 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
546 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
547 captureInfo->streamIds_.push_back(1);
548 captureInfo->width_ = TEST_WIDTH;
549 captureInfo->height_ = TEST_HEIGTH;
550 captureInfo->stride_ = 1;
551 captureInfo->format_ = 1;
552 captureInfo->dataspace_ = 1;
553 captureInfo->encodeType_ = ENCODE_TYPE_H265;
554 captureInfo->type_ = CONTINUOUS_FRAME;
555 captureInfos.push_back(captureInfo);
556 camDev_->InitDCameraSourceDev();
557 std::vector<DCameraIndex> indexs;
558 DCameraIndex index;
559 index.devId_ = TEST_DEVICE_ID;
560 index.dhId_ = TEST_CAMERA_DH_ID_0;
561 indexs.push_back(index);
562 camDev_->InitDCameraSourceDev();
563 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
564 camDev_->controller_->Init(indexs);
565 camDev_->input_->Init();
566 int32_t ret = camDev_->StartCapture(captureInfos);
567 EXPECT_EQ(DCAMERA_OK, ret);
568 camDev_->HitraceAndHisyseventImpl(captureInfos);
569 EXPECT_EQ(DCAMERA_OK, ret);
570 }
571
572 /**
573 * @tc.name: dcamera_source_dev_test_020
574 * @tc.desc: Verify source dev StopAllCapture.
575 * @tc.type: FUNC
576 * @tc.require: Issue Number
577 */
578 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020, TestSize.Level1)
579 {
580 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
581 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
582 captureInfo->streamIds_.push_back(1);
583 captureInfo->width_ = TEST_WIDTH;
584 captureInfo->height_ = TEST_HEIGTH;
585 captureInfo->stride_ = 1;
586 captureInfo->format_ = 1;
587 captureInfo->dataspace_ = 1;
588 captureInfo->encodeType_ = ENCODE_TYPE_H265;
589 captureInfo->type_ = CONTINUOUS_FRAME;
590 captureInfos.push_back(captureInfo);
591 camDev_->InitDCameraSourceDev();
592 std::vector<DCameraIndex> indexs;
593 DCameraIndex index;
594 index.devId_ = TEST_DEVICE_ID;
595 index.dhId_ = TEST_CAMERA_DH_ID_0;
596 indexs.push_back(index);
597 camDev_->InitDCameraSourceDev();
598 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
599 camDev_->controller_->Init(indexs);
600 camDev_->input_->Init();
601 int32_t ret = camDev_->StartCapture(captureInfos);
602 std::vector<int> streamIds;
603 int32_t streamId = 1;
604 streamIds.push_back(streamId);
605 bool isAllStop = true;
606 ret = camDev_->StopCapture(streamIds, isAllStop);
607 EXPECT_EQ(DCAMERA_OK, ret);
608 ret = camDev_->StopAllCapture();
609 EXPECT_EQ(DCAMERA_OK, ret);
610 }
611
612 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020_1, TestSize.Level1)
613 {
614 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
615 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
616 captureInfo->streamIds_.push_back(1);
617 captureInfo->width_ = TEST_WIDTH;
618 captureInfo->height_ = TEST_HEIGTH;
619 captureInfo->stride_ = 1;
620 captureInfo->format_ = 1;
621 captureInfo->dataspace_ = 1;
622 captureInfo->encodeType_ = ENCODE_TYPE_H265;
623 captureInfo->type_ = CONTINUOUS_FRAME;
624 captureInfos.push_back(captureInfo);
625 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
626 auto savedInput = camDev_->input_;
627 camDev_->input_ = std::make_shared<MockDCameraSourceInput>();
628 camDev_->input_->Init();
629 int32_t ret = camDev_->StartCapture(captureInfos);
630 EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
631 std::vector<int> streamIds;
632 int32_t streamId = 1;
633 streamIds.push_back(streamId);
634 bool isAllStop = true;
635 ret = camDev_->StopCapture(streamIds, isAllStop);
636 EXPECT_EQ(DCAMERA_OK, ret);
637 ret = camDev_->StopAllCapture();
638 EXPECT_EQ(DCAMERA_OK, ret);
639 camDev_->input_ = savedInput;
640 }
641
642 /**
643 * @tc.name: dcamera_source_dev_test_021
644 * @tc.desc: Verify source dev UpdateSettings.
645 * @tc.type: FUNC
646 * @tc.require: Issue Number
647 */
648 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_021, TestSize.Level1)
649 {
650 std::vector<std::shared_ptr<DCCaptureInfo>> captureInfos;
651 std::shared_ptr<DCCaptureInfo> captureInfo = std::make_shared<DCCaptureInfo>();
652 int streamId = 1;
653 captureInfo->streamIds_.push_back(streamId);
654 captureInfo->width_ = TEST_WIDTH;
655 captureInfo->height_ = TEST_HEIGTH;
656 captureInfo->stride_ = 1;
657 captureInfo->format_ = 1;
658 captureInfo->dataspace_ = 1;
659 captureInfo->encodeType_ = ENCODE_TYPE_H265;
660 captureInfo->type_ = CONTINUOUS_FRAME;
661 captureInfos.push_back(captureInfo);
662 camDev_->InitDCameraSourceDev();
663 std::vector<DCameraIndex> indexs;
664 DCameraIndex index;
665 index.devId_ = TEST_DEVICE_ID;
666 index.dhId_ = TEST_CAMERA_DH_ID_0;
667 indexs.push_back(index);
668 camDev_->InitDCameraSourceDev();
669 camDev_->controller_ = std::make_shared<MockDCameraSourceController>();
670 camDev_->controller_->Init(indexs);
671 camDev_->input_->Init();
672 std::vector<std::shared_ptr<DCameraSettings>> settings;
673 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
674 setting->type_ = DCSettingsType::DISABLE_METADATA;
675 setting->value_ = "UpdateSettingsTest";
676 settings.push_back(setting);
677 int32_t ret = camDev_->UpdateSettings(settings);
678 EXPECT_EQ(DCAMERA_OK, ret);
679
680 auto savedInput = camDev_->input_;
681 camDev_->input_ = std::make_shared<MockDCameraSourceInput>();
682 ret = camDev_->UpdateSettings(settings);
683 EXPECT_EQ(DCAMERA_BAD_OPERATE, ret);
684 camDev_->input_ = savedInput;
685 }
686
687 /**
688 * @tc.name: dcamera_source_dev_test_022
689 * @tc.desc: Verify source dev NotifyResult.
690 * @tc.type: FUNC
691 * @tc.require: Issue Number
692 */
693 HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_022, TestSize.Level1)
694 {
695 int32_t ret = camDev_->InitDCameraSourceDev();
696 int32_t result = 0;
697 DCAMERA_EVENT eventType = DCAMERA_EVENT::DCAMERA_EVENT_OPEN;
698 std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
699 DCameraSourceEvent event(DCAMERA_EVENT_NOFIFY, camEvent);
700 camDev_->NotifyResult(eventType, event, result);
701 camDev_->memberFuncMap_.clear();
702 camDev_->NotifyResult(eventType, event, result);
703 EXPECT_EQ(DCAMERA_OK, ret);
704 }
705
706 /**
707 * @tc.name: SetHicollieFlag_001
708 * @tc.desc: Verify source dev SetHicollieFlag.
709 * @tc.type: FUNC
710 * @tc.require: Issue Number
711 */
712 HWTEST_F(DCameraSourceDevTest, SetHicollieFlag_001, TestSize.Level1)
713 {
714 camDev_->SetHicollieFlag(true);
715 EXPECT_EQ(true, camDev_->GetHicollieFlag());
716 camDev_->SetHicollieFlag(false);
717 EXPECT_EQ(false, camDev_->GetHicollieFlag());
718 }
719
720 /**
721 * @tc.name: SetHicollieFlag_001
722 * @tc.desc: Verify source dev SetHicollieFlag.
723 * @tc.type: FUNC
724 * @tc.require: Issue Number
725 */
726 HWTEST_F(DCameraSourceDevTest, GetFullCaps_001, TestSize.Level1)
727 {
728 DHLOGI("DCameraSourceDevTest GetFullCaps_001");
729 EXPECT_EQ(DCAMERA_OK, camDev_->GetFullCaps());
730
731 std::shared_ptr<DCameraSourceDev> camDev1_;
732 std::shared_ptr<ICameraStateListener> stateListener1_;
733 camDev1_ = std::make_shared<DCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_);
734 EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->GetFullCaps());
735 }
736
737 HWTEST_F(DCameraSourceDevTest, OnChannelConnectedEvent_001, TestSize.Level1)
738 {
739 std::shared_ptr<DCameraSourceDev> camDev1_;
740 std::shared_ptr<ICameraStateListener> stateListener1_;
741 camDev1_ = std::make_shared<DCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_);
742 EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->OnChannelConnectedEvent());
743
744 camDev1_->InitDCameraSourceDev();
745 EXPECT_EQ(DCAMERA_OK, camDev1_->OnChannelConnectedEvent());
746 }
747
748 HWTEST_F(DCameraSourceDevTest, PostHicollieEvent_001, TestSize.Level1)
749 {
750 std::shared_ptr<DCameraSourceDev> camDev1_;
751 std::shared_ptr<ICameraStateListener> stateListener1_;
752 camDev1_ = std::make_shared<DCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_);
753 EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->PostHicollieEvent());
754
755 camDev1_->InitDCameraSourceDev();
756 EXPECT_EQ(DCAMERA_OK, camDev1_->PostHicollieEvent());
757 }
758 } // namespace DistributedHardware
759 } // namespace OHOS
760