From 21713cd29a9e33e42c643c7f0eb81df89ab3938f Mon Sep 17 00:00:00 2001 From: Bobie Date: Mon, 6 May 2024 17:31:59 +0800 Subject: [PATCH 1/2] add ut of dcamera Signed-off-by: Bobie --- .../callback/dcamera_source_callback_test.cpp | 122 ++++++++++++++++++ .../dcamera_sink_output_test.cpp | 8 +- ...mera_stream_data_process_producer_test.cpp | 4 + 3 files changed, 133 insertions(+), 1 deletion(-) diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp index 6872dd32..98c1f4d0 100644 --- a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp @@ -27,6 +27,11 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { +namespace { +constexpr uint32_t DID_MAX_SIZE = 256; +constexpr uint32_t ERR_IPC_CODE = 99999; +constexpr uint32_t PARAM_MAX_SIZE = 50 * 1024 * 1024; +} class DCameraSourceCallbackTest : public testing::Test { public: static void SetUpTestCase(void); @@ -157,5 +162,122 @@ HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_004, TestSize.L EXPECT_EQ(DCAMERA_NOT_FOUND, ret); } +/** + * @tc.name: dcamera_source_callback_test_005 + * @tc.desc: Verify the CheckParams function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_005, TestSize.Level1) +{ + std::string devId = ""; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + std::string result = "result"; + int32_t ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + devId += std::string(DID_MAX_SIZE + 1, 'a'); + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + devId = "devId"; + dhId = ""; + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + dhId += std::string(DID_MAX_SIZE + 1, 'a'); + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + dhId = "dhId"; + reqId = ""; + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + reqId += std::string(DID_MAX_SIZE + 1, 'a'); + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); + reqId ="reqId"; + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(true, ret); + result = std::string(PARAM_MAX_SIZE + 1, 'a'); + ret = sourceCallback_->CheckParams(devId, dhId, reqId, result); + EXPECT_EQ(false, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_006 + * @tc.desc: Verify the OnRemoteRequest function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_006, TestSize.Level1) +{ + uint32_t code = ERR_IPC_CODE; + MessageParcel data; + MessageParcel reply; + MessageOption option; + std::string descriptor = "desc"; + EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + data.WriteString(devId); + data.WriteString(dhId); + data.WriteString(reqId); + int32_t ret = sourceCallback_->OnRemoteRequest(code, data, reply, option); + EXPECT_NE(DCAMERA_OK, ret); + code = DCameraSourceCallback::NOTIFY_REG_RESULT; + ret = sourceCallback_->OnRemoteRequest(code, data, reply, option); + EXPECT_NE(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_007 + * @tc.desc: Verify the NotifyRegResultInner function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_007, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + std::string descriptor = "desc"; + EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t status = 1; + std::string result = "success"; + data.WriteString(devId); + data.WriteString(dhId); + data.WriteString(reqId); + data.WriteInt32(status); + data.WriteString(result); + int32_t ret = sourceCallback_->NotifyRegResultInner(data, reply); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_008 + * @tc.desc: Verify the NotifyUnregResultInner function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_008, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + std::string descriptor = "desc"; + EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t status = 1; + std::string result = "success"; + data.WriteString(devId); + data.WriteString(dhId); + data.WriteString(reqId); + data.WriteInt32(status); + data.WriteString(result); + int32_t ret = sourceCallback_->NotifyUnregResultInner(data, reply); + EXPECT_EQ(DCAMERA_OK, ret); +} } } \ No newline at end of file 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 db34b2b9..84e0f360 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 @@ -28,6 +28,7 @@ #include "dcamera_sink_controller.h" #include "dcamera_sink_data_process.h" #include "dcamera_sink_dev.h" +#include "dcamera_sink_output_result_callback.h" #include "dcamera_utils_tools.h" #include "distributed_camera_errno.h" @@ -141,10 +142,15 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_001, TestSize.Level1) { int32_t ret = output_->Init(); EXPECT_EQ(DCAMERA_OK, ret); + std::shared_ptr output = nullptr; + auto callback = std::make_shared(output); + auto dataBuffer = std::make_shared(1); + callback->OnPhotoResult(dataBuffer); + callback->OnVideoResult(dataBuffer); EXPECT_EQ(true, output_->isInit_); usleep(TEST_TWENTY_MS); ret = output_->UnInit(); - EXPECT_EQ(DCAMERA_OK, ret); + EXPECT_EQ(DCAMERA_OK, ret); EXPECT_EQ(false, output_->isInit_); } diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp index 55175850..8c3ed636 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp @@ -94,6 +94,10 @@ HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_produ EXPECT_EQ(DCAMERA_BAD_VALUE, ret); ret = streamProcess2->FeedStreamToDriver(dhBase, buffer); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + streamProcess1 = nullptr; + auto listener = std::make_shared(streamProcess1); + buffer = nullptr; + EXPECT_EQ(NOTIFY_FAILED, listener->OnSmoothFinished(buffer)); } /** -- Gitee From c2ff19f5f21c970f48a32e37b6085b1bf7a0c29e Mon Sep 17 00:00:00 2001 From: Bobie Date: Thu, 9 May 2024 16:11:38 +0800 Subject: [PATCH 2/2] add ut cases of sink controller. Signed-off-by: Bobie --- .../callback/dcamera_source_callback_test.cpp | 6 +- .../handler/src/dcamera_handler.cpp | 4 +- .../dcamera_sink_controller_test.cpp | 213 ++++++++++++++++++ .../dcamera_sink_output_test.cpp | 2 +- .../mock_camera_channel.h | 3 + .../mock_camera_operator.h | 12 + .../mock_dcamera_sink_output.h | 8 +- 7 files changed, 241 insertions(+), 7 deletions(-) diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp index 98c1f4d0..d6e073a4 100644 --- a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp @@ -214,7 +214,7 @@ HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_006, TestSize.L MessageParcel reply; MessageOption option; std::string descriptor = "desc"; - EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + EXPECT_EQ(true, data.WriteInterfaceToken(to_utf16(descriptor))); std::string devId = "devId"; std::string dhId = "dhId"; std::string reqId = "reqId"; @@ -239,7 +239,7 @@ HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_007, TestSize.L MessageParcel data; MessageParcel reply; std::string descriptor = "desc"; - EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + EXPECT_EQ(true, data.WriteInterfaceToken(to_utf16(descriptor))); std::string devId = "devId"; std::string dhId = "dhId"; std::string reqId = "reqId"; @@ -265,7 +265,7 @@ HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_008, TestSize.L MessageParcel data; MessageParcel reply; std::string descriptor = "desc"; - EXPECT_EQ(true, data.WriteInterfaceToken(std::utf16(descriptor))); + EXPECT_EQ(true, data.WriteInterfaceToken(to_utf16(descriptor))); std::string devId = "devId"; std::string dhId = "dhId"; std::string reqId = "reqId"; diff --git a/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp b/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp index aec4b6b6..4947a375 100644 --- a/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp +++ b/services/cameraservice/cameraoperator/handler/src/dcamera_handler.cpp @@ -168,7 +168,7 @@ int32_t DCameraHandler::CreateAVCodecList(cJSON *root) } std::string mimeType = capData->mimeType; cJSON_AddItemToArray(array, cJSON_CreateString(mimeType.c_str())); - DHLOGI("codec name: %s, mimeType: %s", coder.c_str(), mimeType.c_str()); + DHLOGI("codec name: %{public}s, mimeType: %{public}s", coder.c_str(), mimeType.c_str()); } return DCAMERA_OK; } @@ -270,7 +270,7 @@ void DCameraHandler::ProcessProfile(const DCStreamType type, std::map& profileList) { - DHLOGI("type: %d, size: %{public}zu", type, profileList.size()); + DHLOGI("type: %{public}d, size: %{public}zu", type, profileList.size()); std::set formatSet; cJSON* formatphotoObj = cJSON_CreateObject(); if (formatphotoObj == nullptr) { 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 672d6484..4840844c 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 @@ -45,6 +45,10 @@ namespace DistributedHardware { std::string g_channelStr = ""; std::string g_outputStr = ""; std::string g_operatorStr = ""; + +namespace { +const int DEFAULT_DEVICE_SECURITY_LEVEL = -1; +} class DCameraSinkControllerTest : public testing::Test { public: static void SetUpTestCase(void); @@ -245,6 +249,10 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_005, TestSize.L cmdMetadata.Unmarshal(TEST_METADATA_SETTING_CMD_JSON); ret = controller_->UpdateSettings(cmdMetadata.value_); controller_->OnMetadataResult(cmdMetadata.value_); + g_channelStr = "test005"; + controller_->OnMetadataResult(cmdMetadata.value_); + std::vector> settings; + controller_->OnMetadataResult(settings); EXPECT_EQ(DCAMERA_WRONG_STATE, ret); } @@ -309,6 +317,13 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.L cmd.value_ = std::make_shared(); int32_t ret = controller_->GetCameraInfo(cmd.value_); EXPECT_EQ(DCAMERA_OK, ret); + int32_t state = -1; + controller_->OnSessionState(state); + + int32_t eventType = 1; + int32_t eventReason = 0; + std::string detail = "detail"; + controller_->OnSessionError(eventType, eventReason, detail); EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTING, cmd.value_->state_); } @@ -326,6 +341,17 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.L cmd.value_ = std::make_shared(); int32_t ret = controller_->GetCameraInfo(cmd.value_); EXPECT_EQ(DCAMERA_OK, ret); + size_t capacity = 1; + std::vector> buffers; + controller_->OnDataReceived(buffers); + std::shared_ptr dataBuffer = std::make_shared(capacity); + buffers.push_back(dataBuffer); + controller_->OnDataReceived(buffers); + buffers.clear(); + capacity = controller_->DATABUFF_MAX_SIZE + 1; + dataBuffer = std::make_shared(capacity); + buffers.push_back(dataBuffer); + controller_->OnDataReceived(buffers); EXPECT_EQ(DCAMERA_CHANNEL_STATE_CONNECTED, cmd.value_->state_); } @@ -394,6 +420,12 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_014, TestSize.L { int32_t ret = controller_->CloseChannel(); EXPECT_EQ(DCAMERA_OK, ret); + controller_->isPageStatus_.store(true); + sptr sinkCallback(new DCameraSinkCallback()); + EXPECT_EQ(true, controller_->isPageStatus_.load()); + controller_->sinkCallback_ = sinkCallback; + ret = controller_->CloseChannel(); + EXPECT_EQ(DCAMERA_OK, ret); } /** @@ -530,5 +562,186 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_023, TestSize.L int32_t ret = controller_->StartCapture(cmd.value_); EXPECT_EQ(DCAMERA_DEVICE_BUSY, ret); } + +/** + * @tc.name: dcamera_sink_controller_test_024 + * @tc.desc: Verify the PullUpPage function. + * @tc.type: FUNC + * @tc.require: AR000GK6MU + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_024, TestSize.Level1) +{ + g_operatorStr = "test024"; + controller_->isSensitive_ = false; + int32_t ret = controller_->PullUpPage(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_sink_controller_test_025 + * @tc.desc: Verify the PullUpPage function. + * @tc.type: FUNC + * @tc.require: AR000GK6MU + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_025, TestSize.Level1) +{ + sptr sinkCallback(new DCameraSinkCallback()); + EXPECT_NE(nullptr, sinkCallback); + controller_->isSensitive_ = true; + controller_->sinkCallback_ = sinkCallback; + int32_t ret = controller_->PullUpPage(); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = controller_->Init(g_testCamIndex); + EXPECT_EQ(DCAMERA_OK, ret); + EXPECT_NE(nullptr, controller_->sinkCotrEventHandler_); + std::shared_ptr param = std::make_shared(""); + AppExecFwk::InnerEvent::Pointer event = + AppExecFwk::InnerEvent::Get(EVENT_FRAME_TRIGGER, param, 0); + controller_->sinkCotrEventHandler_->ProcessEvent(event); + std::shared_ptr>> infos = + std::make_shared>>(); + AppExecFwk::InnerEvent::Pointer authorizationEvent = + AppExecFwk::InnerEvent::Get(EVENT_AUTHORIZATION, infos, 0); + controller_->PostAuthorization(*infos); + g_outputStr = "test_025"; + controller_->PostAuthorization(*infos); + g_outputStr = ""; + controller_->sinkCotrEventHandler_->ProcessEvent(authorizationEvent); + event = AppExecFwk::InnerEvent::Get(0, param, 0); + controller_->sinkCotrEventHandler_->ProcessEvent(event); +} + +/** + * @tc.name: dcamera_sink_controller_test_026 + * @tc.desc: Verify the Init and UnInit function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_026, TestSize.Level1) +{ + g_outputStr = "test026"; + auto outputMock = std::make_shared("camera_1", nullptr); + EXPECT_NE(DCAMERA_OK, outputMock->Init()); + controller_->output_ = outputMock; + int32_t ret = controller_->Init(g_testCamIndex); + EXPECT_NE(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_controller_test_027 + * @tc.desc: Verify the Init and UnInit function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_027, TestSize.Level1) +{ + g_operatorStr ="test027"; + EXPECT_EQ(DCAMERA_OK, controller_->UnInit()); +} + +/** + * @tc.name: dcamera_sink_controller_test_028 + * @tc.desc: Verify HandleReceivedData function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_028, TestSize.Level1) +{ + size_t capacity = 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->HandleReceivedData(dataBuffer)); +} + +/** + * @tc.name: dcamera_sink_controller_test_029 + * @tc.desc: Verify PauseDistributedHardware function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_029, TestSize.Level1) +{ + std::string netId = ""; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId)); + netId = "netId"; + EXPECT_EQ(DCAMERA_OK, controller_->PauseDistributedHardware(netId)); + g_operatorStr = "test029"; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId)); + g_operatorStr = ""; + controller_->operator_ = nullptr; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->PauseDistributedHardware(netId)); +} + +/** + * @tc.name: dcamera_sink_controller_test_030 + * @tc.desc: Verify ResumeDistributedHardware function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_030, TestSize.Level1) +{ + std::string netId = ""; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId)); + netId = "netId"; + EXPECT_EQ(DCAMERA_OK, controller_->ResumeDistributedHardware(netId)); + g_operatorStr = "test030"; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId)); + g_operatorStr = ""; + controller_->operator_ = nullptr; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->ResumeDistributedHardware(netId)); +} + +/** + * @tc.name: dcamera_sink_controller_test_031 + * @tc.desc: Verify StopDistributedHardware function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_031, TestSize.Level1) +{ + std::string netId = ""; + EXPECT_EQ(DCAMERA_BAD_VALUE, controller_->StopDistributedHardware(netId)); + netId = "netId"; + EXPECT_NE(DCAMERA_OK, controller_->StopDistributedHardware(netId)); +} + +/** + * @tc.name: dcamera_sink_controller_test_032 + * @tc.desc: Verify CheckDeviceSecurityLevel function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_032, TestSize.Level1) +{ + std::string srcNetId = ""; + std::string dstNetId = ""; + EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); +} + +/** + * @tc.name: dcamera_sink_controller_test_033 + * @tc.desc: Verify GetDeviceSecurityLevel function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_033, TestSize.Level1) +{ + std::string udId = ""; + EXPECT_EQ(DEFAULT_DEVICE_SECURITY_LEVEL, controller_->GetDeviceSecurityLevel(udId)); +} + +/** + * @tc.name: dcamera_sink_controller_test_034 + * @tc.desc: Verify GetUdidByNetworkId function. + * @tc.type: FUNC + * @tc.require: AR000GK6MV + */ +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_034, TestSize.Level1) +{ + std::string netId = ""; + EXPECT_EQ("", controller_->GetUdidByNetworkId(netId)); + netId = "netId"; + EXPECT_EQ("", controller_->GetUdidByNetworkId(netId)); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file 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 84e0f360..bd7caa57 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 @@ -150,7 +150,7 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_001, TestSize.Level1) EXPECT_EQ(true, output_->isInit_); usleep(TEST_TWENTY_MS); ret = output_->UnInit(); - EXPECT_EQ(DCAMERA_OK, ret); + EXPECT_EQ(DCAMERA_OK, ret); EXPECT_EQ(false, output_->isInit_); } diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_channel.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_channel.h index d85e77be..9afd76b9 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_channel.h +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_channel.h @@ -61,6 +61,9 @@ public: int32_t SendData(std::shared_ptr& buffer) { + if (g_channelStr == "test005") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } }; diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h index 5f385751..0e564fed 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h @@ -34,6 +34,9 @@ public: int32_t Init() { + if (g_operatorStr == "test026") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } @@ -76,6 +79,9 @@ public: int32_t StopCapture() { + if (g_operatorStr == "test027") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } @@ -91,11 +97,17 @@ public: int32_t PauseCapture() { + if (g_operatorStr == "test029") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } int32_t ResumeCapture() { + if (g_operatorStr == "test030") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } }; diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_output.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_output.h index b4ea4a44..d8d8dc36 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_output.h +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_dcamera_sink_output.h @@ -35,6 +35,9 @@ public: int32_t Init() { + if (g_outputStr == "test026") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } int32_t UnInit() @@ -46,7 +49,7 @@ public: } int32_t StartCapture(std::vector>& captureInfos) { - if (g_outputStr == "test021") { + if (g_outputStr == "test021" || g_outputStr == "test_025") { return DCAMERA_BAD_VALUE; } return DCAMERA_OK; @@ -68,6 +71,9 @@ public: } int32_t GetProperty(const std::string& propertyName, PropertyCarrier& propertyCarrier) { + if (g_outputStr == "test_025") { + return DCAMERA_BAD_VALUE; + } return DCAMERA_OK; } }; -- Gitee