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 #define private public
18 #include "dcamera_source_controller.h"
19 #undef private
20
21 #include "dcamera_source_state.h"
22 #include "dcamera_utils_tools.h"
23 #include "mock_camera_channel.h"
24 #include "distributed_hardware_log.h"
25 #include "icamera_state_listener.h"
26 #include "dcamera_source_controller_channel_listener.h"
27 #include "distributed_camera_errno.h"
28 #include "mock_dcamera_source_dev.h"
29 #include "mock_dcamera_source_state_listener.h"
30
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace DistributedHardware {
35 std::string g_channelStr = "";
36 class DCameraSourceControllerTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42
43 std::shared_ptr<DCameraSourceDev> camDev_;
44 std::shared_ptr<ICameraStateListener> stateListener_;
45 std::shared_ptr<DCameraSourceStateMachine> stateMachine_;
46 std::shared_ptr<DCameraSourceController> controller_;
47 std::vector<DCameraIndex> indexs_;
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 int32_t TEST_WIDTH = 1920;
54 const int32_t TEST_HEIGTH = 1080;
55 const int32_t TEST_FORMAT = 4;
56 const int32_t TEST_DATASPACE = 8;
57 const int32_t TEST_ISCAPTURE = 0;
58 const int32_t TEST_SLEEP_SEC = 200000;
59 const size_t DATABUFF_MAX_SIZE = 100 * 1024 * 1024;
60 }
61
SetUpTestCase(void)62 void DCameraSourceControllerTest::SetUpTestCase(void)
63 {
64 }
65
TearDownTestCase(void)66 void DCameraSourceControllerTest::TearDownTestCase(void)
67 {
68 }
69
SetUp(void)70 void DCameraSourceControllerTest::SetUp(void)
71 {
72 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
73 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
74 stateMachine_ = std::make_shared<DCameraSourceStateMachine>(camDev_);
75 controller_ = std::make_shared<DCameraSourceController>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateMachine_,
76 camDev_);
77 controller_->channel_ = std::make_shared<MockCameraChannel>();
78 DCameraIndex index;
79 index.devId_ = TEST_DEVICE_ID;
80 index.dhId_ = TEST_CAMERA_DH_ID_0;
81 indexs_.push_back(index);
82 }
83
TearDown(void)84 void DCameraSourceControllerTest::TearDown(void)
85 {
86 usleep(TEST_SLEEP_SEC);
87 stateMachine_ = nullptr;
88 camDev_ = nullptr;
89 stateListener_ = nullptr;
90 controller_ = nullptr;
91 }
92
93 /**
94 * @tc.name: dcamera_source_controller_test_001
95 * @tc.desc: Verify source controller Init.
96 * @tc.type: FUNC
97 * @tc.require: Issue Number
98 */
99 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_001, TestSize.Level1)
100 {
101 int32_t ret = controller_->Init(indexs_);
102 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
103 }
104
105 /**
106 * @tc.name: dcamera_source_controller_test_002
107 * @tc.desc: Verify source controller UnInit.
108 * @tc.type: FUNC
109 * @tc.require: Issue Number
110 */
111 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_002, TestSize.Level1)
112 {
113 int32_t ret = controller_->Init(indexs_);
114 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
115 ret = controller_->UnInit();
116 EXPECT_EQ(ret, DCAMERA_OK);
117 }
118
119 /**
120 * @tc.name: dcamera_source_controller_test_003
121 * @tc.desc: Verify source controller StartCapture.
122 * @tc.type: FUNC
123 * @tc.require: Issue Number
124 */
125 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_003, TestSize.Level1)
126 {
127 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
128 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
129 capture->width_ = TEST_WIDTH;
130 capture->height_ = TEST_HEIGTH;
131 capture->format_ = TEST_FORMAT;
132 capture->dataspace_ = TEST_DATASPACE;
133 capture->isCapture_ = TEST_ISCAPTURE;
134 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
135 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
136 captureInfos.push_back(capture);
137
138 int32_t ret = controller_->Init(indexs_);
139 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
140 DCameraIndex index1;
141 index1.devId_ = TEST_DEVICE_ID;
142 index1.dhId_ = TEST_CAMERA_DH_ID_0;
143 controller_->indexs_.push_back(index1);
144 int32_t mode = 0;
145 ret = controller_->StartCapture(captureInfos, mode);
146 controller_->UnInit();
147 EXPECT_EQ(ret, DCAMERA_OK);
148 }
149
150 /**
151 * @tc.name: dcamera_source_controller_test_004
152 * @tc.desc: Verify source controller StartCapture and StopCapture.
153 * @tc.type: FUNC
154 * @tc.require: Issue Number
155 */
156 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_004, TestSize.Level1)
157 {
158 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
159 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
160 capture->width_ = TEST_WIDTH;
161 capture->height_ = TEST_HEIGTH;
162 capture->format_ = TEST_FORMAT;
163 capture->dataspace_ = TEST_DATASPACE;
164 capture->isCapture_ = TEST_ISCAPTURE;
165 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
166 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
167 captureInfos.push_back(capture);
168 int32_t ret = controller_->Init(indexs_);
169 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
170 DCameraIndex index1;
171 index1.devId_ = TEST_DEVICE_ID;
172 index1.dhId_ = TEST_CAMERA_DH_ID_0;
173 controller_->indexs_.push_back(index1);
174 int32_t mode = 0;
175 ret = controller_->StartCapture(captureInfos, mode);
176
177 ret = controller_->StopCapture();
178 controller_->UnInit();
179 EXPECT_EQ(ret, DCAMERA_BAD_VALUE);
180 }
181
182 /**
183 * @tc.name: dcamera_source_controller_test_005
184 * @tc.desc: Verify source controller ChannelNeg.
185 * @tc.type: FUNC
186 * @tc.require: Issue Number
187 */
188 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_005, TestSize.Level1)
189 {
190 DHLOGI("start execute dcamera_source_controller_test_005");
191 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
192 int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
193 DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
194 DCameraChannelDetail snapShotChInfo(SNAP_SHOT_SESSION_FLAG, SNAPSHOT_FRAME);
195 chanInfo->detail_.push_back(continueChInfo);
196 chanInfo->detail_.push_back(snapShotChInfo);
197 ret = controller_->Init(indexs_);
198 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
199 DCameraIndex index1;
200 index1.devId_ = TEST_DEVICE_ID;
201 index1.dhId_ = TEST_CAMERA_DH_ID_0;
202 controller_->indexs_.push_back(index1);
203 ret = controller_->ChannelNeg(chanInfo);
204 controller_->UnInit();
205 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
206 }
207
208 /**
209 * @tc.name: dcamera_source_controller_test_006
210 * @tc.desc: Verify source controller UpdateSettings.
211 * @tc.type: FUNC
212 * @tc.require: Issue Number
213 */
214 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_006, TestSize.Level1)
215 {
216 DHLOGI("start execute dcamera_source_controller_test_006");
217 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
218 std::vector<std::shared_ptr<DCameraSettings>> settings;
219 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
220 setting->type_ = DCSettingsType::DISABLE_METADATA;
221 setting->value_ = "UpdateSettingsTest";
222 settings.push_back(setting);
223
224 int32_t ret = controller_->Init(indexs_);
225 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
226 DCameraIndex index1;
227 index1.devId_ = TEST_DEVICE_ID;
228 index1.dhId_ = TEST_CAMERA_DH_ID_0;
229 controller_->indexs_.push_back(index1);
230 ret = controller_->UpdateSettings(settings);
231 controller_->UnInit();
232 EXPECT_EQ(ret, DCAMERA_OK);
233 }
234
235 /**
236 * @tc.name: dcamera_source_controller_test_007
237 * @tc.desc: Verify source controller GetCameraInfo.
238 * @tc.type: FUNC
239 * @tc.require: Issue Number
240 */
241 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_007, TestSize.Level1)
242 {
243 DHLOGI("start execute dcamera_source_controller_test_006");
244 int32_t ret = controller_->Init(indexs_);
245 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
246 DCameraIndex index1;
247 index1.devId_ = TEST_DEVICE_ID;
248 index1.dhId_ = TEST_CAMERA_DH_ID_0;
249 controller_->indexs_.push_back(index1);
250 std::shared_ptr<DCameraInfo> camInfo = std::make_shared<DCameraInfo>();
251 camInfo->state_ = 1;
252 ret = controller_->GetCameraInfo(camInfo);
253 controller_->UnInit();
254 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
255 }
256
257 /**
258 * @tc.name: dcamera_source_controller_test_008
259 * @tc.desc: Verify source controller OpenChannel.
260 * @tc.type: FUNC
261 * @tc.require: Issue Number
262 */
263 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_008, TestSize.Level1)
264 {
265 int32_t ret = controller_->Init(indexs_);
266 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
267 DCameraIndex index1;
268 index1.devId_ = TEST_DEVICE_ID;
269 index1.dhId_ = TEST_CAMERA_DH_ID_0;
270 controller_->indexs_.push_back(index1);
271 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
272 ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
273 ret = controller_->OpenChannel(openInfo);
274 controller_->UnInit();
275 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
276 }
277
278 /**
279 * @tc.name: dcamera_source_controller_test_009
280 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
281 * @tc.type: FUNC
282 * @tc.require: Issue Number
283 */
284 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_009, TestSize.Level1)
285 {
286 int32_t ret = controller_->Init(indexs_);
287 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
288 DCameraIndex index1;
289 index1.devId_ = TEST_DEVICE_ID;
290 index1.dhId_ = TEST_CAMERA_DH_ID_0;
291 controller_->indexs_.push_back(index1);
292 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
293 ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
294 controller_->OpenChannel(openInfo);
295 ret = controller_->CloseChannel();
296 controller_->UnInit();
297 EXPECT_EQ(ret, DCAMERA_OK);
298 }
299
300 /**
301 * @tc.name: dcamera_source_controller_test_010
302 * @tc.desc: Verify source controller OnDataReceived.
303 * @tc.type: FUNC
304 * @tc.require: Issue Number
305 */
306 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_010, TestSize.Level1)
307 {
308 int32_t ret = controller_->Init(indexs_);
309 ret = camDev_->InitDCameraSourceDev();
310 std::shared_ptr<ICameraChannelListener> listener =
311 std::make_shared<DCameraSourceControllerChannelListener>(controller_);
312 int32_t state = 0;
313 listener->OnSessionState(state, "");
314 state = 1;
315 listener->OnSessionState(state, "");
316 int32_t eventType = 1;
317 int32_t eventReason = 1;
318 std::string detail = "OnSessionErrorTest";
319 listener->OnSessionError(eventType, eventReason, detail);
320 std::vector<std::shared_ptr<DataBuffer>> buffers;
321 listener->OnDataReceived(buffers);
322 size_t capacity = 0;
323 std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
324 buffers.push_back(dataBuffer);
325 listener->OnDataReceived(buffers);
326 buffers.clear();
327 capacity = DATABUFF_MAX_SIZE + 1;
328 dataBuffer = std::make_shared<DataBuffer>(capacity);
329 buffers.push_back(dataBuffer);
330 listener->OnDataReceived(buffers);
331 buffers.clear();
332 capacity = 1;
333 dataBuffer = std::make_shared<DataBuffer>(capacity);
334 buffers.push_back(dataBuffer);
335 listener->OnDataReceived(buffers);
336 ret = controller_->UnInit();
337 EXPECT_EQ(ret, DCAMERA_OK);
338 }
339
340 /**
341 * @tc.name: dcamera_source_controller_test_011
342 * @tc.desc: Verify source controller ChannelNeg.
343 * @tc.type: FUNC
344 * @tc.require: Issue Number
345 */
346 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_011, TestSize.Level1)
347 {
348 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
349 int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
350 DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
351 DCameraChannelDetail snapShotChInfo(SNAP_SHOT_SESSION_FLAG, SNAPSHOT_FRAME);
352 chanInfo->detail_.push_back(continueChInfo);
353 chanInfo->detail_.push_back(snapShotChInfo);
354 DCameraIndex index1;
355 index1.devId_ = TEST_DEVICE_ID;
356 index1.dhId_ = TEST_CAMERA_DH_ID_0;
357 DCameraIndex index2;
358 index2.devId_ = TEST_DEVICE_ID;
359 index2.dhId_ = TEST_CAMERA_DH_ID_0;
360 controller_->Init(indexs_);
361
362 controller_->indexs_.push_back(index1);
363 controller_->indexs_.push_back(index2);
364 ret = controller_->ChannelNeg(chanInfo);
365 controller_->UnInit();
366 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
367 }
368
369 /**
370 * @tc.name: dcamera_source_controller_test_012
371 * @tc.desc: Verify source controller DCameraNotify.
372 * @tc.type: FUNC
373 * @tc.require: Issue Number
374 */
375 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012, TestSize.Level1)
376 {
377 std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
378 events->eventType_ = 1;
379 events->eventResult_ = DCAMERA_EVENT_CAMERA_ERROR;
380 events->eventContent_ = "controllerTest012";
381 int32_t ret = controller_->DCameraNotify(events);
382 controller_->UnInit();
383 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
384 }
385
386 /**
387 * @tc.name: dcamera_source_controller_test_013
388 * @tc.desc: Verify source controller UpdateSettings.
389 * @tc.type: FUNC
390 * @tc.require: Issue Number
391 */
392 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_013, TestSize.Level1)
393 {
394 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
395 std::vector<std::shared_ptr<DCameraSettings>> settings;
396 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
397 setting->type_ = DCSettingsType::DISABLE_METADATA;
398 setting->value_ = "UpdateSettingsTest";
399 settings.push_back(setting);
400 DCameraIndex index1;
401 index1.devId_ = TEST_DEVICE_ID;
402 index1.dhId_ = TEST_CAMERA_DH_ID_0;
403 DCameraIndex index2;
404 index2.devId_ = TEST_DEVICE_ID;
405 index2.dhId_ = TEST_CAMERA_DH_ID_0;
406 controller_->indexs_.push_back(index1);
407 controller_->indexs_.push_back(index2);
408 int32_t ret = controller_->UpdateSettings(settings);
409 controller_->UnInit();
410 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
411 }
412
413 /**
414 * @tc.name: dcamera_source_controller_test_014
415 * @tc.desc: Verify source controller GetCameraInfo.
416 * @tc.type: FUNC
417 * @tc.require: Issue Number
418 */
419 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_014, TestSize.Level1)
420 {
421 DCameraIndex index1;
422 index1.devId_ = TEST_DEVICE_ID;
423 index1.dhId_ = TEST_CAMERA_DH_ID_0;
424 DCameraIndex index2;
425 index2.devId_ = TEST_DEVICE_ID;
426 index2.dhId_ = TEST_CAMERA_DH_ID_0;
427 controller_->indexs_.push_back(index1);
428 controller_->indexs_.push_back(index2);
429 indexs_.push_back(index1);
430
431 std::shared_ptr<DCameraInfo> camInfo = std::make_shared<DCameraInfo>();
432 camInfo->state_ = 1;
433 int32_t ret = controller_->GetCameraInfo(camInfo);
434 controller_->UnInit();
435 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
436 }
437
438 /**
439 * @tc.name: dcamera_source_controller_test_015
440 * @tc.desc: Verify source controller OpenChannel.
441 * @tc.type: FUNC
442 * @tc.require: Issue Number
443 */
444 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015, TestSize.Level1)
445 {
446 DCameraIndex index1;
447 index1.devId_ = TEST_DEVICE_ID;
448 index1.dhId_ = TEST_CAMERA_DH_ID_0;
449 DCameraIndex index2;
450 index2.devId_ = TEST_DEVICE_ID;
451 index2.dhId_ = TEST_CAMERA_DH_ID_0;
452 controller_->indexs_.push_back(index1);
453 controller_->indexs_.push_back(index2);
454 indexs_.push_back(index1);
455
456 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
457 int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
458 ret = controller_->OpenChannel(openInfo);
459 controller_->UnInit();
460 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
461 }
462
463 /**
464 * @tc.name: dcamera_source_controller_test_016
465 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
466 * @tc.type: FUNC
467 * @tc.require: Issue Number
468 */
469 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_016, TestSize.Level1)
470 {
471 DCameraIndex index1;
472 index1.devId_ = TEST_DEVICE_ID;
473 index1.dhId_ = TEST_CAMERA_DH_ID_0;
474 DCameraIndex index2;
475 index2.devId_ = TEST_DEVICE_ID;
476 index2.dhId_ = TEST_CAMERA_DH_ID_0;
477 controller_->indexs_.push_back(index1);
478 controller_->indexs_.push_back(index2);
479 controller_->CloseChannel();
480 int32_t ret = controller_->UnInit();
481 EXPECT_EQ(ret, DCAMERA_OK);
482 }
483
484 /**
485 * @tc.name: dcamera_source_controller_test_017
486 * @tc.desc: Verify source controller OpenChannel and HandleMetaDataResult.
487 * @tc.type: FUNC
488 * @tc.require: Issue Number
489 */
490 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_017, TestSize.Level1)
491 {
492 int32_t ret = controller_->Init(indexs_);
493 std::string jsonStr = "controllerTest17";
494 controller_->HandleMetaDataResult(jsonStr);
495 ret = controller_->UnInit();
496 EXPECT_EQ(ret, DCAMERA_OK);
497 }
498
499 /**
500 * @tc.name: dcamera_source_controller_test_018
501 * @tc.desc: Verify source controller OpenChannel and WaitforSessionResult.
502 * @tc.type: FUNC
503 * @tc.require: Issue Number
504 */
505 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_018, TestSize.Level1)
506 {
507 int32_t ret = camDev_->InitDCameraSourceDev();
508 controller_->PublishEnableLatencyMsg(TEST_DEVICE_ID);
509 ret = controller_->UnInit();
510 EXPECT_EQ(ret, DCAMERA_OK);
511 }
512
513 /**
514 * @tc.name: dcamera_source_controller_test_019
515 * @tc.desc: Verify source controller OnSessionError.
516 * @tc.type: FUNC
517 * @tc.require: Issue Number
518 */
519 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSize.Level1)
520 {
521 int32_t ret = controller_->Init(indexs_);
522 std::shared_ptr<DCameraSourceController> controller = nullptr;
523 std::shared_ptr<ICameraChannelListener> listener_ =
524 std::make_shared<DCameraSourceControllerChannelListener>(controller);
525 int32_t state = DCAMERA_CHANNEL_STATE_CONNECTED;
526 listener_->OnSessionState(state, "");
527 int32_t eventType = 1;
528 int32_t eventReason = 1;
529 std::string detail = "OnSessionErrorTest";
530 listener_->OnSessionError(eventType, eventReason, detail);
531 std::vector<std::shared_ptr<DataBuffer>> buffers;
532 listener_->OnDataReceived(buffers);
533 ret = controller_->UnInit();
534 EXPECT_EQ(ret, DCAMERA_OK);
535 }
536
537 /**
538 * @tc.name: dcamera_source_controller_test_020
539 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
540 * @tc.type: FUNC
541 * @tc.require: Issue Number
542 */
543 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_020, TestSize.Level1)
544 {
545 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
546 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
547 capture->width_ = TEST_WIDTH;
548 capture->height_ = TEST_HEIGTH;
549 capture->format_ = TEST_FORMAT;
550 capture->dataspace_ = TEST_DATASPACE;
551 capture->isCapture_ = TEST_ISCAPTURE;
552 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
553 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
554 captureInfos.push_back(capture);
555 DCameraIndex index1;
556 index1.devId_ = TEST_DEVICE_ID;
557 index1.dhId_ = TEST_CAMERA_DH_ID_0;
558 DCameraIndex index2;
559 index2.devId_ = TEST_DEVICE_ID;
560 index2.dhId_ = TEST_CAMERA_DH_ID_0;
561 controller_->indexs_.push_back(index1);
562 controller_->indexs_.push_back(index2);
563 indexs_.push_back(index1);
564
565 int32_t ret = controller_->Init(indexs_);
566 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
567 int32_t mode = 0;
568 ret = controller_->StartCapture(captureInfos, mode);
569 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
570 ret = controller_->StopCapture();
571 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
572 }
573 }
574 }
575