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_source_controller.h"
19 #undef private
20
21 #include <securec.h>
22
23 #include "dcamera_source_state.h"
24 #include "dcamera_utils_tools.h"
25 #include "mock_camera_channel.h"
26 #include "distributed_hardware_log.h"
27 #include "icamera_state_listener.h"
28 #include "dcamera_source_controller_channel_listener.h"
29 #include "distributed_camera_errno.h"
30 #include "mock_dcamera_source_dev.h"
31 #include "mock_dcamera_source_state_listener.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace DistributedHardware {
37
38 class DCameraSourceStateImpl : public DCameraSourceState {
39 public:
Execute(std::shared_ptr<DCameraSourceDev> & camDev,DCAMERA_EVENT eventType,DCameraSourceEvent & event)40 int32_t Execute(std::shared_ptr<DCameraSourceDev> &camDev, DCAMERA_EVENT eventType,
41 DCameraSourceEvent &event) override
42 {
43 return 0;
44 }
45
GetStateType()46 DCameraStateType GetStateType() override
47 {
48 return DCameraStateType::DCAMERA_STATE_INIT;
49 }
50 };
51
52 class CameraStateListenerImpl : public ICameraStateListener {
53 public:
OnRegisterNotify(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,std::string & data)54 int32_t OnRegisterNotify(const std::string &devId, const std::string &dhId, const std::string &reqId,
55 int32_t status, std::string &data) override
56 {
57 return 0;
58 }
59
OnUnregisterNotify(const std::string & devId,const std::string & dhId,const std::string & reqId,int32_t status,std::string & data)60 int32_t OnUnregisterNotify(const std::string &devId, const std::string &dhId, const std::string &reqId,
61 int32_t status, std::string &data) override
62 {
63 return 0;
64 }
65
OnHardwareStateChanged(const std::string & devId,const std::string & dhId,int32_t status)66 int32_t OnHardwareStateChanged(const std::string &devId, const std::string &dhId, int32_t status) override
67 {
68 return 0;
69 }
70
OnDataSyncTrigger(const std::string & devId)71 int32_t OnDataSyncTrigger(const std::string &devId) override
72 {
73 return 0;
74 }
75
SetCallback(sptr<IDCameraSourceCallback> callback)76 void SetCallback(sptr<IDCameraSourceCallback> callback) override
77 {
78 callback_ = callback;
79 }
80
81 private:
82 sptr<IDCameraSourceCallback> callback_;
83 };
84
85 std::string g_channelStr = "";
86 class DCameraSourceControllerTest : public testing::Test {
87 public:
88 static void SetUpTestCase(void);
89 static void TearDownTestCase(void);
90 void SetUp();
91 void TearDown();
92
93 std::shared_ptr<DCameraSourceDev> camDev_;
94 std::shared_ptr<ICameraStateListener> stateListener_;
95 std::shared_ptr<DCameraSourceStateMachine> stateMachine_;
96 std::shared_ptr<DCameraSourceController> controller_;
97 std::vector<DCameraIndex> indexs_;
98 };
99
100 namespace {
101 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
102 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
103 const int32_t TEST_WIDTH = 1920;
104 const int32_t TEST_HEIGTH = 1080;
105 const int32_t TEST_FORMAT = 4;
106 const int32_t TEST_DATASPACE = 8;
107 const int32_t TEST_ISCAPTURE = 0;
108 const int32_t TEST_SLEEP_SEC = 200000;
109 const size_t DATABUFF_MAX_SIZE = 100 * 1024 * 1024;
110 static const char* DCAMERA_PROTOCOL_CMD_METADATA_RESULT = "METADATA_RESULT";
111 static const char* DCAMERA_PROTOCOL_CMD_STATE_NOTIFY = "STATE_NOTIFY";
112 }
113
SetUpTestCase(void)114 void DCameraSourceControllerTest::SetUpTestCase(void)
115 {
116 }
117
TearDownTestCase(void)118 void DCameraSourceControllerTest::TearDownTestCase(void)
119 {
120 }
121
SetUp(void)122 void DCameraSourceControllerTest::SetUp(void)
123 {
124 stateListener_ = std::make_shared<MockDCameraSourceStateListener>();
125 camDev_ = std::make_shared<MockDCameraSourceDev>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_);
126 stateMachine_ = std::make_shared<DCameraSourceStateMachine>(camDev_);
127 controller_ = std::make_shared<DCameraSourceController>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateMachine_,
128 camDev_);
129 controller_->channel_ = std::make_shared<MockCameraChannel>();
130 DCameraIndex index;
131 index.devId_ = TEST_DEVICE_ID;
132 index.dhId_ = TEST_CAMERA_DH_ID_0;
133 indexs_.push_back(index);
134 }
135
TearDown(void)136 void DCameraSourceControllerTest::TearDown(void)
137 {
138 usleep(TEST_SLEEP_SEC);
139 stateMachine_ = nullptr;
140 camDev_ = nullptr;
141 stateListener_ = nullptr;
142 controller_ = nullptr;
143 }
144
145 /**
146 * @tc.name: dcamera_source_controller_test_001
147 * @tc.desc: Verify source controller Init.
148 * @tc.type: FUNC
149 * @tc.require: Issue Number
150 */
151 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_001, TestSize.Level1)
152 {
153 int32_t ret = controller_->Init(indexs_);
154 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
155 }
156
157 /**
158 * @tc.name: dcamera_source_controller_test_002
159 * @tc.desc: Verify source controller UnInit.
160 * @tc.type: FUNC
161 * @tc.require: Issue Number
162 */
163 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_002, TestSize.Level1)
164 {
165 int32_t ret = controller_->Init(indexs_);
166 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
167 ret = controller_->UnInit();
168 EXPECT_EQ(ret, DCAMERA_OK);
169 }
170
171 /**
172 * @tc.name: dcamera_source_controller_test_003
173 * @tc.desc: Verify source controller StartCapture.
174 * @tc.type: FUNC
175 * @tc.require: Issue Number
176 */
177 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_003, TestSize.Level1)
178 {
179 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
180 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
181 capture->width_ = TEST_WIDTH;
182 capture->height_ = TEST_HEIGTH;
183 capture->format_ = TEST_FORMAT;
184 capture->dataspace_ = TEST_DATASPACE;
185 capture->isCapture_ = TEST_ISCAPTURE;
186 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
187 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
188 captureInfos.push_back(capture);
189
190 int32_t ret = controller_->Init(indexs_);
191 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
192 DCameraIndex index1;
193 index1.devId_ = TEST_DEVICE_ID;
194 index1.dhId_ = TEST_CAMERA_DH_ID_0;
195 controller_->indexs_.push_back(index1);
196 int32_t mode = 0;
197 ret = controller_->StartCapture(captureInfos, mode);
198 controller_->UnInit();
199 EXPECT_EQ(ret, DCAMERA_OK);
200 }
201
202 /**
203 * @tc.name: dcamera_source_controller_test_004
204 * @tc.desc: Verify source controller StartCapture and StopCapture.
205 * @tc.type: FUNC
206 * @tc.require: Issue Number
207 */
208 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_004, TestSize.Level1)
209 {
210 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
211 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
212 capture->width_ = TEST_WIDTH;
213 capture->height_ = TEST_HEIGTH;
214 capture->format_ = TEST_FORMAT;
215 capture->dataspace_ = TEST_DATASPACE;
216 capture->isCapture_ = TEST_ISCAPTURE;
217 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
218 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
219 captureInfos.push_back(capture);
220 int32_t ret = controller_->Init(indexs_);
221 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
222 DCameraIndex index1;
223 index1.devId_ = TEST_DEVICE_ID;
224 index1.dhId_ = TEST_CAMERA_DH_ID_0;
225 controller_->indexs_.push_back(index1);
226 int32_t mode = 0;
227 ret = controller_->StartCapture(captureInfos, mode);
228
229 ret = controller_->StopCapture();
230 controller_->UnInit();
231 EXPECT_EQ(ret, DCAMERA_BAD_VALUE);
232 }
233
234 /**
235 * @tc.name: dcamera_source_controller_test_005
236 * @tc.desc: Verify source controller ChannelNeg.
237 * @tc.type: FUNC
238 * @tc.require: Issue Number
239 */
240 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_005, TestSize.Level1)
241 {
242 DHLOGI("start execute dcamera_source_controller_test_005");
243 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
244 int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
245 DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
246 DCameraChannelDetail snapShotChInfo(SNAP_SHOT_SESSION_FLAG, SNAPSHOT_FRAME);
247 chanInfo->detail_.push_back(continueChInfo);
248 chanInfo->detail_.push_back(snapShotChInfo);
249 ret = controller_->Init(indexs_);
250 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
251 DCameraIndex index1;
252 index1.devId_ = TEST_DEVICE_ID;
253 index1.dhId_ = TEST_CAMERA_DH_ID_0;
254 controller_->indexs_.push_back(index1);
255 ret = controller_->ChannelNeg(chanInfo);
256 controller_->UnInit();
257 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
258 }
259
260 /**
261 * @tc.name: dcamera_source_controller_test_006
262 * @tc.desc: Verify source controller UpdateSettings.
263 * @tc.type: FUNC
264 * @tc.require: Issue Number
265 */
266 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_006, TestSize.Level1)
267 {
268 DHLOGI("start execute dcamera_source_controller_test_006");
269 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
270 std::vector<std::shared_ptr<DCameraSettings>> settings;
271 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
272 setting->type_ = DCSettingsType::DISABLE_METADATA;
273 setting->value_ = "UpdateSettingsTest";
274 settings.push_back(setting);
275
276 int32_t ret = controller_->Init(indexs_);
277 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
278 DCameraIndex index1;
279 index1.devId_ = TEST_DEVICE_ID;
280 index1.dhId_ = TEST_CAMERA_DH_ID_0;
281 controller_->indexs_.push_back(index1);
282 ret = controller_->UpdateSettings(settings);
283 controller_->UnInit();
284 EXPECT_EQ(ret, DCAMERA_OK);
285 }
286
287 /**
288 * @tc.name: dcamera_source_controller_test_007
289 * @tc.desc: Verify source controller GetCameraInfo.
290 * @tc.type: FUNC
291 * @tc.require: Issue Number
292 */
293 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_007, TestSize.Level1)
294 {
295 DHLOGI("start execute dcamera_source_controller_test_007");
296 int32_t ret = controller_->Init(indexs_);
297 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
298 DCameraIndex index1;
299 index1.devId_ = TEST_DEVICE_ID;
300 index1.dhId_ = TEST_CAMERA_DH_ID_0;
301 controller_->indexs_.push_back(index1);
302 std::shared_ptr<DCameraInfo> camInfo = std::make_shared<DCameraInfo>();
303 camInfo->state_ = 1;
304 ret = controller_->GetCameraInfo(camInfo);
305 controller_->UnInit();
306 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
307 }
308
309 /**
310 * @tc.name: dcamera_source_controller_test_008
311 * @tc.desc: Verify source controller OpenChannel.
312 * @tc.type: FUNC
313 * @tc.require: Issue Number
314 */
315 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_008, TestSize.Level1)
316 {
317 int32_t ret = controller_->Init(indexs_);
318 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
319 DCameraIndex index1;
320 index1.devId_ = TEST_DEVICE_ID;
321 index1.dhId_ = TEST_CAMERA_DH_ID_0;
322 controller_->indexs_.push_back(index1);
323 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
324 ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
325 ret = controller_->OpenChannel(openInfo);
326 controller_->UnInit();
327 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
328 }
329
330 /**
331 * @tc.name: dcamera_source_controller_test_009
332 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
333 * @tc.type: FUNC
334 * @tc.require: Issue Number
335 */
336 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_009, TestSize.Level1)
337 {
338 int32_t ret = controller_->Init(indexs_);
339 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
340 DCameraIndex index1;
341 index1.devId_ = TEST_DEVICE_ID;
342 index1.dhId_ = TEST_CAMERA_DH_ID_0;
343 controller_->indexs_.push_back(index1);
344 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
345 ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
346 controller_->OpenChannel(openInfo);
347 ret = controller_->CloseChannel();
348 controller_->UnInit();
349 EXPECT_EQ(ret, DCAMERA_OK);
350 }
351
352 /**
353 * @tc.name: dcamera_source_controller_test_010
354 * @tc.desc: Verify source controller OnDataReceived.
355 * @tc.type: FUNC
356 * @tc.require: Issue Number
357 */
358 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_010, TestSize.Level1)
359 {
360 int32_t ret = controller_->Init(indexs_);
361 ret = camDev_->InitDCameraSourceDev();
362 std::shared_ptr<ICameraChannelListener> listener =
363 std::make_shared<DCameraSourceControllerChannelListener>(controller_);
364 int32_t state = 0;
365 listener->OnSessionState(state, "");
366 state = 1;
367 listener->OnSessionState(state, "");
368 int32_t eventType = 1;
369 int32_t eventReason = 1;
370 std::string detail = "OnSessionErrorTest";
371 listener->OnSessionError(eventType, eventReason, detail);
372 std::vector<std::shared_ptr<DataBuffer>> buffers;
373 listener->OnDataReceived(buffers);
374 size_t capacity = 0;
375 std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
376 buffers.push_back(dataBuffer);
377 listener->OnDataReceived(buffers);
378 buffers.clear();
379 capacity = DATABUFF_MAX_SIZE + 1;
380 dataBuffer = std::make_shared<DataBuffer>(capacity);
381 buffers.push_back(dataBuffer);
382 listener->OnDataReceived(buffers);
383 buffers.clear();
384 capacity = 1;
385 dataBuffer = std::make_shared<DataBuffer>(capacity);
386 buffers.push_back(dataBuffer);
387 listener->OnDataReceived(buffers);
388 ret = controller_->UnInit();
389 EXPECT_EQ(ret, DCAMERA_OK);
390 }
391
392 /**
393 * @tc.name: dcamera_source_controller_test_011
394 * @tc.desc: Verify source controller ChannelNeg.
395 * @tc.type: FUNC
396 * @tc.require: Issue Number
397 */
398 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_011, TestSize.Level1)
399 {
400 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
401 int32_t ret = GetLocalDeviceNetworkId(chanInfo->sourceDevId_);
402 DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
403 DCameraChannelDetail snapShotChInfo(SNAP_SHOT_SESSION_FLAG, SNAPSHOT_FRAME);
404 chanInfo->detail_.push_back(continueChInfo);
405 chanInfo->detail_.push_back(snapShotChInfo);
406 DCameraIndex index1;
407 index1.devId_ = TEST_DEVICE_ID;
408 index1.dhId_ = TEST_CAMERA_DH_ID_0;
409 DCameraIndex index2;
410 index2.devId_ = TEST_DEVICE_ID;
411 index2.dhId_ = TEST_CAMERA_DH_ID_0;
412 controller_->Init(indexs_);
413
414 controller_->indexs_.push_back(index1);
415 controller_->indexs_.push_back(index2);
416 ret = controller_->ChannelNeg(chanInfo);
417 controller_->UnInit();
418 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
419 }
420
421 /**
422 * @tc.name: dcamera_source_controller_test_012
423 * @tc.desc: Verify source controller DCameraNotify.
424 * @tc.type: FUNC
425 * @tc.require: Issue Number
426 */
427 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012, TestSize.Level1)
428 {
429 std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
430 events->eventType_ = 1;
431 events->eventResult_ = DCAMERA_EVENT_CAMERA_ERROR;
432 events->eventContent_ = "controllerTest012";
433 int32_t ret = controller_->DCameraNotify(events);
434 controller_->UnInit();
435 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
436 }
437
438 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012_1, TestSize.Level1)
439 {
440 std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
441 events->eventType_ = 1;
442 events->eventResult_ = DCAMERA_EVENT_CAMERA_SUCCESS;
443 events->eventContent_ = START_CAPTURE_SUCC;
444 int32_t ret = controller_->DCameraNotify(events);
445 controller_->UnInit();
446 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
447 }
448
449 /**
450 * @tc.name: dcamera_source_controller_test_013
451 * @tc.desc: Verify source controller UpdateSettings.
452 * @tc.type: FUNC
453 * @tc.require: Issue Number
454 */
455 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_013, TestSize.Level1)
456 {
457 std::shared_ptr<DCameraChannelInfo> chanInfo = std::make_shared<DCameraChannelInfo>();
458 std::vector<std::shared_ptr<DCameraSettings>> settings;
459 std::shared_ptr<DCameraSettings> setting = std::make_shared<DCameraSettings>();
460 setting->type_ = DCSettingsType::DISABLE_METADATA;
461 setting->value_ = "UpdateSettingsTest";
462 settings.push_back(setting);
463 DCameraIndex index1;
464 index1.devId_ = TEST_DEVICE_ID;
465 index1.dhId_ = TEST_CAMERA_DH_ID_0;
466 DCameraIndex index2;
467 index2.devId_ = TEST_DEVICE_ID;
468 index2.dhId_ = TEST_CAMERA_DH_ID_0;
469 controller_->indexs_.push_back(index1);
470 controller_->indexs_.push_back(index2);
471 int32_t ret = controller_->UpdateSettings(settings);
472 controller_->UnInit();
473 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
474 }
475
476 /**
477 * @tc.name: dcamera_source_controller_test_014
478 * @tc.desc: Verify source controller GetCameraInfo.
479 * @tc.type: FUNC
480 * @tc.require: Issue Number
481 */
482 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_014, TestSize.Level1)
483 {
484 DCameraIndex index1;
485 index1.devId_ = TEST_DEVICE_ID;
486 index1.dhId_ = TEST_CAMERA_DH_ID_0;
487 DCameraIndex index2;
488 index2.devId_ = TEST_DEVICE_ID;
489 index2.dhId_ = TEST_CAMERA_DH_ID_0;
490 controller_->indexs_.push_back(index1);
491 controller_->indexs_.push_back(index2);
492 indexs_.push_back(index1);
493
494 std::shared_ptr<DCameraInfo> camInfo = std::make_shared<DCameraInfo>();
495 camInfo->state_ = 1;
496 int32_t ret = controller_->GetCameraInfo(camInfo);
497 controller_->UnInit();
498 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
499 }
500
501 /**
502 * @tc.name: dcamera_source_controller_test_015
503 * @tc.desc: Verify source controller OpenChannel.
504 * @tc.type: FUNC
505 * @tc.require: Issue Number
506 */
507 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015, TestSize.Level1)
508 {
509 DCameraIndex index1;
510 index1.devId_ = TEST_DEVICE_ID;
511 index1.dhId_ = TEST_CAMERA_DH_ID_0;
512 DCameraIndex index2;
513 index2.devId_ = TEST_DEVICE_ID;
514 index2.dhId_ = TEST_CAMERA_DH_ID_0;
515 controller_->indexs_.push_back(index1);
516 controller_->indexs_.push_back(index2);
517 indexs_.push_back(index1);
518
519 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
520 int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
521 ret = controller_->OpenChannel(openInfo);
522 controller_->UnInit();
523 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
524 }
525
526 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015_1, TestSize.Level1)
527 {
528 DCameraIndex index1;
529 index1.devId_ = TEST_DEVICE_ID;
530 index1.dhId_ = TEST_CAMERA_DH_ID_0;
531 controller_->indexs_.push_back(index1);
532 indexs_.push_back(index1);
533
534 bool saved = ManageSelectChannel::GetInstance().GetSrcConnect();
535 ManageSelectChannel::GetInstance().SetSrcConnect(true);
536 std::shared_ptr<DCameraOpenInfo> openInfo = std::make_shared<DCameraOpenInfo>();
537 int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_);
538 ret = controller_->OpenChannel(openInfo);
539 ret = controller_->UnInit();
540 ManageSelectChannel::GetInstance().SetSrcConnect(saved);
541 EXPECT_EQ(ret, DCAMERA_OK);
542 }
543
544 /**
545 * @tc.name: dcamera_source_controller_test_016
546 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
547 * @tc.type: FUNC
548 * @tc.require: Issue Number
549 */
550 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_016, TestSize.Level1)
551 {
552 DCameraIndex index1;
553 index1.devId_ = TEST_DEVICE_ID;
554 index1.dhId_ = TEST_CAMERA_DH_ID_0;
555 DCameraIndex index2;
556 index2.devId_ = TEST_DEVICE_ID;
557 index2.dhId_ = TEST_CAMERA_DH_ID_0;
558 controller_->indexs_.push_back(index1);
559 controller_->indexs_.push_back(index2);
560 controller_->CloseChannel();
561 int32_t ret = controller_->UnInit();
562 EXPECT_EQ(ret, DCAMERA_OK);
563 }
564
565 /**
566 * @tc.name: dcamera_source_controller_test_017
567 * @tc.desc: Verify source controller OpenChannel and HandleMetaDataResult.
568 * @tc.type: FUNC
569 * @tc.require: Issue Number
570 */
571 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_017, TestSize.Level1)
572 {
573 int32_t ret = controller_->Init(indexs_);
574 std::string jsonStr = "controllerTest17";
575 controller_->HandleMetaDataResult(jsonStr);
576 ret = controller_->UnInit();
577 EXPECT_EQ(ret, DCAMERA_OK);
578 }
579
580 /**
581 * @tc.name: dcamera_source_controller_test_018
582 * @tc.desc: Verify source controller OpenChannel and WaitforSessionResult.
583 * @tc.type: FUNC
584 * @tc.require: Issue Number
585 */
586 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_018, TestSize.Level1)
587 {
588 int32_t ret = camDev_->InitDCameraSourceDev();
589 controller_->PublishEnableLatencyMsg(TEST_DEVICE_ID);
590 ret = controller_->UnInit();
591 EXPECT_EQ(ret, DCAMERA_OK);
592 }
593
594 /**
595 * @tc.name: dcamera_source_controller_test_019
596 * @tc.desc: Verify source controller OnSessionError.
597 * @tc.type: FUNC
598 * @tc.require: Issue Number
599 */
600 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSize.Level1)
601 {
602 int32_t ret = controller_->Init(indexs_);
603 std::shared_ptr<DCameraSourceController> controller = nullptr;
604 std::shared_ptr<ICameraChannelListener> listener_ =
605 std::make_shared<DCameraSourceControllerChannelListener>(controller);
606 int32_t state = DCAMERA_CHANNEL_STATE_CONNECTED;
607 listener_->OnSessionState(state, "");
608 int32_t eventType = 1;
609 int32_t eventReason = 1;
610 std::string detail = "OnSessionErrorTest";
611 listener_->OnSessionError(eventType, eventReason, detail);
612 std::vector<std::shared_ptr<DataBuffer>> buffers;
613 listener_->OnDataReceived(buffers);
614 ret = controller_->UnInit();
615 EXPECT_EQ(ret, DCAMERA_OK);
616 }
617
618 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019_1, TestSize.Level1)
619 {
620 int32_t ret = controller_->Init(indexs_);
621 std::shared_ptr<ICameraChannelListener> listener_ =
622 std::make_shared<DCameraSourceControllerChannelListener>(controller_);
623 stateMachine_->UpdateState(DCAMERA_STATE_INIT);
624 int32_t state = DCAMERA_CHANNEL_STATE_CONNECTED;
625 listener_->OnSessionState(state, "");
626 int32_t eventType = 1;
627 int32_t eventReason = 1;
628 std::string detail = "OnSessionErrorTest";
629 listener_->OnSessionError(eventType, eventReason, detail);
630 std::vector<std::shared_ptr<DataBuffer>> buffers;
631 listener_->OnDataReceived(buffers);
632 ret = controller_->UnInit();
633 EXPECT_EQ(ret, DCAMERA_OK);
634 }
635
636 /**
637 * @tc.name: dcamera_source_controller_test_020
638 * @tc.desc: Verify source controller OpenChannel and CloseChannel.
639 * @tc.type: FUNC
640 * @tc.require: Issue Number
641 */
642 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_020, TestSize.Level1)
643 {
644 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
645 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
646 capture->width_ = TEST_WIDTH;
647 capture->height_ = TEST_HEIGTH;
648 capture->format_ = TEST_FORMAT;
649 capture->dataspace_ = TEST_DATASPACE;
650 capture->isCapture_ = TEST_ISCAPTURE;
651 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
652 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
653 captureInfos.push_back(capture);
654 DCameraIndex index1;
655 index1.devId_ = TEST_DEVICE_ID;
656 index1.dhId_ = TEST_CAMERA_DH_ID_0;
657 DCameraIndex index2;
658 index2.devId_ = TEST_DEVICE_ID;
659 index2.dhId_ = TEST_CAMERA_DH_ID_0;
660 controller_->indexs_.push_back(index1);
661 controller_->indexs_.push_back(index2);
662 indexs_.push_back(index1);
663
664 int32_t ret = controller_->Init(indexs_);
665 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
666 int32_t mode = 0;
667 ret = controller_->StartCapture(captureInfos, mode);
668 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
669 ret = controller_->StopCapture();
670 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
671 }
672
673 /**
674 * @tc.name: dcamera_source_controller_test_021
675 * @tc.desc: Verify source controller DCameraNotify.
676 * @tc.type: FUNC
677 * @tc.require: Issue Number
678 */
679 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_021, TestSize.Level1)
680 {
681 std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
682 events->eventType_ = 1;
683 events->eventResult_ = DCAMERA_EVENT_CAMERA_SUCCESS;
684 events->eventContent_ = START_CAPTURE_SUCC;
685 controller_->camHdiProvider_ = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
686 int32_t ret = controller_->DCameraNotify(events);
687 int32_t state = 2;
688 std::shared_ptr<ICameraStateListener> stateLisener = std::make_shared<CameraStateListenerImpl>();
689 std::shared_ptr<DCameraSourceDev> camDev = std::make_shared<DCameraSourceDev>("devId", "dhId",
690 stateLisener);
691 std::shared_ptr<DCameraSourceStateMachine> stMachine = std::make_shared<DCameraSourceStateMachine>(camDev);
692 controller_->stateMachine_ = stMachine;
693 std::shared_ptr<DCameraSourceState> currentState = std::make_shared<DCameraSourceStateImpl>();
694 controller_->stateMachine_->currentState_ = currentState;
695 controller_->OnSessionState(state, "networkId");
696 controller_->camDev_ = std::make_shared<DCameraSourceDev>("devId", "dhId", stateLisener);
697 controller_->PostChannelDisconnectedEvent();
698 controller_->PauseDistributedHardware("networkId");
699 controller_->ResumeDistributedHardware("networkId");
700 controller_->StopDistributedHardware("networkId");
701 controller_->UnInit();
702 EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
703 }
704
705 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_022, TestSize.Level1)
706 {
707 std::vector<std::shared_ptr<DCameraCaptureInfo>> captureInfos;
708 std::shared_ptr<DCameraCaptureInfo> capture = std::make_shared<DCameraCaptureInfo>();
709 capture->width_ = TEST_WIDTH;
710 capture->height_ = TEST_HEIGTH;
711 capture->format_ = TEST_FORMAT;
712 capture->dataspace_ = TEST_DATASPACE;
713 capture->isCapture_ = TEST_ISCAPTURE;
714 capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264;
715 capture->streamType_ = DCStreamType::SNAPSHOT_FRAME;
716 captureInfos.push_back(capture);
717 int32_t ret = controller_->Init(indexs_);
718 EXPECT_EQ(ret, DCAMERA_INIT_ERR);
719 DCameraIndex index1;
720 index1.devId_ = TEST_DEVICE_ID;
721 index1.dhId_ = TEST_CAMERA_DH_ID_0;
722 controller_->indexs_.push_back(index1);
723 int32_t mode = 0;
724 ret = controller_->StartCapture(captureInfos, mode);
725 bool saved = ManageSelectChannel::GetInstance().GetSrcConnect();
726 ManageSelectChannel::GetInstance().SetSrcConnect(true);
727 ret = controller_->StopCapture();
728 controller_->UnInit();
729 ManageSelectChannel::GetInstance().SetSrcConnect(saved);
730 EXPECT_EQ(ret, DCAMERA_OK);
731 }
732
733 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_023, TestSize.Level1)
734 {
735 cJSON *metaJson1 = cJSON_CreateObject();
736 cJSON_AddStringToObject(metaJson1, "Command", "skip");
737 std::string cjson1 = cJSON_PrintUnformatted(metaJson1);
738 size_t capacity = cjson1.length() + 1;
739 std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
740 if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) {
741 EXPECT_TRUE(false);
742 }
743 controller_->HandleReceivedData(dataBuffer);
744 cJSON_Delete(metaJson1);
745
746 metaJson1 = cJSON_CreateObject();
747 cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_METADATA_RESULT);
748 cjson1 = cJSON_PrintUnformatted(metaJson1);
749 capacity = cjson1.length() + 1;
750 dataBuffer = std::make_shared<DataBuffer>(capacity);
751 if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) {
752 EXPECT_TRUE(false);
753 }
754 controller_->HandleReceivedData(dataBuffer);
755 cJSON_Delete(metaJson1);
756
757 metaJson1 = cJSON_CreateObject();
758 cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_STATE_NOTIFY);
759 cjson1 = cJSON_PrintUnformatted(metaJson1);
760 capacity = cjson1.length() + 1;
761 dataBuffer = std::make_shared<DataBuffer>(capacity);
762 if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) {
763 EXPECT_TRUE(false);
764 }
765 controller_->HandleReceivedData(dataBuffer);
766 cJSON_Delete(metaJson1);
767 EXPECT_FALSE(controller_->CheckAclRight());
768 }
769
770 HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_024, TestSize.Level1)
771 {
772 std::string networkId = "testNetworkId";
773 bool isInvalid = false;
774 int32_t typeVal = controller_->CheckOsType(networkId, isInvalid);
775 typeVal = 50;
776 std::string jsonStr = "{\"OS_TYPE\": 50}";
777 std::string key = "OS_TYPE";
778 int32_t result = controller_->ParseValueFromCjson(jsonStr, key);
779 EXPECT_EQ(result, typeVal);
780
781 jsonStr = "invalid_json";
782 key = "typeVal";
783 result = controller_->ParseValueFromCjson(jsonStr, key);
784 EXPECT_EQ(result, DCAMERA_BAD_VALUE);
785
786 jsonStr = "{\"test\": 80}";
787 result = controller_->ParseValueFromCjson(jsonStr, key);
788 EXPECT_EQ(result, DCAMERA_BAD_VALUE);
789
790 jsonStr = "{\"test\": \"typeVal\"}";
791 result = controller_->ParseValueFromCjson(jsonStr, key);
792 EXPECT_EQ(result, DCAMERA_BAD_VALUE);
793
794 jsonStr = "";
795 result = controller_->ParseValueFromCjson(jsonStr, key);
796 EXPECT_EQ(result, DCAMERA_BAD_VALUE);
797
798 jsonStr = "null";
799 key = "typeVal";
800 result = controller_->ParseValueFromCjson(jsonStr, key);
801 EXPECT_EQ(result, DCAMERA_BAD_VALUE);
802 }
803 }
804 }