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