From f76aa7aaebeb47002d7945c5e5792d0f79f80d04 Mon Sep 17 00:00:00 2001 From: Bobie Date: Mon, 8 Jul 2024 10:29:58 +0800 Subject: [PATCH] fix sinkservice issue Signed-off-by: Bobie --- .../handler/src/dcamera_handler.cpp | 13 +++++++ .../distributed_camera_sink_service.cpp | 22 ++++++++---- .../dcamera_sink_controller.cpp | 29 ++++++++++++++-- .../dcamera_sink_data_process.cpp | 5 +++ .../dcamera_sink_output.cpp | 7 ++++ .../dcamera_sink_service_ipc.cpp | 4 ++- .../dcamera_sink_access_control_test.cpp | 4 +++ .../dcamera_sink_controller_test.cpp | 34 +++++++++++++++++++ .../dcamera_sink_data_process_test.cpp | 8 +++++ .../dcamera_sink_dev_test.cpp | 14 ++++++++ .../dcamera_sink_output_test.cpp | 8 +++++ .../dcamera_frame_trigger_event_test.cpp | 1 + .../dcamera_photo_output_event_test.cpp | 1 + 13 files changed, 140 insertions(+), 10 deletions(-) diff --git a/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp b/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp index 5ab748d3..07871f67 100644 --- a/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp +++ b/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp @@ -64,6 +64,9 @@ std::vector DCameraHandler::QueryMeta() return itemList; } for (auto& info : cameraList) { + if (info == nullptr) { + continue; + } if (info->GetConnectionType() != CameraStandard::ConnectionType::CAMERA_CONNECTION_BUILT_IN) { DHLOGI("connection type: %{public}d", info->GetConnectionType()); continue; @@ -92,6 +95,9 @@ std::vector DCameraHandler::Query() return itemList; } for (auto& info : cameraList) { + if (info == nullptr) { + continue; + } if ((info->GetConnectionType() != CameraStandard::ConnectionType::CAMERA_CONNECTION_BUILT_IN)) { DHLOGI("connection type: %{public}d", info->GetConnectionType()); continue; @@ -139,6 +145,7 @@ void DCameraHandler::UnRegisterPluginListener() std::vector DCameraHandler::GetCameras() { std::vector cameras; + CHECK_AND_RETURN_RET_LOG(cameraManager_ == nullptr, itemList, "cameraManager is null."); std::vector> cameraList = cameraManager_->GetSupportedCameras(); uint64_t listSize = static_cast(cameraList.size()); DHLOGI("get %{public}" PRIu64" cameras", listSize); @@ -147,6 +154,9 @@ std::vector DCameraHandler::GetCameras() return cameras; } for (auto& info : cameraList) { + if (info == nullptr) { + continue; + } sptr capability = cameraManager_->GetSupportedOutputCapability(info); if (capability == nullptr) { DHLOGI("get supported capability is null"); @@ -198,6 +208,7 @@ int32_t DCameraHandler::CreateAVCodecList(cJSON *root) int32_t DCameraHandler::CreateMetaDHItem(sptr& info, DHItem& item) { + CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "Camera info is null"); std::string id = info->GetID(); item.dhId = CAMERA_ID_PREFIX + id; item.subtype = "camera"; @@ -219,6 +230,8 @@ int32_t DCameraHandler::CreateMetaDHItem(sptr& inf int32_t DCameraHandler::CreateDHItem(sptr& info, DHItem& item) { + CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "Camera info is null"); + CHECK_AND_RETURN_RET_LOG(cameraManager_ == nullptr, DCAMERA_BAD_VALUE, "Camera manager is null"); std::string id = info->GetID(); item.dhId = CAMERA_ID_PREFIX + id; item.subtype = "camera"; diff --git a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp index 20b87e8e..9ad77af7 100644 --- a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp +++ b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_service.cpp @@ -109,6 +109,7 @@ int32_t DistributedCameraSinkService::ReleaseSink() std::lock_guard lock(mapMutex_); for (auto iter = camerasMap_.begin(); iter != camerasMap_.end(); iter++) { std::shared_ptr sinkDevice = iter->second; + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->UnInit(); CHECK_AND_LOG(ret != DCAMERA_OK, "release sink device failed, ret: %{public}d", ret); } @@ -137,7 +138,7 @@ int32_t DistributedCameraSinkService::SubscribeLocalHardware(const std::string& } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->SubscribeLocalHardware(parameters); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "SubscribeLocalHardware failed, ret: %{public}d", ret); DHLOGI("SubscribeLocalHardware success"); @@ -157,7 +158,7 @@ int32_t DistributedCameraSinkService::UnsubscribeLocalHardware(const std::string } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->UnsubscribeLocalHardware(); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "UnsubscribeLocalHardware failed, ret: %{public}d", ret); DHLOGI("UnsubscribeLocalHardware success"); @@ -177,7 +178,7 @@ int32_t DistributedCameraSinkService::StopCapture(const std::string& dhId) } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->StopCapture(); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "StopCapture failed, ret: %{public}d", ret); DHLOGI("StopCapture success"); @@ -197,7 +198,7 @@ int32_t DistributedCameraSinkService::ChannelNeg(const std::string& dhId, std::s } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->ChannelNeg(channelInfo); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "ChannelNeg failed, ret: %{public}d", ret); DHLOGI("ChannelNeg success"); @@ -217,7 +218,7 @@ int32_t DistributedCameraSinkService::GetCameraInfo(const std::string& dhId, std } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->GetCameraInfo(cameraInfo); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "GetCameraInfo failed, ret: %{public}d", ret); DHLOGI("GetCameraInfo success"); @@ -237,7 +238,7 @@ int32_t DistributedCameraSinkService::OpenChannel(const std::string& dhId, std:: } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->OpenChannel(openInfo); if (ret != DCAMERA_OK) { DHLOGE("OpenChannel failed, ret: %{public}d", ret); @@ -262,7 +263,7 @@ int32_t DistributedCameraSinkService::CloseChannel(const std::string& dhId) } sinkDevice = iter->second; } - + CHECK_AND_RETURN_RET_LOG(sinkDevice== nullptr, DCAMERA_BAD_VALUE, "Sink device is null"); int32_t ret = sinkDevice->CloseChannel(); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "CloseChannel failed, ret: %{public}d", ret); DHLOGI("CloseChannel success"); @@ -299,6 +300,9 @@ void DistributedCameraSinkService::GetCamIds() { std::lock_guard lock(mapMutex_); for (auto it = camerasMap_.begin(); it != camerasMap_.end(); it++) { + if (it->second == nullptr) { + continue; + } camIds.push_back(it->second->GetDhid()); } } @@ -307,6 +311,9 @@ void DistributedCameraSinkService::GetCamIds() void DistributedCameraSinkService::GetCamDumpInfo(CameraDumpInfo& camDump) { + if (dcSinkService == nullptr) { + return; + } dcSinkService->GetCamIds(); camDump = g_camDump; } @@ -321,6 +328,7 @@ bool DistributedCameraSinkService::IsCurSinkDev(std::shared_ptr ret = cmd.Unmarshal(camInfoJson); CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, false, "DCameraInfoCmd Unmarshal failed: %{public}d", ret); std::shared_ptr camInfo = cmd.value_; + CHECK_AND_RETURN_RET_LOG(camInfo == nullptr, false, "Camera info is null"); if (camInfo->state_ == DCAMERA_CHANNEL_STATE_CONNECTED) { return true; } diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp index c94d88ea..48a16a56 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp @@ -195,6 +195,7 @@ int32_t DCameraSinkController::UpdateSettings(std::vector& camInfo) { DHLOGI("GetCameraInfo dhId: %{public}s, session state: %{public}d", GetAnonyString(dhId_).c_str(), sessionState_); + CHECK_AND_RETURN_RET_LOG(camInfo == nullptr, DCAMERA_BAD_VALUE, "Camera info is null"); camInfo->state_ = sessionState_; return DCAMERA_OK; } @@ -206,6 +207,7 @@ int32_t DCameraSinkController::OpenChannel(std::shared_ptr& ope DHLOGE("DCameraSinkController OpenChannel fail, CheckPermission fail"); return DCAMERA_WRONG_STATE; } + CHECK_AND_RETURN_RET_LOG(openInfo == nullptr, DCAMERA_BAD_VALUE, "Open info is null"); if (sessionState_ != DCAMERA_CHANNEL_STATE_DISCONNECTED) { DHLOGE("wrong state, dhId: %{public}s, sessionState: %{public}d", GetAnonyString(dhId_).c_str(), sessionState_); return DCAMERA_WRONG_STATE; @@ -235,6 +237,7 @@ int32_t DCameraSinkController::OpenChannel(std::shared_ptr& ope auto controller = std::shared_ptr(shared_from_this()); std::shared_ptr listener = std::make_shared(controller); + CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "Camera channel is null"); ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener); if (ret != DCAMERA_OK) { DHLOGE("channel create session failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret); @@ -251,6 +254,7 @@ int32_t DCameraSinkController::PullUpPage() if (isSensitive_) { bool isSensitive = false; bool isSameAccout = false; + CHECK_AND_RETURN_RET_LOG(sinkCallback_ == nullptr, DCAMERA_BAD_VALUE, "Sink callback is null"); int32_t ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, PAGE_SUBTYPE, srcDevId_, isSensitive, isSameAccout); if (ret != DCAMERA_OK) { @@ -277,7 +281,7 @@ int32_t DCameraSinkController::CloseChannel() DHLOGE("DCameraSinkController release channel failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret); } - + CHECK_AND_RETURN_RET_LOG(output_ == nullptr, DCAMERA_BAD_VALUE, "Output is null"); ret = output_->CloseChannel(); if (ret != DCAMERA_OK) { DHLOGE("DCameraSinkController CloseChannel failed, dhId: %{public}s, ret: %{public}d", @@ -287,6 +291,7 @@ int32_t DCameraSinkController::CloseChannel() if (isPageStatus_.load()) { bool isSensitive = false; bool isSameAccout = false; + CHECK_AND_RETURN_RET_LOG(sinkCallback_ == nullptr, DCAMERA_BAD_VALUE, "Sink callback is null"); ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, PAGE_SUBTYPE, srcDevId_, isSensitive, isSameAccout); if (ret != DCAMERA_OK) { @@ -398,6 +403,10 @@ void DCameraSinkController::DCameraSinkContrEventHandler::ProcessEvent(const App void DCameraSinkController::ProcessFrameTrigger(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGD("Receive frame trigger event then start process data in sink controller."); + if (accessControl_ == nullptr) { + DHLOGD("access controller is null."); + return; + } std::shared_ptr param = event->GetSharedObject(); accessControl_->TriggerFrame(*param); } @@ -412,6 +421,10 @@ void DCameraSinkController::ProcessPostAuthorization(const AppExecFwk::InnerEven void DCameraSinkController::OnStateChanged(std::shared_ptr& event) { + if (event == nullptr) { + DHLOGE("event is null."); + return; + } DHLOGI("DCameraSinkController::OnStateChanged dhId: %{public}s, result: %{public}d", GetAnonyString(dhId_).c_str(), event->eventResult_); if (event->eventResult_ == DCAMERA_EVENT_DEVICE_PREEMPT) { @@ -447,6 +460,10 @@ void DCameraSinkController::OnMetadataResult(std::vectorSendData(buffer); if (ret != DCAMERA_OK) { DHLOGE("channel send data failed, dhId: %{public}s ret: %{public}d", GetAnonyString(dhId_).c_str(), ret); @@ -502,6 +519,9 @@ void DCameraSinkController::OnDataReceived(std::vectorSize() <= 0 || buffer->Size() > DATABUFF_MAX_SIZE) { DHLOGI("buffer is invalid"); return; @@ -515,7 +535,9 @@ void DCameraSinkController::PostAuthorization(std::vectorNotifySensitiveSrc(SRC_TYPE); + if (accessControl_ != nullptr) { + accessControl_->NotifySensitiveSrc(SRC_TYPE); + } } } @@ -523,6 +545,7 @@ int32_t DCameraSinkController::StartCaptureInner(std::vector autoLock(captureLock_); + CHECK_AND_RETURN_RET_LOG(output_ == nullptr, DCAMERA_BAD_VALUE, "output is null"); int32_t ret = output_->StartCapture(captureInfos); if (ret != DCAMERA_OK) { DHLOGE("output start capture failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret); @@ -535,6 +558,7 @@ int32_t DCameraSinkController::StartCaptureInner(std::vectorStartCapture(captureInfos, carrier.surface_); if (ret != DCAMERA_OK) { DHLOGE("camera client start capture failed, dhId: %{public}s, ret: %{public}d", @@ -566,6 +590,7 @@ int32_t DCameraSinkController::DCameraNotifyInner(int32_t type, int32_t result, int32_t DCameraSinkController::HandleReceivedData(std::shared_ptr& dataBuffer) { DHLOGI("DCameraSinkController::HandleReceivedData dhId: %{public}s", GetAnonyString(dhId_).c_str()); + CHECK_AND_RETURN_RET_LOG(dataBuffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null"); uint8_t *data = dataBuffer->Data(); std::string jsonStr(reinterpret_cast(data), dataBuffer->Capacity()); cJSON *rootValue = cJSON_Parse(jsonStr.c_str()); diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_data_process.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_data_process.cpp index 5e588116..636052f9 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_data_process.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_data_process.cpp @@ -70,6 +70,7 @@ void DCameraSinkDataProcess::StartEventHandler() int32_t DCameraSinkDataProcess::StartCapture(std::shared_ptr& captureInfo) { + CHECK_AND_RETURN_RET_LOG(captureInfo == nullptr, DCAMERA_BAD_VALUE, "Capture info is null"); DHLOGI("StartCapture dhId: %{public}s, width: %{public}d, height: %{public}d, format: %{public}d, stream: " "%{public}d, encode: %{public}d", GetAnonyString(dhId_).c_str(), captureInfo->width_, captureInfo->height_, captureInfo->format_, captureInfo->streamType_, captureInfo->encodeType_); @@ -150,6 +151,10 @@ void DCameraSinkDataProcess::SendDataAsync(const std::shared_ptr& bu { auto sendFunc = [this, buffer]() mutable { std::shared_ptr sendBuffer = buffer; + if (buffer == nullptr || channel_ == nullptr || captureInfo_ == nullptr) { + DHLOGE("Existing null pointer."); + return; + } int32_t ret = channel_->SendData(sendBuffer); uint64_t buffersSize = static_cast(buffer->Size()); DHLOGD("SendData type: %{public}d output data ret: %{public}d, dhId: %{public}s, bufferSize: %{public}" PRIu64, diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_output.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_output.cpp index e3efaca1..e524801c 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_output.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_output.cpp @@ -46,6 +46,7 @@ int32_t DCameraSinkOutput::Init() DHLOGI("Init dhId: %{public}s", GetAnonyString(dhId_).c_str()); auto output = std::shared_ptr(shared_from_this()); std::shared_ptr resultCallback = std::make_shared(output); + CHECK_AND_RETURN_RET_LOG(operator_ == nullptr, DCAMERA_BAD_VALUE, "Operator is null"); operator_->SetResultCallback(resultCallback); InitInner(CONTINUOUS_FRAME); @@ -78,6 +79,7 @@ int32_t DCameraSinkOutput::UnInit() int32_t DCameraSinkOutput::OpenChannel(std::shared_ptr& info) { + CHECK_AND_RETURN_RET_LOG(info == nullptr, DCAMERA_BAD_VALUE, "Camera info is null"); DHLOGI("OpenChannel dhId: %{public}s", GetAnonyString(dhId_).c_str()); std::map modeMaps; modeMaps.emplace(CONTINUOUS_FRAME, DCAMERA_SESSION_MODE_VIDEO); @@ -113,6 +115,7 @@ int32_t DCameraSinkOutput::CloseChannel() auto iterCon = channels_.find(CONTINUOUS_FRAME); if (iterCon != channels_.end()) { int32_t ret = DCAMERA_OK; + CHECK_AND_RETURN_RET_LOG(iterCon->second == nullptr, DCAMERA_BAD_VALUE, "Connect is null"); ret = iterCon->second->ReleaseSession(); if (ret != DCAMERA_OK) { DHLOGI("DCameraSinkOutput UnInit release continue session failed, dhId: %{public}s, ret: %{public}d", @@ -124,6 +127,7 @@ int32_t DCameraSinkOutput::CloseChannel() auto iterSnap = channels_.find(SNAPSHOT_FRAME); if (iterSnap != channels_.end()) { int32_t ret = DCAMERA_OK; + CHECK_AND_RETURN_RET_LOG(iterSnap->second == nullptr, DCAMERA_BAD_VALUE, "Snapshot is null"); ret = iterSnap->second->ReleaseSession(); if (ret != DCAMERA_OK) { DHLOGI("DCameraSinkOutput UnInit release snapshot session failed, dhId: %{public}s, ret: %{public}d", @@ -157,6 +161,7 @@ int32_t DCameraSinkOutput::StopCapture() auto iterCon = dataProcesses_.find(CONTINUOUS_FRAME); if (iterCon != dataProcesses_.end()) { DHLOGI("StopCapture %{public}s continuous frame stop capture", GetAnonyString(dhId_).c_str()); + CHECK_AND_RETURN_RET_LOG(iterCon->second == nullptr, DCAMERA_BAD_VALUE, "Connect is null"); int32_t ret = iterCon->second->StopCapture(); if (ret != DCAMERA_OK) { DHLOGE("continuous data process stop capture failed, dhId: %{public}s, ret: %{public}d", @@ -167,6 +172,7 @@ int32_t DCameraSinkOutput::StopCapture() auto iterSnap = dataProcesses_.find(SNAPSHOT_FRAME); if (iterSnap != dataProcesses_.end()) { DHLOGI("StopCapture %{public}s snapshot frame stop capture", GetAnonyString(dhId_).c_str()); + CHECK_AND_RETURN_RET_LOG(iterSnap->second == nullptr, DCAMERA_BAD_VALUE, "Snapshot is null"); int32_t ret = iterSnap->second->StopCapture(); if (ret != DCAMERA_OK) { DHLOGE("snapshot data process stop capture failed, dhId: %{public}s, ret: %{public}d", @@ -197,6 +203,7 @@ void DCameraSinkOutput::OnPhotoResult(std::shared_ptr& buffer) DHLOGE("OnPhotoResult %{public}s has no snapshot data process", GetAnonyString(dhId_).c_str()); return; } + CHECK_AND_RETURN_RET_LOG(dataProcesses_[SNAPSHOT_FRAME] == nullptr, DCAMERA_BAD_VALUE, "Snapshot is null"); dataProcesses_[SNAPSHOT_FRAME]->FeedStream(buffer); } diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_service_ipc.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_service_ipc.cpp index 7ad8a4de..11a415bd 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_service_ipc.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_service_ipc.cpp @@ -106,7 +106,9 @@ sptr DCameraSinkServiceIpc::GetSourceRemoteCamSrv(cons std::lock_guard autoLock(sourceRemoteCamSrvLock_); auto iter = remoteSources_.find(deviceId); if (iter != remoteSources_.end()) { - iter->second->AsObject()->RemoveDeathRecipient(sourceRemoteRecipient_); + if (iter->second != nullptr && iter->second->AsObject() != nullptr) { + iter->second->AsObject()->RemoveDeathRecipient(sourceRemoteRecipient_); + } } remoteSources_[deviceId] = remoteCamSrvObj; } diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_access_control_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_access_control_test.cpp index 0458e230..84e603fd 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_access_control_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_access_control_test.cpp @@ -65,6 +65,7 @@ void DCameraSinkAccessControlTest::TearDown(void) */ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_001, TestSize.Level1) { + EXPECT_EQ(accessControl_ == nullptr, false); bool ret = accessControl_->IsSensitiveSrcAccess(TEST_SRC_TYPE); EXPECT_EQ(true, ret); } @@ -77,6 +78,7 @@ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_001, Tes */ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_002, TestSize.Level1) { + EXPECT_EQ(accessControl_ == nullptr, false); bool ret = accessControl_->NotifySensitiveSrc(TEST_SRC_TYPE); EXPECT_EQ(true, ret); } @@ -89,6 +91,7 @@ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_002, Tes */ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_003, TestSize.Level1) { + EXPECT_EQ(accessControl_ == nullptr, false); int32_t ret = accessControl_->GetAccessControlType(TEST_ACCESS_TYPE); EXPECT_EQ(DCAMERA_SAME_ACCOUNT, ret); } @@ -101,6 +104,7 @@ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_003, Tes */ HWTEST_F(DCameraSinkAccessControlTest, dcamera_sink_access_control_test_004, TestSize.Level1) { + EXPECT_EQ(accessControl_ == nullptr, false); int32_t ret = accessControl_->TriggerFrame(TEST_DEVICE_NAME); EXPECT_EQ(DCAMERA_OK, ret); } diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp index a7b0d8e6..ebca672d 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp @@ -176,6 +176,7 @@ void DCameraSinkControllerTest::SetTokenID() */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_001, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); int32_t ret = controller_->Init(g_testCamIndex); EXPECT_EQ(DCAMERA_OK, ret); EXPECT_EQ(true, controller_->isInit_); @@ -193,6 +194,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_001, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_002, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraInfoCmd cmd; cmd.value_ = std::make_shared(); int32_t ret = controller_->GetCameraInfo(cmd.value_); @@ -208,6 +210,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_002, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_003, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraChannelInfoCmd cmd; cmd.Unmarshal(TEST_CHANNEL_INFO_CMD_CONTINUE_JSON); int32_t ret = controller_->ChannelNeg(cmd.value_); @@ -222,6 +225,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_003, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_004, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); int32_t ret = controller_->StartCapture(cmd.value_); @@ -236,6 +240,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_004, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); SetTokenID(); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); @@ -261,6 +266,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_006, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); int32_t ret = controller_->StartCapture(cmd.value_); @@ -278,6 +284,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_006, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_007, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); controller_->srcDevId_ = TEST_DEVICE_ID_EMPTY; DCameraEventCmd cmd; @@ -294,6 +301,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_007, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraEventCmd cmd; cmd.Unmarshal(TEST_EVENT_CMD_JSON); int32_t ret = controller_->DCameraNotify(cmd.value_); @@ -308,6 +316,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING); DCameraInfoCmd cmd; @@ -332,6 +341,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED); DCameraInfoCmd cmd; @@ -360,6 +370,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED); std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); @@ -378,6 +389,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); SetTokenID(); DCameraOpenInfoCmd cmd; cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON); @@ -393,6 +405,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED); DCameraInfoCmd cmd; @@ -415,6 +428,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); int32_t ret = controller_->CloseChannel(); EXPECT_EQ(DCAMERA_OK, ret); controller_->isPageStatus_.store(true); @@ -433,6 +447,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_015, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); SetTokenID(); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); @@ -454,6 +469,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_015, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_016, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); SetTokenID(); DCameraOpenInfoCmd cmd; cmd.Unmarshal(TEST_OPEN_INFO_CMD_JSON); @@ -470,6 +486,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_016, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_017, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_channelStr = "test017"; int32_t ret = controller_->CloseChannel(); EXPECT_EQ(DCAMERA_OK, ret); @@ -483,6 +500,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_017, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_018, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_outputStr = "test018"; int32_t ret = controller_->CloseChannel(); EXPECT_EQ(DCAMERA_OK, ret); @@ -496,6 +514,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_018, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_019, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_outputStr = "test019"; int32_t ret = controller_->UnInit(); EXPECT_EQ(DCAMERA_OK, ret); @@ -509,6 +528,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_019, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_020, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_operatorStr = "test020"; int32_t ret = controller_->UnInit(); EXPECT_EQ(DCAMERA_OK, ret); @@ -522,6 +542,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_020, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_021, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); g_outputStr = "test021"; @@ -537,6 +558,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_021, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_022, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); g_outputStr = ""; @@ -553,6 +575,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_022, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_023, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); DCameraCaptureInfoCmd cmd; cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON); g_operatorStr = "test023"; @@ -568,6 +591,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_023, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_024, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_operatorStr = "test024"; controller_->isSensitive_ = false; int32_t ret = controller_->PullUpPage(); @@ -582,6 +606,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_024, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_025, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); sptr sinkCallback(new DCameraSinkCallback()); EXPECT_NE(nullptr, sinkCallback); controller_->isSensitive_ = true; @@ -617,6 +642,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_025, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_026, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_outputStr = "test026"; auto outputMock = std::make_shared("camera_1", nullptr); EXPECT_NE(DCAMERA_OK, outputMock->Init()); @@ -633,6 +659,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_026, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_027, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); g_operatorStr ="test027"; EXPECT_EQ(DCAMERA_OK, controller_->UnInit()); } @@ -645,6 +672,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_027, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_028, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); size_t capacity = 1; std::shared_ptr dataBuffer = std::make_shared(capacity); EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->HandleReceivedData(dataBuffer)); @@ -658,6 +686,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_028, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_029, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string netId = ""; EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId)); netId = "netId"; @@ -677,6 +706,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_029, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_030, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string netId = ""; EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId)); netId = "netId"; @@ -696,6 +726,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_030, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_031, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string netId = ""; EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->StopDistributedHardware(netId)); netId = "netId"; @@ -710,6 +741,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_031, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_032, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string srcNetId = ""; std::string dstNetId = ""; EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); @@ -723,6 +755,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_032, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_033, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string udId = ""; EXPECT_NE(DCAMERA_OK, controller_->GetDeviceSecurityLevel(udId)); } @@ -735,6 +768,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_033, TestSize.L */ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_034, TestSize.Level1) { + EXPECT_EQ(controller_ == nullptr, false); std::string netId = ""; EXPECT_EQ("", controller_->GetUdidByNetworkId(netId)); netId = "netId"; diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_data_process_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_data_process_test.cpp index 8a765334..e270bc9b 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_data_process_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_data_process_test.cpp @@ -126,6 +126,7 @@ void DCameraSinkDataProcessTest::TearDown(void) */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_001, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); int32_t ret = dataProcess_->StartCapture(g_testCaptureInfoContinuousNotEncode); EXPECT_EQ(DCAMERA_OK, ret); } @@ -138,6 +139,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_001, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_002, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); int32_t ret = dataProcess_->StartCapture(g_testCaptureInfoContinuousNeedEncode); EXPECT_EQ(DCAMERA_OK, ret); } @@ -150,6 +152,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_002, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_003, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); int32_t ret = dataProcess_->StartCapture(g_testCaptureInfoSnapshot); EXPECT_EQ(DCAMERA_OK, ret); } @@ -162,6 +165,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_003, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_004, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); int32_t ret = dataProcess_->StopCapture(); EXPECT_EQ(DCAMERA_OK, ret); } @@ -174,6 +178,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_004, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_005, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); dataProcess_->captureInfo_ = g_testCaptureInfoContinuousNotEncode; int32_t ret = dataProcess_->FeedStream(g_testDataBuffer); std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); @@ -188,6 +193,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_005, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_006, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); dataProcess_->captureInfo_ = g_testCaptureInfoContinuousNeedEncode; int32_t ret = dataProcess_->FeedStream(g_testDataBuffer); std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); @@ -202,6 +208,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_006, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_007, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); dataProcess_->captureInfo_ = g_testCaptureInfoSnapshot; int32_t ret = dataProcess_->FeedStream(g_testDataBuffer); std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); @@ -216,6 +223,7 @@ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_007, TestSiz */ HWTEST_F(DCameraSinkDataProcessTest, dcamera_sink_data_process_test_008, TestSize.Level1) { + EXPECT_EQ(dataProcess_ == nullptr, false); EXPECT_EQ(VideoCodecType::CODEC_H264, dataProcess_->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H264)); EXPECT_EQ(VideoCodecType::CODEC_H265, dataProcess_->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_H265)); EXPECT_EQ(VideoCodecType::CODEC_MPEG4_ES, dataProcess_->GetPipelineCodecType(DCEncodeType::ENCODE_TYPE_MPEG4_ES)); diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_dev_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_dev_test.cpp index 9f77c44c..e90914fd 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_dev_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_dev_test.cpp @@ -102,6 +102,7 @@ void DCameraSinkDevTest::TearDown(void) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_001, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->Init(); EXPECT_EQ(DCAMERA_OK, ret); EXPECT_EQ(true, dev_->isInit_); @@ -129,6 +130,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_001, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_002, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->SubscribeLocalHardware(TEST_PARAMETER); EXPECT_EQ(DCAMERA_OK, ret); } @@ -141,6 +143,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_002, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_003, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->UnsubscribeLocalHardware(); EXPECT_EQ(DCAMERA_OK, ret); } @@ -153,6 +156,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_003, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_004, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->GetCameraInfo(g_testCameraInfo); EXPECT_EQ(DCAMERA_OK, ret); DHLOGI("DCameraSinkDevTest::GetCameraInfo cameraInfo is %{public}s", GetAnonyString(g_testCameraInfo).c_str()); @@ -170,6 +174,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_004, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_005, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->ChannelNeg(g_testChannelInfoDevEmpty); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); } @@ -182,6 +187,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_005, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_006, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->ChannelNeg(g_testChannelInfoDevContinue); EXPECT_EQ(DCAMERA_OK, ret); g_sinkCtrlStr = "test_006"; @@ -198,6 +204,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_006, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_007, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->StopCapture(); EXPECT_EQ(DCAMERA_OK, ret); } @@ -210,6 +217,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_007, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_008, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->OpenChannel(g_testOpenInfoDevEmpty); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); } @@ -222,6 +230,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_008, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_009, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->OpenChannel(g_testOpenInfoDev); EXPECT_EQ(DCAMERA_OK, ret); } @@ -234,6 +243,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_009, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_010, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); int32_t ret = dev_->CloseChannel(); EXPECT_EQ(DCAMERA_OK, ret); } @@ -246,6 +256,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_010, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_011, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); dev_->dhId_ = "1"; std::string ret = dev_->GetDhid(); EXPECT_NE("", ret); @@ -259,6 +270,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_011, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_012, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); std::string devId = ""; int32_t ret = dev_->PauseDistributedHardware(devId); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); @@ -280,6 +292,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_012, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_013, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); std::string devId = ""; int32_t ret = dev_->ResumeDistributedHardware(devId); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); @@ -301,6 +314,7 @@ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_013, TestSize.Level1) */ HWTEST_F(DCameraSinkDevTest, dcamera_sink_dev_test_014, TestSize.Level1) { + EXPECT_EQ(dev_ == nullptr, false); std::string devId = ""; int32_t ret = dev_->StopDistributedHardware(devId); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp index 0a5fe02f..5d003074 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp @@ -140,6 +140,7 @@ void DCameraSinkOutputTest::TearDown(void) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_001, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); int32_t ret = output_->Init(); EXPECT_EQ(DCAMERA_OK, ret); std::shared_ptr output = nullptr; @@ -162,6 +163,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_001, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_002, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); dataProcess_ = std::make_shared(channel_); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); @@ -183,6 +185,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_002, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_003, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); dataProcess_ = std::make_shared(channel_); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); @@ -204,6 +207,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_003, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_004, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); dataProcess_ = std::make_shared(channel_); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); @@ -225,6 +229,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_004, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_005, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); dataProcess_ = std::make_shared(channel_); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); @@ -249,6 +254,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_005, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_006, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); output_->channels_.emplace(CONTINUOUS_FRAME, channel_); @@ -264,6 +270,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_006, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_007, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); channel_ = std::make_shared(); output_->channels_.emplace(SNAPSHOT_FRAME, channel_); output_->channels_.emplace(CONTINUOUS_FRAME, channel_); @@ -279,6 +286,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_007, TestSize.Level1) */ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_008, TestSize.Level1) { + EXPECT_EQ(output_ == nullptr, false); std::string name = "name"; PropertyCarrier propertyCarrier; int32_t ret = output_->GetProperty(name, propertyCarrier); diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp index 4e0453ba..6f9fdd8f 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp @@ -66,6 +66,7 @@ void DCameraFrameTriggerEventTest::TearDown(void) */ HWTEST_F(DCameraFrameTriggerEventTest, dcamera_frame_trigger_event_test_001, TestSize.Level1) { + EXPECT_EQ(testDCameraFrameTriggerEvent_ == nullptr, false); std::string param = testDCameraFrameTriggerEvent_->GetParam(); EXPECT_EQ(param, TEST_PARAM); } diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp index 4777134f..cc1074a9 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp @@ -72,6 +72,7 @@ void DCameraPhotoOutputEventTest::TearDown(void) */ HWTEST_F(DCameraPhotoOutputEventTest, dcamera_photo_output_event_test_001, TestSize.Level1) { + EXPECT_EQ(testDCameraPhotoOutputEvent_ == nullptr, false); std::shared_ptr buffer = testDCameraPhotoOutputEvent_->GetParam(); EXPECT_EQ(buffer->Capacity(), TEST_CAPACITY); } -- Gitee