diff --git a/common/test/unittest/src/screen_common_test.cpp b/common/test/unittest/src/screen_common_test.cpp index 148274b5f181a0c3ab0adfb9fb6686747c2326ae..d8123eab4796135f2a73ce72e8f635dcfff2df28 100644 --- a/common/test/unittest/src/screen_common_test.cpp +++ b/common/test/unittest/src/screen_common_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -19,8 +19,12 @@ #include "dscreen_json_util.h" #include "dscreen_log.h" #include "dscreen_util.h" +#include "parameter.h" +#include "softbus_bus_center.h" using namespace testing::ext; +static int g_mockGetLocalNodeDeviceInfoReturnInt32Value = -1; +static int g_mockGetParameterReturnIntValue = -1; namespace OHOS { namespace DistributedHardware { @@ -42,6 +46,7 @@ HWTEST_F(ScreenCommonTest, common_001, TestSize.Level1) { DHLOGW("common_001."); std::string networkId = "networkId"; + g_mockGetLocalNodeDeviceInfoReturnInt32Value = -1; int32_t ret = GetLocalDeviceNetworkId(networkId); EXPECT_NE(DH_SUCCESS, ret); } @@ -55,6 +60,21 @@ HWTEST_F(ScreenCommonTest, common_001, TestSize.Level1) HWTEST_F(ScreenCommonTest, common_002, TestSize.Level1) { DHLOGW("common_002."); + std::string networkId = "networkId"; + g_mockGetLocalNodeDeviceInfoReturnInt32Value = DH_SUCCESS; + int32_t ret = GetLocalDeviceNetworkId(networkId); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: common_003 + * @tc.desc: Verify the common function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenCommonTest, common_003, TestSize.Level1) +{ + DHLOGW("common_003."); ReportSaFail(eventName, errCode, saId, errMsg); ReportSaFail(eventName, errCode, saId, errMsg); ReportRegisterFail(eventName, errCode, devId, dhId, errMsg); @@ -79,28 +99,28 @@ HWTEST_F(ScreenCommonTest, common_002, TestSize.Level1) } /** - * @tc.name: common_003 + * @tc.name: common_004 * @tc.desc: Verify the common function. * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(ScreenCommonTest, common_003, TestSize.Level1) +HWTEST_F(ScreenCommonTest, common_004, TestSize.Level1) { - DHLOGW("common_003."); + DHLOGW("common_004."); std::string value = "Id"; std::string ret = GetInterruptString(value); EXPECT_EQ(value, ret); } /** - * @tc.name: common_004 + * @tc.name: common_005 * @tc.desc: Verify the common function. * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(ScreenCommonTest, common_004, TestSize.Level1) +HWTEST_F(ScreenCommonTest, common_005, TestSize.Level1) { - DHLOGW("common_004."); + DHLOGW("common_005."); std::string value = "Idvalues"; std::string ret = GetInterruptString(value); EXPECT_EQ("Idva", ret); @@ -143,5 +163,49 @@ HWTEST_F(ScreenCommonTest, IsArray_001, TestSize.Level1) testJson[key] = {1, 2, 3}; EXPECT_TRUE(IsArray(testJson, key)); } + +/** + * @tc.name: IsPartialRefreshEnabled_001 + * @tc.desc: Verify the IsPartialRefreshEnabled function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenCommonTest, IsPartialRefreshEnabled_001, TestSize.Level1) +{ + g_mockGetParameterReturnIntValue = 1; + EXPECT_FALSE(IsPartialRefreshEnabled()); + g_mockGetParameterReturnIntValue = -1; + EXPECT_FALSE(IsPartialRefreshEnabled()); +} + +/** + * @tc.name: IsSupportAVTransEngine_001 + * @tc.desc: Verify the IsSupportAVTransEngine function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenCommonTest, IsSupportAVTransEngine_001, TestSize.Level1) +{ + std::string version = "2"; + EXPECT_FALSE(IsSupportAVTransEngine(version)); + + version = "3"; + g_mockGetParameterReturnIntValue = 1; + EXPECT_TRUE(IsSupportAVTransEngine(version)); + + g_mockGetParameterReturnIntValue = -1; + EXPECT_TRUE(IsSupportAVTransEngine(version)); +} } // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file +} // namespace OHOS + +extern "C" __attribute__((constructor)) int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info) +{ + return g_mockGetLocalNodeDeviceInfoReturnInt32Value; +} + +extern "C" __attribute__((constructor)) int GetParameter(const char *key, const char *def, + char *value, unsigned int len) +{ + return g_mockGetParameterReturnIntValue; +} diff --git a/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp b/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp index b3f5f4ddd87185053395f91b4b47b9b5e74fb4a3..468eb24bc419d43454e03ecefd65fb7e9b5554bc 100644 --- a/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp +++ b/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -381,6 +381,7 @@ HWTEST_F(DScreenSourceHandlerTest, OnRemoteSourceSvrDied_001, TestSize.Level1) wptr remote(remoteObject); DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote); EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_); + DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote); } } // namespace DistributedHardware } // namespace OHOS diff --git a/services/common/test/unittest/decision_center/screen_decision_center_test.cpp b/services/common/test/unittest/decision_center/screen_decision_center_test.cpp index 8fb13cf716033d5ee04daafe1ed391fd5532d22e..865d1dc4f0f9608fb6caf71291a12ed4c82238cd 100644 --- a/services/common/test/unittest/decision_center/screen_decision_center_test.cpp +++ b/services/common/test/unittest/decision_center/screen_decision_center_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -118,7 +118,7 @@ HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_003, TestSize.Level1) std::vector damages; decision->configParam_.SetScreenWidth(1); decision->configParam_.SetScreenHeight(1); - OHOS::Rect damage = {0, 0, -1, 0}; + OHOS::Rect damage = {0, 0, 1, 0}; damages.push_back(damage); int32_t ret = decision->IsDirtyRectValid(damages); EXPECT_EQ(false, ret); @@ -129,6 +129,12 @@ HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_003, TestSize.Level1) ret = decision->IsDirtyRectValid(damages); EXPECT_EQ(false, ret); + damages.clear(); + damage = {0, 0, -2, 0}; + damages.push_back(damage); + ret = decision->IsDirtyRectValid(damages); + EXPECT_EQ(false, ret); + damages.clear(); damage = {0, 0, 0, -1}; damages.push_back(damage); @@ -149,7 +155,7 @@ HWTEST_F(ScreenDecisionCenterTest, IsDirtyRectValid_003, TestSize.Level1) } /** - * @tc.name: IsDirtyRectValid_005 + * @tc.name: IsDirtyRectValid_004 * @tc.desc: Verify the IsDirtyRectValid function. * @tc.type: FUNC * @tc.require: Issue Number diff --git a/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp b/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp index f1ee93abdc28c25e0b9bb1ccc4ff6adcee1ca68f..c52ba820eddaee7631c39e7d2709890daaad37ae 100644 --- a/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp +++ b/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -131,21 +131,30 @@ HWTEST_F(ScreenImageJpegTest, DecodeDamageData_001, TestSize.Level1) int32_t ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + dataBuffer->dirtyRectVec_.clear(); dataBuffer->AddDirtyRect(rect); jpeg_->configParam_.SetScreenWidth(rect.xPos); - jpeg_->configParam_.SetScreenHeight(rect.xPos - 1); + jpeg_->configParam_.SetScreenHeight(rect.yPos - 1); ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + dataBuffer->dirtyRectVec_.clear(); dataBuffer->AddDirtyRect(rect); - jpeg_->configParam_.SetScreenHeight(rect.xPos); + jpeg_->configParam_.SetScreenHeight(rect.yPos); ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + dataBuffer->dirtyRectVec_.clear(); rect.width = 0; dataBuffer->AddDirtyRect(rect); ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + dataBuffer->dirtyRectVec_.clear(); + rect.height = 0; + dataBuffer->AddDirtyRect(rect); + ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); } /** diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp index d6374ba7ca97fe23838e24195a4db72d53569eb2..1f9196e457b9f16bab951a1a406a03bd547f743e 100644 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -226,6 +226,9 @@ HWTEST_F(DScreenSinkStubTest, DScreenNotify_001, TestSize.Level1) std::string devId = "devId000"; int32_t eventCode = 0; + std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a'); + sinkProxy.DScreenNotify(devId, eventCode, exceedParamMaxSizeStr); + std::string eventContent = "eventContent000"; sinkProxy.DScreenNotify(devId, eventCode, eventContent); EXPECT_STREQ(devId.c_str(), ((sptr &)sinkStubPtr)->devId_.c_str()); diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn index 5dbaa8c98cf51bff8836dc53d42c3e25b7927f30..bd9017d13911bc7af0c7fab244ad84d545e8833a 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2024 Huawei Device Co., Ltd. +# Copyright (c) 2022-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -22,11 +22,16 @@ config("module_private_config") { include_dirs = [ "./include", "./include/callback", + "${common_path}/include", + "${distributedscreen_path}/interfaces/innerkits/native_cpp/screen_sink/include", + "${distributedscreen_path}/interfaces/innerkits/native_cpp/screen_source/include", "${interfaces_path}/innerkits/native_cpp/screen_source/include", "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", - "${common_path}/include", + "${services_path}/common/utils/include", + "${services_path}/screenservice/sourceservice/dscreenmgr", "${services_path}/screenservice/sourceservice/dscreenservice/include", "${services_path}/screenservice/sourceservice/dscreenservice/include/callback", + "${services_path}/screentransport/screensourcetrans/include", ] } @@ -41,6 +46,7 @@ ohos_unittest("DScreenSourceStubTest") { sources = [ "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp", ] @@ -50,17 +56,28 @@ ohos_unittest("DScreenSourceStubTest") { ] deps = [ + "${common_path}:distributed_screen_utils", + "${interfaces_path}/innerkits/native_cpp/screen_sink:distributed_screen_sink_sdk", "${interfaces_path}/innerkits/native_cpp/screen_source:distributed_screen_source_sdk", "${services_path}/screenservice/sourceservice:distributed_screen_source", + "${services_path}/screentransport/screensourcetrans:distributed_screen_sourcetrans", ] external_deps = [ "access_token:libaccesstoken_sdk", + "cJSON:cjson", "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", "distributed_hardware_fwk:distributedhardwareutils", + "distributed_hardware_fwk:libdhfwk_sdk", "googletest:gmock", "googletest:gtest_main", + "graphic_2d:librender_service_client", + "graphic_surface:surface", + "hilog:libhilog", "ipc:ipc_core", + "json:nlohmann_json_static", "samgr:samgr_proxy", + "window_manager:libdm", ] } diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h new file mode 100644 index 0000000000000000000000000000000000000000..88b44d52aba51f4b2ba224c772f092cda803bee5 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DSCREEN_SOURCE_SERVICE_TEST_H +#define OHOS_DSCREEN_SOURCE_SERVICE_TEST_H + +#include +#include + +#include "dscreen_errcode.h" +#include "dscreen_source_callback_proxy.h" +#include "dscreen_source_callback.h" +#include "dscreen_source_proxy.h" +#include "dscreen_source_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenSourceServiceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp index 17080292f0251abb384a58be943a48cafb0ec308..b4324de338af54272c09866c1f1eb3f89ad92079 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -141,5 +141,26 @@ HWTEST_F(DScreenSourceCallbackStubTest, OnNotifyUnregResult_001, TestSize.Level1 ret = sourceCbkProxy.OnNotifyUnregResult("devId000", "dhId000", "reqId000", 0, exceedParamMaxSizeStr); EXPECT_NE(DH_SUCCESS, ret); } + +/** + * @tc.name: OnRemoteRequest_001 + * @tc.desc: Invoke the OnRemoteRequest ipc interface. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceCallbackStubTest, OnRemoteRequest_001, TestSize.Level1) +{ + std::shared_ptr callback = std::make_shared(); + std::u16string descriptor = DScreenSourceCallbackStub::GetDescriptor(); + std::u16string requestDescriptor = descriptor; + uint32_t requestCode = 999; + MessageParcel data; + data.WriteInterfaceToken(requestDescriptor); + data.WriteUint32(requestCode); + MessageParcel reply; + MessageOption option; + int32_t result = callback->OnRemoteRequest(requestCode, data, reply, option); + EXPECT_NE(0, result); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c85fadb2b2681ab1631aaf2eaa24e77820839cf3 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp @@ -0,0 +1,291 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "dscreen_source_service_test.h" +#include "1.0/include/dscreen_manager.h" +#include "2.0/include/dscreen_manager.h" +#include "accesstoken_kit.h" +#include "dscreen_constants.h" +#include "dscreen_source_callback.h" +#include "dscreen_source_service.h" +#include "idscreen_source.h" +#include "system_ability.h" + +using namespace testing; +using namespace testing::ext; + +static int32_t g_mockEnableDistributedScreenReturnInt32Value = -1; +static int32_t g_mockUnregisterDistributedHardwareV1ReturnInt32Value = -1; +static int32_t g_mockUnregisterDistributedHardwareV2ReturnInt32Value = -1; +static int32_t g_mockUnInitV1ReturnInt32Value = -1; +static int32_t g_mockReleaseV2ReturnInt32Value = -1; +static int32_t g_mockInitV1ReturnInt32Value = -1; +static int32_t g_mockInitializeV2ReturnInt32Value = -1; + +namespace OHOS { +namespace DistributedHardware { +int32_t V1_0::DScreenManager::EnableDistributedScreen(const std::string &devId, const std::string &dhId, + const EnableParam ¶m, const std::string &reqId) +{ + return g_mockEnableDistributedScreenReturnInt32Value; +} + +int32_t V2_0::DScreenManager::EnableDistributedScreen(const std::string &devId, const std::string &dhId, + const EnableParam ¶m, const std::string &reqId) +{ + return g_mockEnableDistributedScreenReturnInt32Value; +} + +int32_t V1_0::DScreenManager::DScreenManager::DisableDistributedScreen(const std::string &devId, + const std::string &dhId, const std::string &reqId) +{ + return g_mockUnregisterDistributedHardwareV1ReturnInt32Value; +} + +int32_t V2_0::DScreenManager::DScreenManager::DisableDistributedScreen(const std::string &devId, + const std::string &dhId, const std::string &reqId) +{ + return g_mockUnregisterDistributedHardwareV2ReturnInt32Value; +} + +int32_t V1_0::DScreenManager::DScreenManager::Init() +{ + return g_mockInitV1ReturnInt32Value; +} + +int32_t V2_0::DScreenManager::DScreenManager::Initialize() +{ + return g_mockInitializeV2ReturnInt32Value; +} + +int32_t V1_0::DScreenManager::DScreenManager::UnInit() +{ + return g_mockUnInitV1ReturnInt32Value; +} + +int32_t V2_0::DScreenManager::DScreenManager::Release() +{ + return g_mockReleaseV2ReturnInt32Value; +} + +void V1_0::DScreenManager::RegisterDScreenCallback(const sptr &callback) {} + +void V2_0::DScreenManager::RegisterDScreenCallback(const sptr &callback) {} + +void DScreenSourceServiceTest::SetUpTestCase(void) {} + +void DScreenSourceServiceTest::TearDownTestCase(void) {} + +void DScreenSourceServiceTest::SetUp(void) +{ + g_mockEnableDistributedScreenReturnInt32Value = -1; + g_mockUnregisterDistributedHardwareV1ReturnInt32Value = -1; + g_mockUnregisterDistributedHardwareV2ReturnInt32Value = -1; + g_mockUnInitV1ReturnInt32Value = -1; + g_mockReleaseV2ReturnInt32Value = -1; + g_mockInitV1ReturnInt32Value = -1; + g_mockInitializeV2ReturnInt32Value = -1; +} + +void DScreenSourceServiceTest::TearDown(void) {} + +/* * + * @tc.name: OnStart_001 + * @tc.desc: Verify the OnStart function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, OnStart_001, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + sourceService->registerToService_ = true; + sourceService->OnStart(); + sourceService->OnStop(); + EXPECT_FALSE(sourceService->registerToService_); +} + +/* * + * @tc.name: OnStop_001 + * @tc.desc: Verify the OnStop function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, OnStop_001, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + sourceService->registerToService_ = true; + g_mockReleaseV2ReturnInt32Value = 0; + g_mockUnInitV1ReturnInt32Value = 0; + sourceService->OnStop(); + EXPECT_FALSE(sourceService->registerToService_); +} + +/* * + * @tc.name: InitSource_001 + * @tc.desc: Verify the InitSource function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, InitSource_001, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + sptr callback = nullptr; + std::string params; + int32_t ret = sourceService->InitSource(params, callback); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL); + sourceService->ReleaseSource(); +} + +/* * + * @tc.name: InitSource_002 + * @tc.desc: Verify the InitSource function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, InitSource_002, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string params; + g_mockReleaseV2ReturnInt32Value = 0; + g_mockUnInitV1ReturnInt32Value = 0; + sptr callback(new DScreenSourceCallback()); + int32_t ret = sourceService->InitSource(params, callback); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL); + sourceService->ReleaseSource(); +} + +/* * + * @tc.name: InitSource_003 + * @tc.desc: Verify the InitSource function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, InitSource_003, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string params; + g_mockInitializeV2ReturnInt32Value = 0; + g_mockInitV1ReturnInt32Value = -1; + sptr callback(new DScreenSourceCallback()); + int32_t ret = sourceService->InitSource(params, callback); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL); + + g_mockInitV1ReturnInt32Value = 0; + ret = sourceService->InitSource(params, callback); + EXPECT_EQ(ret, DH_SUCCESS); + sourceService->ReleaseSource(); +} + +/* * + * @tc.name: RegisterDistributedHardware_001 + * @tc.desc: Verify the RegisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, RegisterDistributedHardware_001, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + g_mockEnableDistributedScreenReturnInt32Value = DH_SUCCESS; + std::string devId; + std::string dhId; + EnableParam param = { "", "", "1.0", "attrs000" }; + std::string reqId; + int32_t ret = sourceService->RegisterDistributedHardware(devId, dhId, param, reqId); + EXPECT_EQ(ret, DH_SUCCESS); +} + +/* * + * @tc.name: RegisterDistributedHardware_002 + * @tc.desc: Verify the RegisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, RegisterDistributedHardware_002, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string devId; + std::string dhId; + EnableParam param = { "", "", "3.0", "attrs000" }; + std::string reqId; + int32_t ret = sourceService->RegisterDistributedHardware(devId, dhId, param, reqId); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_ENABLE_FAILED); +} + +/* * + * @tc.name: UnregisterDistributedHardware_001 + * @tc.desc: Verify the UnregisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, UnregisterDistributedHardware_001, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string devId; + std::string dhId; + std::string reqId; + g_mockUnregisterDistributedHardwareV1ReturnInt32Value = -1; + int32_t ret = sourceService->UnregisterDistributedHardware(devId, dhId, reqId); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_DISABLE_FAILED); +} + +/* * + * @tc.name: UnregisterDistributedHardware_002 + * @tc.desc: Verify the UnregisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, UnregisterDistributedHardware_002, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string devId; + std::string dhId; + std::string reqId; + g_mockUnregisterDistributedHardwareV1ReturnInt32Value = 0; + g_mockUnregisterDistributedHardwareV2ReturnInt32Value = -1; + int32_t ret = sourceService->UnregisterDistributedHardware(devId, dhId, reqId); + EXPECT_EQ(ret, ERR_DH_SCREEN_SA_DISABLE_FAILED); +} + +/* * + * @tc.name: UnregisterDistributedHardware_003 + * @tc.desc: Verify the UnregisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceServiceTest, UnregisterDistributedHardware_003, TestSize.Level1) +{ + std::shared_ptr sourceService = + std::make_shared(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false); + std::string devId; + std::string dhId; + std::string reqId; + g_mockUnregisterDistributedHardwareV1ReturnInt32Value = 0; + g_mockUnregisterDistributedHardwareV2ReturnInt32Value = 0; + int32_t ret = sourceService->UnregisterDistributedHardware(devId, dhId, reqId); + EXPECT_EQ(ret, DH_SUCCESS); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/screentransport/test/unittest/screensinkprocessor/src/image_sink_decoder_test.cpp b/services/screentransport/test/unittest/screensinkprocessor/src/image_sink_decoder_test.cpp index 62dfa99dedf8e19c0625a84048c9dd4a724afc2d..7efe9f09bfbc1ebab849796b5116dc85acc04cd7 100644 --- a/services/screentransport/test/unittest/screensinkprocessor/src/image_sink_decoder_test.cpp +++ b/services/screentransport/test/unittest/screensinkprocessor/src/image_sink_decoder_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -94,6 +94,18 @@ HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_003, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, imageDecoder_->ConfigureDecoder(param_)); } +/** + * @tc.name: configure_decoder_test_004 + * @tc.desc: Verify the ConfigureDecoder function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ImageSinkDecoderTest, configure_decoder_test_004, TestSize.Level1) +{ + param_.videoWidth_ = VIDEO_DATA_NUM + 1; + EXPECT_EQ(DH_SUCCESS, imageDecoder_->ConfigureDecoder(param_)); +} + /** * @tc.name: release_decoder_test_001 * @tc.desc: Verify the ReleaseDecoder function. diff --git a/services/screentransport/test/unittest/screensourceprocessor/src/image_source_encoder_test.cpp b/services/screentransport/test/unittest/screensourceprocessor/src/image_source_encoder_test.cpp index 16e2150b10ffccc327b845afe57e215e492e7f03..84fa854dd6d619978637f514dde943520e972d13 100644 --- a/services/screentransport/test/unittest/screensourceprocessor/src/image_source_encoder_test.cpp +++ b/services/screentransport/test/unittest/screensourceprocessor/src/image_source_encoder_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -39,6 +39,18 @@ void ImageSourceEncoderTest::TearDown(void) } } +/** + * @tc.name: InitDscreenDBG_001 + * @tc.desc: Verify InitDscreenDBG when dlopen fails. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ImageSourceEncoderTest, InitDscreenDBG_001, TestSize.Level1) +{ + encoder->InitDscreenDBG(); + EXPECT_EQ(encoder->pHandler_, nullptr); +} + /** * @tc.name: ConfigureEncoder_001 * @tc.desc: Verify the ConfigureEncoder function.