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 3c5e50ef255f2204eb50ad7ed11e95f14ca58443..b3f5f4ddd87185053395f91b4b47b9b5e74fb4a3 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 @@ -366,5 +366,21 @@ HWTEST_F(DScreenSourceHandlerTest, OnRemoteDied_001, TestSize.Level1) DScreenSourceHandler::GetInstance().sourceSvrRecipient_->OnRemoteDied(remote2); EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_); } + +/** + * @tc.name: OnRemoteSourceSvrDied_001 + * @tc.desc: Verify the OnRemoteSourceSvrDied function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceHandlerTest, OnRemoteSourceSvrDied_001, TestSize.Level1) +{ + sptr samgr = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID); + wptr remote(remoteObject); + DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote); + EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/screenhandler/test/fuzztest/pluginhardware_fuzzer/BUILD.gn b/screenhandler/test/fuzztest/pluginhardware_fuzzer/BUILD.gn index b514afcec480d88d3239c0c21ed9c1cb54d2a931..e1880a618b3d73fa5fc60c772d330fe3f98b64ba 100644 --- a/screenhandler/test/fuzztest/pluginhardware_fuzzer/BUILD.gn +++ b/screenhandler/test/fuzztest/pluginhardware_fuzzer/BUILD.gn @@ -47,6 +47,7 @@ ohos_fuzztest("PluginHardwareFuzzTest") { "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "graphic_2d:libgraphic_utils", + "graphic_2d:librender_service_base", "graphic_surface:surface", "hilog:libhilog", "ipc:ipc_core", diff --git a/screenhandler/test/fuzztest/registerpluginlistener_fuzzer/BUILD.gn b/screenhandler/test/fuzztest/registerpluginlistener_fuzzer/BUILD.gn index d7f1f8b6124ba7441326d9817786006aca7fa811..f2573bddf2399f941f936fa039eae4e74e55de9a 100644 --- a/screenhandler/test/fuzztest/registerpluginlistener_fuzzer/BUILD.gn +++ b/screenhandler/test/fuzztest/registerpluginlistener_fuzzer/BUILD.gn @@ -47,6 +47,7 @@ ohos_fuzztest("RegisterPluginListenerFuzzTest") { "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "graphic_2d:libgraphic_utils", + "graphic_2d:librender_service_base", "graphic_surface:surface", "hilog:libhilog", "ipc:ipc_core", diff --git a/screenhandler/test/fuzztest/unpluginhardware_fuzzer/BUILD.gn b/screenhandler/test/fuzztest/unpluginhardware_fuzzer/BUILD.gn index 0dd1e215596ae86cbc60cfa89e8283578f3b45c2..e35cee5504732c0e24774011fd2216cb3dfe58c1 100644 --- a/screenhandler/test/fuzztest/unpluginhardware_fuzzer/BUILD.gn +++ b/screenhandler/test/fuzztest/unpluginhardware_fuzzer/BUILD.gn @@ -47,6 +47,7 @@ ohos_fuzztest("UnPluginHardwareFuzzTest") { "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "graphic_2d:libgraphic_utils", + "graphic_2d:librender_service_base", "graphic_surface:surface", "hilog:libhilog", "ipc:ipc_core", diff --git a/screenhandler/test/unittest/screenhandler/BUILD.gn b/screenhandler/test/unittest/screenhandler/BUILD.gn index 1d6d96d815e2fdf4453a8c71fe69fd3ac2e7a4a3..484697f8729a11a4258cc65a7444b186ce4f6661 100644 --- a/screenhandler/test/unittest/screenhandler/BUILD.gn +++ b/screenhandler/test/unittest/screenhandler/BUILD.gn @@ -52,6 +52,7 @@ ohos_unittest("DscreenHandlerTest") { "googletest:gmock", "googletest:gtest_main", "graphic_2d:libgraphic_utils", + "graphic_2d:librender_service_base", "graphic_surface:surface", "hilog:libhilog", "ipc:ipc_core", 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 7addbd28a1c1b2df2dfc0cbbaadea116292773e4..f1ee93abdc28c25e0b9bb1ccc4ff6adcee1ca68f 100644 --- a/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp +++ b/services/common/test/unittest/imageJpeg/jpeg_image_processor_test.cpp @@ -114,5 +114,55 @@ HWTEST_F(ScreenImageJpegTest, ReplaceDamage2LastFrame_001, TestSize.Level1) int32_t ret = jpeg_->ReplaceDamage2LastFrame(lastframe, dirtyImageData, rect); EXPECT_EQ(DH_SUCCESS, ret); } + +/** + * @tc.name: DecodeDamageData_001 + * @tc.desc: Verify the DecodeDamageData function with invalid dirty rect position and size. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenImageJpegTest, DecodeDamageData_001, TestSize.Level1) +{ + std::shared_ptr dataBuffer = std::make_shared(16); + uint8_t *lastFrame = nullptr; + DirtyRect rect = {100, 100, 100, 100, 100}; + dataBuffer->AddDirtyRect(rect); + jpeg_->configParam_.SetScreenWidth(rect.xPos - 1); + int32_t ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + dataBuffer->AddDirtyRect(rect); + jpeg_->configParam_.SetScreenWidth(rect.xPos); + jpeg_->configParam_.SetScreenHeight(rect.xPos - 1); + ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + dataBuffer->AddDirtyRect(rect); + jpeg_->configParam_.SetScreenHeight(rect.xPos); + ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + rect.width = 0; + dataBuffer->AddDirtyRect(rect); + ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); +} + +/** + * @tc.name: DecodeDamageData_002 + * @tc.desc: Verify the DecodeDamageData function with invalid dirty rect size. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenImageJpegTest, DecodeDamageData_002, TestSize.Level1) +{ + std::shared_ptr dataBuffer = std::make_shared(10); + uint8_t *lastFrame = nullptr; + + DirtyRect rect = {20, 20, 20, 20, DIRTY_MAX_BUF_SIZE + 1}; + dataBuffer->AddDirtyRect(rect); + int32_t ret = jpeg_->DecodeDamageData(dataBuffer, lastFrame); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/common/test/unittest/utils/dscreen_hidumper_test.cpp b/services/common/test/unittest/utils/dscreen_hidumper_test.cpp index c74ad12a75c024e2eeb64bb38f6d4b18696c3ba7..b7a5f4287c0210f2e3dbb1f931187710d3625992 100644 --- a/services/common/test/unittest/utils/dscreen_hidumper_test.cpp +++ b/services/common/test/unittest/utils/dscreen_hidumper_test.cpp @@ -14,11 +14,28 @@ */ #include "dscreen_hidumper_test.h" +#include "dscreen_hidumper.h" using namespace testing::ext; namespace OHOS { namespace DistributedHardware { + +int32_t DscreenHidumper::DumpScreenData(std::string &result) +{ + return DH_SUCCESS; +} + +int32_t DscreenHidumper::ReDumpScreenData(std::string &result) +{ + return DH_SUCCESS; +} + +int32_t DscreenHidumper::ShowIllegalInfomation(std::string &result) +{ + return DH_SUCCESS; +} + void DScreenHidumperTest::SetUpTestCase(void) {} void DScreenHidumperTest::TearDownTestCase(void) {} @@ -76,5 +93,60 @@ HWTEST_F(DScreenHidumperTest, Dump_003, TestSize.Level1) EXPECT_EQ(helpStr, result); } +/** + * @tc.name: ProcessDump_001 + * @tc.desc: Verify the ProcessDump function with HidumpFlag::DUMP_SCREEN_DATA. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenHidumperTest, ProcessDump_001, TestSize.Level1) +{ + std::string result; + std::string argsStr = "--dump"; + int32_t ret = DscreenHidumper::GetInstance().ProcessDump(argsStr, result); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: ProcessDump_002 + * @tc.desc: Verify the ProcessDump function with HidumpFlag::DUMP_SCREEN_DATA_RESTART. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenHidumperTest, ProcessDump_002, TestSize.Level1) +{ + std::string result; + std::string argsStr = "--redump"; + int32_t ret = DscreenHidumper::GetInstance().ProcessDump(argsStr, result); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: ProcessDump_003 + * @tc.desc: Verify the ProcessDump function with HidumpFlag::DUMP_SCREEN_DATA_STOP. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenHidumperTest, ProcessDump_003, TestSize.Level1) +{ + std::string result; + std::string argsStr = "--stopdump"; + int32_t ret = DscreenHidumper::GetInstance().ProcessDump(argsStr, result); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: ProcessDump_004 + * @tc.desc: Verify the ProcessDump function with an unknown command. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenHidumperTest, ProcessDump_004, TestSize.Level1) +{ + std::string result; + std::string argsStr = "unknown_command"; + int32_t ret = DscreenHidumper::GetInstance().ProcessDump(argsStr, result); + EXPECT_EQ(DH_SUCCESS, ret); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/common/test/unittest/utils/dscreen_maprelation_test.cpp b/services/common/test/unittest/utils/dscreen_maprelation_test.cpp index edfa7ff9dac4219063fb54c640fa9416475866a7..b56e356d8402cd50da48a8680c202547137d1313 100644 --- a/services/common/test/unittest/utils/dscreen_maprelation_test.cpp +++ b/services/common/test/unittest/utils/dscreen_maprelation_test.cpp @@ -189,6 +189,12 @@ HWTEST_F(DScreenMapRelationTest, from_json_003, TestSize.Level1) j[KEY_POINT_START_Y] = startY; from_json(j, displayRect); EXPECT_EQ(0, displayRect.startY); + j[KEY_WIDTH] = static_cast(DSCREEN_MAX_VIDEO_DATA_WIDTH) + 1; + from_json(j, displayRect); + EXPECT_EQ(0, displayRect.width); + j[KEY_HEIGHT] = static_cast(DSCREEN_MAX_VIDEO_DATA_HEIGHT) + 1; + from_json(j, displayRect); + EXPECT_EQ(0, displayRect.height); j[KEY_WIDTH] = width; from_json(j, displayRect); EXPECT_EQ(0, displayRect.width); @@ -219,6 +225,12 @@ HWTEST_F(DScreenMapRelationTest, from_json_004, TestSize.Level1) j[KEY_POINT_START_Y] = startY; from_json(j, screenRect); EXPECT_EQ(0, screenRect.startY); + j[KEY_WIDTH] = DSCREEN_MAX_SCREEN_DATA_WIDTH + 1; + from_json(j, screenRect); + EXPECT_EQ(0, screenRect.width); + j[KEY_HEIGHT] = DSCREEN_MAX_SCREEN_DATA_HEIGHT + 1; + from_json(j, screenRect); + EXPECT_EQ(0, screenRect.height); j[KEY_WIDTH] = width; from_json(j, screenRect); EXPECT_EQ(0, screenRect.width); diff --git a/services/screenclient/BUILD.gn b/services/screenclient/BUILD.gn index 9a74d6b6204be8e776d886ddb22aaa04d58ced43..f24202fa69f05f0cbbfa4be6f9ef23e9332fb206 100644 --- a/services/screenclient/BUILD.gn +++ b/services/screenclient/BUILD.gn @@ -50,6 +50,7 @@ ohos_shared_library("distributed_screen_client") { "distributed_hardware_fwk:distributedhardwareutils", "eventhandler:libeventhandler", "graphic_2d:2d_graphics", + "graphic_2d:GLESv3", "graphic_2d:libcomposer", "graphic_2d:libgraphic_utils", "graphic_2d:librender_service_base", diff --git a/services/screenservice/sourceservice/BUILD.gn b/services/screenservice/sourceservice/BUILD.gn index 620421fd9c253213d10e8c2b8e682e559989c401..4d005653579d71059f7643e7aafdddec6eb60f07 100644 --- a/services/screenservice/sourceservice/BUILD.gn +++ b/services/screenservice/sourceservice/BUILD.gn @@ -90,6 +90,7 @@ ohos_shared_library("distributed_screen_source") { "distributed_hardware_fwk:libdhfwk_sdk", "eventhandler:libeventhandler", "graphic_2d:2d_graphics", + "graphic_2d:GLESv3", "graphic_2d:libcomposer", "graphic_2d:librender_service_base", "graphic_2d:librender_service_client", diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn b/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn index 16472d9f4829fb2b27adfb43b2993a0abc875cc4..4085f75dabbb5b76d7a32067eb3e2ac3f0ca4f99 100644 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn @@ -50,6 +50,7 @@ ohos_unittest("DScreenSinkStubTest") { ] external_deps = [ + "access_token:libaccesstoken_sdk", "c_utils:utils", "googletest:gmock", "googletest:gtest_main", 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 708220bb6bc740292f6200e5b645e51d78c49312..d6374ba7ca97fe23838e24195a4db72d53569eb2 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 @@ -13,15 +13,24 @@ * limitations under the License. */ -#include "dscreen_sink_stub_test.h" - #include +#include "dscreen_sink_stub_test.h" +#include "accesstoken_kit.h" #include "dscreen_constants.h" using namespace testing; using namespace testing::ext; +static int g_mockVerifyAccessTokenReturnIntValue = -1; + namespace OHOS { +namespace Security::AccessToken { +int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName) +{ + return g_mockVerifyAccessTokenReturnIntValue; +} +} + namespace DistributedHardware { void DScreenSinkStubTest::SetUpTestCase(void) { @@ -33,6 +42,7 @@ void DScreenSinkStubTest::TearDownTestCase(void) void DScreenSinkStubTest::SetUp(void) { + g_mockVerifyAccessTokenReturnIntValue = -1; } void DScreenSinkStubTest::TearDown(void) @@ -88,6 +98,10 @@ HWTEST_F(DScreenSinkStubTest, InitSink_001, TestSize.Level1) ret = sinkProxy.InitSink(""); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + std::string param(PARAM_MAX_SIZE + 1, 'a'); + ret = sinkProxy.InitSink(param); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); } /** @@ -132,6 +146,21 @@ HWTEST_F(DScreenSinkStubTest, SubscribeLocalHardware_001, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); } +/** + * @tc.name: SubscribeLocalHardware_002 + * @tc.desc: Test the SubscribeLocalHardware method when param exceeds the maximum size. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, SubscribeLocalHardware_002, TestSize.Level1) +{ + sptr sinkStubPtr(new TestDScreenSinkStub()); + DScreenSinkProxy sinkProxy(sinkStubPtr); + std::string param(PARAM_MAX_SIZE + 1, 'a'); + int32_t ret = sinkProxy.SubscribeLocalHardware("dhId000", param); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); +} + /** * @tc.name: UnsubscribeLocalHardware_001 * @tc.desc: Invoke the UnsubscribeLocalHardware ipc interface. @@ -156,6 +185,25 @@ HWTEST_F(DScreenSinkStubTest, UnsubscribeLocalHardware_001, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); } +/** + * @tc.name: UnsubscribeLocalHardware_002 + * @tc.desc: Invoke the UnsubscribeLocalHardware ipc interface. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, UnsubscribeLocalHardware_002, TestSize.Level1) +{ + sptr sinkStubPtr(new TestDScreenSinkStub()); + DScreenSinkProxy sinkProxy(sinkStubPtr); + std::string dhId(DID_MAX_SIZE + 1, 'a'); + int32_t ret = sinkProxy.UnsubscribeLocalHardware(dhId); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + + dhId.clear(); + ret = sinkProxy.UnsubscribeLocalHardware(dhId); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); +} + /** * @tc.name: DScreenNotify_001 * @tc.desc: Invoke the DScreenNotify ipc interface. @@ -294,5 +342,46 @@ HWTEST_F(DScreenSinkStubTest, DScreenNotifyInner_005, TestSize.Level1) int32_t ret = sinkStub->DScreenNotifyInner(data, reply, option); EXPECT_EQ(ret, DH_SUCCESS); } + +/** + * @tc.name: InitSinkInner_001 + * @tc.desc: Verify the InitSinkInner function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, InitSinkInner_001, TestSize.Level1) +{ + sptr sinkStub(new TestDScreenSinkStub()); + MessageParcel data; + MessageParcel reply; + MessageOption option; + std::string param = ""; + data.WriteString(param); + g_mockVerifyAccessTokenReturnIntValue = 0; + int32_t ret = sinkStub->InitSinkInner(data, reply, option); + EXPECT_EQ(ret, ERR_DH_SCREEN_INPUT_PARAM_INVALID); + + param = "param"; + data.WriteString(param); + ret = sinkStub->InitSinkInner(data, reply, option); + EXPECT_EQ(ret, DH_SUCCESS); +} + +/** + * @tc.name: ReleaseSinkInner_001 + * @tc.desc: Verify the ReleaseSinkInner function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, ReleaseSinkInner_001, TestSize.Level1) +{ + sptr sinkStub(new TestDScreenSinkStub()); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + int32_t ret = sinkStub->ReleaseSinkInner(data, reply, option); + EXPECT_EQ(ret, DH_SUCCESS); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp index 0c507d60804fde8246743ad860c63c7abb8fc441..5a259a5425c898dc4539d7ce6fbc6060d9a307f1 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp @@ -14,17 +14,13 @@ */ #include "1.0/include/dscreen_test.h" -#include "accesstoken_kit.h" -#include "nativetoken_kit.h" -#include "token_setproc.h" - -#include "dscreen_constants.h" -#include "dscreen_errcode.h" #include "1.0/include/dscreen_manager.h" #include "common/include/screen_manager_adapter.h" +#include "dscreen_constants.h" +#include "dscreen_errcode.h" #include "dscreen_util.h" -#include "video_param.h" #include "screen_source_trans.h" +#include "video_param.h" using namespace testing; using namespace testing::ext; @@ -56,29 +52,6 @@ void DScreenTestV1::SetUp(void) void DScreenTestV1::TearDown(void) {} -void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId) -{ - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permsNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_basic", - }; - - infoInstance.processName = "DscreenMgrTest"; - tokenId = GetAccessTokenId(&infoInstance); - SetSelfTokenID(tokenId); - OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); -} - -void DisablePermissionAccess(const uint64_t &tokenId) -{ - OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId); -} - /** * @tc.name: AddTask_001 * @tc.desc: Verify the AddTask function failed. @@ -381,16 +354,10 @@ HWTEST_F(DScreenTestV1, NegotiateCodecType_002, TestSize.Level1) */ HWTEST_F(DScreenTestV1, SetUp_001, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); dScreen_->sourceTrans_ = nullptr; dScreen_->version_ = "1.0"; int32_t ret = dScreen_->SetUp(); EXPECT_EQ(DH_SUCCESS, ret); - DisablePermissionAccess(tokenId_); } /** @@ -401,16 +368,10 @@ HWTEST_F(DScreenTestV1, SetUp_001, TestSize.Level1) */ HWTEST_F(DScreenTestV1, SetUp_002, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); dScreen_->sourceTrans_ = std::make_shared(); dScreen_->version_ = "1.0"; int32_t ret = dScreen_->SetUp(); EXPECT_EQ(DH_SUCCESS, ret); - DisablePermissionAccess(tokenId_); } /** diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/screen_manager_adapter_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/screen_manager_adapter_test.cpp index 127997d7d74e7ce5876595812709414960979387..f6dd85f30cfadf7c2d17be60e9b0af12e234e010 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/screen_manager_adapter_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/screen_manager_adapter_test.cpp @@ -16,13 +16,12 @@ #include "1.0/include/screen_manager_adapter_test.h" #include "common/include/screen_manager_adapter.h" +#include "display_manager.h" #include "dscreen_constants.h" #include "dscreen_errcode.h" #include "dscreen_util.h" -#include "video_param.h" -#include "accesstoken_kit.h" -#include "nativetoken_kit.h" #include "token_setproc.h" +#include "video_param.h" using namespace testing; using namespace testing::ext; @@ -38,29 +37,6 @@ void DScreenManagerAdapterTest::SetUp(void) {} void DScreenManagerAdapterTest::TearDown(void) {} -void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId) -{ - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permsNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_basic", - }; - - infoInstance.processName = "DscreenMgrTest"; - tokenId = GetAccessTokenId(&infoInstance); - SetSelfTokenID(tokenId); - OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); -} - -void DisablePermissionAccess(const uint64_t &tokenId) -{ - OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId); -} - /** * @tc.name: CreateVirtualScreen_001 * @tc.desc: Verify the CreateVirtualScreen function failed. @@ -245,22 +221,17 @@ HWTEST_F(DScreenManagerAdapterTest, GetMapRelation_001, TestSize.Level1) */ HWTEST_F(DScreenManagerAdapterTest, GetMapRelation_002, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); std::string devId = "devId"; std::string dhId = "dhId"; ScreenMgrAdapter::GetInstance().screenIdMap_.clear(); std::shared_ptr videoParam = std::make_shared(); videoParam->SetScreenWidth(VIDEO_DATA_NUM); videoParam->SetScreenHeight(VIDEO_DATA_NUM); - uint64_t screenId = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam); - std::shared_ptr ret = ScreenMgrAdapter::GetInstance().GetMapRelation(screenId); - ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(screenId); + uint64_t VirtualScreenId = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam); + uint64_t defaultScreenId = Rosen::DisplayManager::GetInstance().GetDefaultDisplay()->GetScreenId(); + std::shared_ptr ret = ScreenMgrAdapter::GetInstance().GetMapRelation(defaultScreenId); + ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(VirtualScreenId); ScreenMgrAdapter::GetInstance().screenIdMap_.clear(); - DisablePermissionAccess(tokenId_); EXPECT_NE(nullptr, ret); } } // namespace DistributedHardware diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp index a244eac9d781e1c9114c85ccd5e2b86cd6a0fbb8..42d9fe386562886f1388db53aebb9bc6d404d531 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp @@ -171,9 +171,6 @@ HWTEST_F(DScreenManagerTestV2, OnUnregResult_001, TestSize.Level1) */ HWTEST_F(DScreenManagerTestV2, EnableDistributedScreen_001, TestSize.Level1) { - int32_t ret = DScreenManager::GetInstance().EnableDistributedScreen("", "", EnableParam{"", "", "", ""}, ""); - EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, ret); - std::string devId = "devId000"; std::string dhId = "dhId000"; EnableParam param = {"", "", "2.0", "attrs000"}; @@ -183,7 +180,7 @@ HWTEST_F(DScreenManagerTestV2, EnableDistributedScreen_001, TestSize.Level1) std::shared_ptr dScreenCallback = std::make_shared(); std::shared_ptr dScreen = std::make_shared(devId, dhId, dScreenCallback); dScreen->SetState(DScreenState::ENABLED); - ret = DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId); + int32_t ret = DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId); EXPECT_EQ(DH_SUCCESS, ret); dScreen->SetState(DScreenState::DISCONNECTING); @@ -194,6 +191,39 @@ HWTEST_F(DScreenManagerTestV2, EnableDistributedScreen_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, ret); } +/* * + * @tc.name: EnableDistributedScreen_002 + * @tc.desc: Verify the EnableDistributedScreen function failed with invalid parameters. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTestV2, EnableDistributedScreen_002, TestSize.Level1) +{ + std::string devId = "devId000"; + std::string dhId = "dhId000"; + EnableParam param = { "2.0", "attrs000", "", "" }; + std::string reqId = "reqId000"; + + EXPECT_EQ(DScreenManager::GetInstance().EnableDistributedScreen("", dhId, param, reqId), + ERR_DH_SCREEN_SA_ENABLE_FAILED); + + EXPECT_EQ(DScreenManager::GetInstance().EnableDistributedScreen(devId, "", param, reqId), + ERR_DH_SCREEN_SA_ENABLE_FAILED); + + param.sinkVersion = ""; + EXPECT_EQ(DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId), + ERR_DH_SCREEN_SA_ENABLE_FAILED); + + param.sinkVersion = "2.0"; + param.sinkAttrs = ""; + EXPECT_EQ(DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId), + ERR_DH_SCREEN_SA_ENABLE_FAILED); + + param.sinkAttrs = "attrs000"; + EXPECT_EQ(DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, ""), + ERR_DH_SCREEN_SA_ENABLE_FAILED); +} + /** * @tc.name: DisableDistributedScreen_001 * @tc.desc: Verify the DisableDistributedScreen function failed. @@ -344,6 +374,20 @@ HWTEST_F(DScreenManagerTestV2, GetScreenDumpInfo_002, TestSize.Level1) EXPECT_EQ(false, result.empty()); } +/** + * @tc.name: GetScreenDumpInfo_003 + * @tc.desc: Verify the GetScreenDumpInfo function failed. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTestV2, GetScreenDumpInfo_003, TestSize.Level1) +{ + std::string result; + DScreenManager::GetInstance().Release(); + DScreenManager::GetInstance().GetScreenDumpInfo(result); + EXPECT_EQ(false, result.empty()); +} + /** * @tc.name: PublishMessage_001 * @tc.desc: Verify the PublishMessage function failed. diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn index 6c79e0f3339cdd1ff633824af3b5349aea22ad56..5dbaa8c98cf51bff8836dc53d42c3e25b7927f30 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/BUILD.gn @@ -55,6 +55,7 @@ ohos_unittest("DScreenSourceStubTest") { ] external_deps = [ + "access_token:libaccesstoken_sdk", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "googletest:gmock", diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp index a93ab47b6fbdda14d06970fa0e7a6acf8d2cefa8..c63cb49383adb0ccb18da7dbbb2f5bb08bcd6daa 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp @@ -13,15 +13,24 @@ * limitations under the License. */ +#include #include "dscreen_source_stub_test.h" +#include "accesstoken_kit.h" #include "dscreen_constants.h" -#include - using namespace testing; using namespace testing::ext; +static int g_mockVerifyAccessTokenReturnIntValue = -1; + namespace OHOS { +namespace Security::AccessToken { +int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName) +{ + return g_mockVerifyAccessTokenReturnIntValue; +} +} + namespace DistributedHardware { void DScreenSourceStubTest::SetUpTestCase(void) { @@ -33,6 +42,7 @@ void DScreenSourceStubTest::TearDownTestCase(void) void DScreenSourceStubTest::SetUp(void) { + g_mockVerifyAccessTokenReturnIntValue = -1; } void DScreenSourceStubTest::TearDown(void) @@ -104,6 +114,10 @@ HWTEST_F(DScreenSourceStubTest, InitSource_001, TestSize.Level1) int32_t ret = sourceProxy.InitSource("", callback); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + std::string params(PARAM_MAX_SIZE + 1, 'a'); + ret = sourceProxy.InitSource(params, callback); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); + ret = sourceProxy.InitSource("params000", callback); EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret); @@ -173,6 +187,58 @@ HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardware_001, TestSize.Level1 EXPECT_EQ(DH_SUCCESS, ret); } +/** + * @tc.name: CheckRegParams_001 + * @tc.desc: Test CheckRegParams with valid parameters. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, DScreenSourceProxy_CheckRegParams_001, TestSize.Level1) +{ + std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a'); + EnableParam validParam; + validParam.sinkVersion = exceedParamMaxSizeStr; + validParam.sinkAttrs = exceedParamMaxSizeStr; + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + + sptr sourceStubPtr(new TestDScreenSourceStub()); + DScreenSourceProxy sourceProxy(sourceStubPtr); + EXPECT_FALSE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId)); + + validParam.sinkVersion = "sinkVersion"; + EXPECT_FALSE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId)); + + validParam.sinkAttrs = "sinkAttrs"; + EXPECT_TRUE(sourceProxy.CheckRegParams(devId, dhId, validParam, reqId)); +} + +/** + * @tc.name: CheckConfigParams_001 + * @tc.desc: Test CheckConfigParams with valid parameters. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, DScreenSourceProxy_CheckConfigParams_001, TestSize.Level1) +{ + std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a'); + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string key = exceedParamMaxSizeStr; + std::string value = exceedParamMaxSizeStr; + + sptr sourceStubPtr(new TestDScreenSourceStub()); + DScreenSourceProxy sourceProxy(sourceStubPtr); + EXPECT_FALSE(sourceProxy.CheckConfigParams(devId, dhId, key, value)); + + key = "key"; + EXPECT_FALSE(sourceProxy.CheckConfigParams(devId, dhId, key, value)); + + value = "value"; + EXPECT_TRUE(sourceProxy.CheckConfigParams(devId, dhId, key, value)); +} + /** * @tc.name: UnregisterDistributedHardware_001 * @tc.desc: Invoke the UnregisterDistributedHardware ipc interface. @@ -253,21 +319,26 @@ HWTEST_F(DScreenSourceStubTest, ConfigDistributedHardware_001, TestSize.Level1) */ HWTEST_F(DScreenSourceStubTest, DScreenNotify_001, TestSize.Level1) { + std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a'); + std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a'); + int32_t eventCode = 0; + std::string eventContent = ""; + std::string devId = ""; + sptr sourceStubPtr(new TestDScreenSourceStub()); DScreenSourceProxy sourceProxy(sourceStubPtr); + sourceProxy.DScreenNotify(devId, eventCode, eventContent); - sourceProxy.DScreenNotify("", 0, "eventContent000"); + devId = exceedDidMaxSizeStr; + sourceProxy.DScreenNotify(devId, eventCode, eventContent); - std::string longString = R"(dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d - Id000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000d - hId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000dhId000)"; - sourceProxy.DScreenNotify(longString, 0, "eventContent000"); + devId = "devId000"; + sourceProxy.DScreenNotify(devId, eventCode, eventContent); - sourceProxy.DScreenNotify("devId000", 0, ""); + eventContent = exceedParamMaxSizeStr; + sourceProxy.DScreenNotify(devId, eventCode, eventContent); - std::string devId = "devId000"; - int32_t eventCode = 0; - std::string eventContent = "eventContent000"; + eventContent = "eventContent000"; sourceProxy.DScreenNotify(devId, eventCode, eventContent); EXPECT_STREQ(devId.c_str(), ((sptr &)sourceStubPtr)->devId_.c_str()); EXPECT_EQ(eventCode, ((sptr &)sourceStubPtr)->eventCode_); @@ -351,6 +422,66 @@ HWTEST_F(DScreenSourceStubTest, InitSourceInner_001, TestSize.Level1) EXPECT_EQ(DSCREEN_INIT_ERR, result); } +/** + * @tc.name: InitSourceInner_002 + * @tc.desc: When HasEnableDHPermission returns true but param is empty or exceeds max size + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, InitSourceInner_002, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString(""); + int32_t result = stubPtr->InitSourceInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + std::string longParam(PARAM_MAX_SIZE + 1, 'a'); + data.WriteString(longParam); + result = stubPtr->InitSourceInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); +} + +/** + * @tc.name: InitSourceInner_003 + * @tc.desc: When HasEnableDHPermission returns true but remoteObject is nullptr + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, InitSourceInner_003, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString("validParam"); + int32_t result = stubPtr->InitSourceInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_SA_READPARAM_FAILED, result); +} + +/** + * @tc.name: InitSourceInner_005 + * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, InitSourceInner_005, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString("validParam"); + sptr remoteObject = new TestDScreenSourceStub(); + data.WriteRemoteObject(remoteObject); + int32_t result = stubPtr->InitSourceInner(data, reply, option); + EXPECT_EQ(DH_SUCCESS, result); +} + /** * @tc.name: ReleaseSourceInner_001 * @tc.desc: When there is no permission @@ -368,6 +499,23 @@ HWTEST_F(DScreenSourceStubTest, ReleaseSourceInner_001, TestSize.Level1) EXPECT_EQ(DSCREEN_INIT_ERR, result); } +/** + * @tc.name: ReleaseSourceInner_002 + * @tc.desc: When HasEnableDHPermission returns true + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, ReleaseSourceInner_002, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + int32_t result = stubPtr->ReleaseSourceInner(data, reply, option); + EXPECT_EQ(DH_SUCCESS, result); +} + /** * @tc.name: RegisterDistributedHardwareInner_001 * @tc.desc: When there is no permission @@ -385,6 +533,134 @@ HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_001, TestSize.L EXPECT_EQ(DSCREEN_INIT_ERR, result); } +/** + * @tc.name: RegisterDistributedHardwareInner_002 + * @tc.desc: When HasEnableDHPermission returns true but input parameters are invalid + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_002, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString(""); + data.WriteString("dhId"); + data.WriteString("version"); + data.WriteString("attrs"); + data.WriteString("reqId"); + int32_t result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString(""); + data.WriteString("version"); + data.WriteString("attrs"); + data.WriteString("reqId"); + result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString(""); + data.WriteString("attrs"); + data.WriteString("reqId"); + result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString("version"); + data.WriteString(""); + data.WriteString("reqId"); + result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString("version"); + data.WriteString("attrs"); + data.WriteString(""); + result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); +} + +/** + * @tc.name: RegisterDistributedHardwareInner_003 + * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, RegisterDistributedHardwareInner_003, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString("version"); + data.WriteString("attrs"); + data.WriteString("reqId"); + int32_t result = stubPtr->RegisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(DH_SUCCESS, result); +} + +/** + * @tc.name: UnregisterDistributedHardwareInner_001 + * @tc.desc: When HasEnableDHPermission returns true but input parameters are invalid + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, UnregisterDistributedHardwareInner_001, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString(""); + data.WriteString("dhId"); + data.WriteString("reqId"); + int32_t result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString(""); + data.WriteString("reqId"); + result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); + + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString(""); + result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, result); +} + +/** + * @tc.name: UnregisterDistributedHardwareInner_002 + * @tc.desc: When HasEnableDHPermission returns true and all parameters are valid + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, UnregisterDistributedHardwareInner_002, TestSize.Level1) +{ + std::shared_ptr stubPtr = std::make_shared(); + MessageParcel data; + MessageParcel reply; + MessageOption option; + g_mockVerifyAccessTokenReturnIntValue = 0; + data.WriteString("devId"); + data.WriteString("dhId"); + data.WriteString("reqId"); + int32_t result = stubPtr->UnregisterDistributedHardwareInner(data, reply, option); + EXPECT_EQ(DH_SUCCESS, result); +} + /** * @tc.name: CheckRegParams_001 * @tc.desc: ValidParams diff --git a/services/screentransport/test/unittest/screendatachannel/BUILD.gn b/services/screentransport/test/unittest/screendatachannel/BUILD.gn index e6fc942a36744d8fc320c7afb076d98f3009f914..549027875aed9873684735f319e1578c0df0527a 100644 --- a/services/screentransport/test/unittest/screendatachannel/BUILD.gn +++ b/services/screentransport/test/unittest/screendatachannel/BUILD.gn @@ -21,17 +21,19 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ "./include", - "${services_path}/screentransport/test/unittest/screentranstestutils/include", "${common_path}/include", "${services_path}/common/databuffer/include", + "${services_path}/common/decision_center/include", + "${services_path}/common/imageJpeg/include", "${services_path}/common/screen_channel/include", "${services_path}/common/utils/include", + "${services_path}/screentransport/screendatachannel/include", "${services_path}/screentransport/screensinkprocessor/include", "${services_path}/screentransport/screensinktrans/include", - "${services_path}/screentransport/screensourcetrans/include", - "${services_path}/screentransport/screendatachannel/include", - "${services_path}/screentransport/screensourceprocessor/include", "${services_path}/screentransport/screensourceprocessor/encoder/include", + "${services_path}/screentransport/screensourceprocessor/include", + "${services_path}/screentransport/screensourcetrans/include", + "${services_path}/screentransport/test/unittest/screentranstestutils/include", "${services_path}/softbusadapter/include", ] } @@ -58,13 +60,16 @@ ohos_unittest("DataChannelTest") { "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libtokensetproc_shared", + "av_codec:av_codec_client", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", "dsoftbus:softbus_client", "googletest:gmock", "googletest:gtest_main", + "graphic_surface:surface", "hilog:libhilog", "json:nlohmann_json_static", + "media_foundation:media_foundation", ] defines = [ diff --git a/services/screentransport/test/unittest/screendatachannel/src/screen_data_channel_impl_test.cpp b/services/screentransport/test/unittest/screendatachannel/src/screen_data_channel_impl_test.cpp index 109e9c8821105e9f27e6565a526d0f053fcfedd1..8e775317181482b71e366871a3206d7f9bb672a1 100644 --- a/services/screentransport/test/unittest/screendatachannel/src/screen_data_channel_impl_test.cpp +++ b/services/screentransport/test/unittest/screendatachannel/src/screen_data_channel_impl_test.cpp @@ -14,12 +14,19 @@ */ #include "screen_data_channel_impl_test.h" -#include "dscreen_util.h" #include "dscreen_json_util.h" -#include "accesstoken_kit.h" -#include "nativetoken_kit.h" +#include "dscreen_util.h" +#include "screen_source_trans.h" +#include "softbus_adapter.h" #include "token_setproc.h" +static int32_t g_mockCreateSoftbusSessionServerReturnInt32Value = -1; +static int32_t g_mockOpenSoftbusSessionReturnInt32Value = -1; +static int32_t g_mockRegisterSoftbusListenerReturnInt32Value = -1; +static int32_t g_mockRemoveSoftbusSessionServerReturnInt32Value = -1; +static int32_t g_mockUnRegisterSoftbusListenerReturnInt32Value = -1; +static int32_t g_mockCloseSoftbusSessionReturnInt32Value = -1; + using namespace testing; using namespace testing::ext; @@ -30,12 +37,52 @@ namespace { const std::string REMOTE_DEV_ID = "f6d4c0864707aefte7a78f09473aa122ff57fc81c00981fcf5be989e7d112123"; const std::string DSCREEN_PKG_NAME_TEST = "ohos.dhardware.dscreen"; } +int32_t SoftbusAdapter::CreateSoftbusSessionServer(const std::string &pkgname, const std::string &sessionName, + const std::string &peerDevId) +{ + return g_mockCreateSoftbusSessionServerReturnInt32Value; +} + +int32_t SoftbusAdapter::RemoveSoftbusSessionServer(const std::string &pkgname, const std::string &sessionName, + const std::string &peerDevId) +{ + return g_mockRemoveSoftbusSessionServerReturnInt32Value; +} + +int32_t SoftbusAdapter::RegisterSoftbusListener(const std::shared_ptr &listener, + const std::string &sessionName, const std::string &peerDevId) +{ + return g_mockRegisterSoftbusListenerReturnInt32Value; +} + +int32_t SoftbusAdapter::UnRegisterSoftbusListener(const std::string &sessionName, const std::string &peerDevId) +{ + return g_mockUnRegisterSoftbusListenerReturnInt32Value; +} + +int32_t SoftbusAdapter::OpenSoftbusSession(const std::string &mySessionName, const std::string &peerSessionName, + const std::string &peerDevId) +{ + return g_mockOpenSoftbusSessionReturnInt32Value; +} + +int32_t SoftbusAdapter::CloseSoftbusSession(const int32_t sessionId) +{ + return g_mockCloseSoftbusSessionReturnInt32Value; +} + void ScreenDataChannelImplTest::SetUpTestCase(void) {} void ScreenDataChannelImplTest::TearDownTestCase(void) {} void ScreenDataChannelImplTest::SetUp(void) { + g_mockRegisterSoftbusListenerReturnInt32Value = -1; + g_mockCreateSoftbusSessionServerReturnInt32Value = -1; + g_mockRemoveSoftbusSessionServerReturnInt32Value = -1; + g_mockUnRegisterSoftbusListenerReturnInt32Value = -1; + g_mockOpenSoftbusSessionReturnInt32Value = -1; + g_mockCloseSoftbusSessionReturnInt32Value = -1; std::string peerDevId = "test"; dataChannelImpl_ = std::make_shared(peerDevId); } @@ -49,29 +96,6 @@ void ScreenDataChannelImplTest::TearDown(void) } } -void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId) -{ - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permsNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_basic", - }; - - infoInstance.processName = "DataChannelTest"; - tokenId = GetAccessTokenId(&infoInstance); - SetSelfTokenID(tokenId); - OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); -} - -void DisablePermissionAccess(const uint64_t &tokenId) -{ - OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId); -} - /** * @tc.name: CreateSession_001 * @tc.desc: Verify the CreateSession function. @@ -94,16 +118,33 @@ HWTEST_F(ScreenDataChannelImplTest, CreateSession_001, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, CreateSession_002, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); + g_mockCreateSoftbusSessionServerReturnInt32Value = DH_SUCCESS; + g_mockRegisterSoftbusListenerReturnInt32Value = DH_SUCCESS; std::shared_ptr listener = std::make_shared(); dataChannelImpl_->jpegSessionFlag_ = false; int32_t ret = dataChannelImpl_->CreateSession(listener); - DisablePermissionAccess(tokenId_); EXPECT_EQ(DH_SUCCESS, ret); + + dataChannelImpl_->jpegSessionFlag_ = true; + ret = dataChannelImpl_->CreateSession(listener); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: CreateSession_003 + * @tc.desc: Verify the CreateSession function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenDataChannelImplTest, CreateSession_003, TestSize.Level1) +{ + std::shared_ptr listener = std::make_shared(); + int32_t ret = dataChannelImpl_->CreateSession(listener); + EXPECT_NE(DH_SUCCESS, ret); + + g_mockCreateSoftbusSessionServerReturnInt32Value = DH_SUCCESS; + ret = dataChannelImpl_->CreateSession(listener); + EXPECT_NE(DH_SUCCESS, ret); } /** @@ -116,7 +157,20 @@ HWTEST_F(ScreenDataChannelImplTest, OpenSession_001, TestSize.Level1) { std::shared_ptr listener = std::make_shared(); int32_t ret = dataChannelImpl_->OpenSession(listener); - EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, ret); + EXPECT_NE(DH_SUCCESS, ret); + + g_mockRegisterSoftbusListenerReturnInt32Value = DH_SUCCESS; + ret = dataChannelImpl_->OpenSession(listener); + EXPECT_NE(DH_SUCCESS, ret); + + g_mockOpenSoftbusSessionReturnInt32Value = DH_SUCCESS; + dataChannelImpl_->jpegSessionFlag_ = true; + ret = dataChannelImpl_->OpenSession(listener); + EXPECT_EQ(DH_SUCCESS, ret); + + dataChannelImpl_->jpegSessionFlag_ = false; + ret = dataChannelImpl_->OpenSession(listener); + EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -193,13 +247,16 @@ HWTEST_F(ScreenDataChannelImplTest, SendDirtyData_002, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, release_session_test_001, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); + g_mockRemoveSoftbusSessionServerReturnInt32Value = DH_SUCCESS; + g_mockUnRegisterSoftbusListenerReturnInt32Value = DH_SUCCESS; + dataChannelImpl_->jpegSessionFlag_ = false; EXPECT_EQ(DH_SUCCESS, dataChannelImpl_->ReleaseSession()); - DisablePermissionAccess(tokenId_); + + dataChannelImpl_->jpegSessionFlag_ = true; + EXPECT_EQ(DH_SUCCESS, dataChannelImpl_->ReleaseSession()); + + g_mockUnRegisterSoftbusListenerReturnInt32Value = -1; + EXPECT_NE(DH_SUCCESS, dataChannelImpl_->ReleaseSession()); } /** @@ -210,8 +267,26 @@ HWTEST_F(ScreenDataChannelImplTest, release_session_test_001, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, close_session_test_001, TestSize.Level1) { + dataChannelImpl_->sessionId_ = 0; + EXPECT_EQ(ERR_DH_SCREEN_TRANS_SESSION_NOT_OPEN, dataChannelImpl_->CloseSession()); + + dataChannelImpl_->sessionId_ = 1; + dataChannelImpl_->jpegSessionFlag_ = true; + dataChannelImpl_->jpegSessionId_ = 1; + g_mockCloseSoftbusSessionReturnInt32Value = DH_SUCCESS; + EXPECT_EQ(DH_SUCCESS, dataChannelImpl_->CloseSession()); + dataChannelImpl_->sessionId_ = 1; + dataChannelImpl_->jpegSessionId_ = 0; EXPECT_EQ(DH_SUCCESS, dataChannelImpl_->CloseSession()); + + dataChannelImpl_->sessionId_ = 1; + dataChannelImpl_->jpegSessionFlag_ = false; + EXPECT_EQ(DH_SUCCESS, dataChannelImpl_->CloseSession()); + + dataChannelImpl_->sessionId_ = 1; + g_mockCloseSoftbusSessionReturnInt32Value = -1; + EXPECT_NE(DH_SUCCESS, dataChannelImpl_->CloseSession()); } /** @@ -222,8 +297,8 @@ HWTEST_F(ScreenDataChannelImplTest, close_session_test_001, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, close_session_test_002, TestSize.Level1) { - dataChannelImpl_->channelListener_ = std::make_shared(); - + std::shared_ptr listener = std::make_shared(); + dataChannelImpl_->channelListener_ = listener; StreamData ext = {0}; StreamFrameInfo *param = nullptr; @@ -300,7 +375,7 @@ HWTEST_F(ScreenDataChannelImplTest, send_data_test_003, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, on_session_opened_test_001, TestSize.Level1) { - std::shared_ptr listener = std::make_shared(); + std::shared_ptr listener = std::make_shared(); dataChannelImpl_->channelListener_ = listener; int32_t sessionId = 1; PeerSocketInfo peerSocketInfo = { @@ -321,8 +396,8 @@ HWTEST_F(ScreenDataChannelImplTest, on_session_opened_test_001, TestSize.Level1) */ HWTEST_F(ScreenDataChannelImplTest, on_session_opened_test_003, TestSize.Level1) { - std::shared_ptr mockListener = std::make_shared(); - dataChannelImpl_->channelListener_ = mockListener; + std::shared_ptr listener = std::make_shared(); + dataChannelImpl_->channelListener_ = listener; int32_t sessionId = 1; dataChannelImpl_->jpegSessionFlag_ = true; dataChannelImpl_->sessionId_ = 1; @@ -353,47 +428,57 @@ HWTEST_F(ScreenDataChannelImplTest, JsonToDirtyJson_001, TestSize.Level1) std::shared_ptr screenData = std::make_shared(10); nlohmann::json rectJson; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["dirtySize"] = 2; - dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["dirtySize"] = INT32_MAX + 1; + EXPECT_EQ(0, screenData->DataType()); + rectJson["dirtySize"] = DIRTY_MAX_SIZE - 1; rectJson["dataType"] = 2; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["dirtySize"] = DIRTY_MAX_SIZE; - rectJson["dataType"] = 2; - dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["dirtySize"] = 2; - rectJson["dataType"] = 2; + EXPECT_EQ(0, screenData->DataType()); rectJson["3"] = 2; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - + EXPECT_EQ(0, screenData->DataType()); nlohmann::json testJson; rectJson["0"] = testJson; - rectJson["0"][KEY_POINT_DIRTY_X] = INT32_MAX + 1; - rectJson["0"][KEY_POINT_DIRTY_Y] = INT32_MAX + 1; - rectJson["0"][KEY_POINT_DIRTY_W] = INT32_MAX + 1; - rectJson["0"][KEY_POINT_DIRTY_H] = INT32_MAX + 1; - rectJson["0"][KEY_POINT_DIRTY_SIZE] = INT32_MAX + 1; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["0"][KEY_POINT_DIRTY_SIZE] = 2; + EXPECT_EQ(0, screenData->DataType()); + rectJson["0"][KEY_POINT_DIRTY_X] = 100; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["0"][KEY_POINT_DIRTY_H] = 2; + EXPECT_EQ(0, screenData->DataType()); + rectJson["0"][KEY_POINT_DIRTY_Y] = 100; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["0"][KEY_POINT_DIRTY_W] = 2; + EXPECT_EQ(0, screenData->DataType()); + rectJson["0"][KEY_POINT_DIRTY_W] = 100; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["0"][KEY_POINT_DIRTY_Y] = 2; + EXPECT_EQ(0, screenData->DataType()); + rectJson["0"][KEY_POINT_DIRTY_H] = 100; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - - rectJson["0"][KEY_POINT_DIRTY_X] = 2; + EXPECT_EQ(0, screenData->DataType()); + rectJson["0"][KEY_POINT_DIRTY_SIZE] = 100; dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); - EXPECT_EQ(nullptr, dataChannelImpl_->channelListener_.lock()); + EXPECT_EQ(0, screenData->DataType()); + rectJson["dirtySize"] = DIRTY_MAX_SIZE; + dataChannelImpl_->JsonToDirtyJson(rectJson, screenData); + EXPECT_EQ(0, screenData->DataType()); +} + +/** + * @tc.name: ProcessDirtyData_001 + * @tc.desc: Verify the ProcessDirtyData function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenDataChannelImplTest, ProcessDirtyData_001, TestSize.Level1) +{ + StreamData data = {0}; + StreamData ext = {0}; + std::shared_ptr dataBuffer = std::make_shared(10); + dataChannelImpl_->ProcessDirtyData(&data, dataBuffer, &ext); + EXPECT_EQ(0, dataBuffer->DataType()); + + std::shared_ptr listener = std::make_shared(); + dataChannelImpl_->channelListener_ = listener; + data.bufLen = dataBuffer->Capacity() + 1; + dataChannelImpl_->ProcessDirtyData(&data, dataBuffer, &ext); + EXPECT_EQ(0, dataBuffer->DataType()); } /** diff --git a/services/screentransport/test/unittest/screensinktrans/src/screen_sink_trans_test.cpp b/services/screentransport/test/unittest/screensinktrans/src/screen_sink_trans_test.cpp index 51b6a590d7e1cf98efa813339433b62f2c158088..e293aae1246c194b6c2f29e92602bd4a02825390 100644 --- a/services/screentransport/test/unittest/screensinktrans/src/screen_sink_trans_test.cpp +++ b/services/screentransport/test/unittest/screensinktrans/src/screen_sink_trans_test.cpp @@ -95,9 +95,13 @@ HWTEST_F(ScreenSinkTransTest, register_processor_listener_001, TestSize.Level1) */ HWTEST_F(ScreenSinkTransTest, register_processor_listener_002, TestSize.Level1) { - trans_->imageProcessor_ = nullptr; + trans_->decoderSurface_ = nullptr; int32_t ret = trans_->RegisterProcessorListener(param_, param_, peerDevId_); EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret); + + trans_->imageProcessor_ = nullptr; + ret = trans_->RegisterProcessorListener(param_, param_, peerDevId_); + EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret); } /** @@ -196,9 +200,12 @@ HWTEST_F(ScreenSinkTransTest, set_image_surface_test_001, TestSize.Level1) HWTEST_F(ScreenSinkTransTest, set_image_surface_test_002, TestSize.Level1) { trans_->transCallback_ = std::make_shared(); + trans_->OnSessionOpened(); trans_->OnSessionClosed(); trans_->OnProcessorStateNotify(DH_SUCCESS); trans_->OnDataReceived(nullptr); + trans_->imageProcessor_ = nullptr; + trans_->OnDataReceived(nullptr); EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, trans_->SetImageSurface(nullptr)); } @@ -219,20 +226,35 @@ HWTEST_F(ScreenSinkTransTest, check_trans_param_test_001, TestSize.Level1) param_.videoFormat_ = VIDEO_DATA_FORMAT_INVALID; EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_)); + param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265; param_.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420; param_.videoWidth_ = WIDTH_INVALID; param_.videoHeight_ = HEIGHT_INVALID; + param_.screenWidth_ = WIDTH_INVALID; + param_.screenHeight_ = HEIGHT_INVALID; EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_)); + param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4; + param_.videoFormat_ = VIDEO_DATA_FORMAT_NV12; param_.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH; + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_)); + + param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4; + param_.videoFormat_ = VIDEO_DATA_FORMAT_NV21; param_.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT; - param_.screenWidth_ = WIDTH_INVALID; - param_.screenHeight_ = HEIGHT_INVALID; EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_)); + param_.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4; + param_.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888; param_.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH; + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, param_, peerDevId_)); + + VideoParam remoteParam = param_; + param_.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT; EXPECT_EQ(DH_SUCCESS, trans_->CheckTransParam(param_, param_, peerDevId_)); + + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, trans_->CheckTransParam(param_, remoteParam, peerDevId_)); } } // namespace DistributedHardware } // namespace OHOS diff --git a/services/screentransport/test/unittest/screensourceprocessor/BUILD.gn b/services/screentransport/test/unittest/screensourceprocessor/BUILD.gn index 5ad167a25d72c5e27503ec492a5574819036931a..0c94125c06926a5352426c67e4325db715ecd6a9 100644 --- a/services/screentransport/test/unittest/screensourceprocessor/BUILD.gn +++ b/services/screentransport/test/unittest/screensourceprocessor/BUILD.gn @@ -24,6 +24,8 @@ config("module_private_config") { "${services_path}/screentransport/test/unittest/screentranstestutils/include", "${common_path}/include", "${services_path}/common/databuffer/include", + "${services_path}/common/decision_center/include", + "${services_path}/common/imageJpeg/include", "${services_path}/common/screen_channel/include", "${services_path}/common/utils/include", "${services_path}/screentransport/test/unittest/screensourcetrans", 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 0d27e32103c293395d340f86f5e7b38daaef2df4..16e2150b10ffccc327b845afe57e215e492e7f03 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 Huawei Device Co., Ltd. + * Copyright (c) 2022-2024 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 @@ -14,6 +14,8 @@ */ #include "image_source_encoder_test.h" +#include "buffer/avsharedmemorybase.h" +#include "screen_source_trans.h" using namespace testing::ext; @@ -307,5 +309,79 @@ HWTEST_F(ImageSourceEncoderTest, SetEncoderFormat_007, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); } +/** + * @tc.name: FeedEncoderData_001 + * @tc.desc: Verify the FeedEncoderData function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ImageSourceEncoderTest, FeedEncoderData_001, TestSize.Level1) +{ + VideoParam configParam; + configParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264); + configParam.SetVideoWidth(DSCREEN_MAX_VIDEO_DATA_WIDTH); + configParam.SetVideoHeight(DSCREEN_MAX_VIDEO_DATA_HEIGHT); + int32_t ret = encoder->ConfigureEncoder(configParam); + ASSERT_EQ(DH_SUCCESS, ret); + + sptr buffer = SurfaceBuffer::Create(); + ret = encoder->FeedEncoderData(buffer); + EXPECT_NE(DH_SUCCESS, ret); +} + +/** + * @tc.name: OnOutputBufferAvailable_001 + * @tc.desc: Verify the OnOutputBufferAvailable function with various scenarios to cover all branches. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ImageSourceEncoderTest, OnOutputBufferAvailable_001, TestSize.Level1) +{ + encoder->videoEncoder_ = nullptr; + std::shared_ptr listener = nullptr; + encoder->imageProcessorListener_ = listener; + MediaAVCodec::AVCodecBufferInfo info; + MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE; + std::shared_ptr buffer = Media::AVSharedMemoryBase::CreateFromLocal(100, + Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer"); + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + encoder->OnError(MediaAVCodec::AVCODEC_ERROR_EXTEND_START, 0); + + std::shared_ptr trans = std::make_shared(); + encoder->imageProcessorListener_ = trans; + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); + + encoder->videoEncoder_ = MediaAVCodec::VideoEncoderFactory::CreateByMime( + std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC)); + buffer = nullptr; + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); + + info.size = 0; + buffer = Media::AVSharedMemoryBase::CreateFromLocal(100, + Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer"); + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); + + info.size = DATA_BUFFER_MAX_SIZE + 1; + buffer = Media::AVSharedMemoryBase::CreateFromLocal(100, + Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer"); + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); + + info.size = 100; + buffer = Media::AVSharedMemoryBase::CreateFromLocal(0, + Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer"); + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); + + info.size = 100; + buffer = Media::AVSharedMemoryBase::CreateFromLocal(100, + Media::AVSharedMemory::FLAGS_READ_WRITE, "userBuffer"); + encoder->videoEncoder_ = nullptr; + encoder->OnOutputBufferAvailable(0, info, flag, buffer); + EXPECT_EQ(trans->dataQueue_.size(), 0); +} } // DistributedHardware } // OHOS \ No newline at end of file diff --git a/services/screentransport/test/unittest/screensourcetrans/src/screen_source_trans_test.cpp b/services/screentransport/test/unittest/screensourcetrans/src/screen_source_trans_test.cpp index 4e940ad4dd94f8255f80583840392e1966b9cb2f..13274a92de2357e3adfbb249ef8305d058b9b072 100644 --- a/services/screentransport/test/unittest/screensourcetrans/src/screen_source_trans_test.cpp +++ b/services/screentransport/test/unittest/screensourcetrans/src/screen_source_trans_test.cpp @@ -15,8 +15,6 @@ #include "screen_source_trans_test.h" #include "screentrans_test_utils.h" -#include "accesstoken_kit.h" -#include "nativetoken_kit.h" #include "token_setproc.h" using namespace testing::ext; @@ -35,29 +33,6 @@ void ScreenSourceTransTest::SetUp(void) void ScreenSourceTransTest::TearDown(void) {} -void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId) -{ - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permsNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_basic", - }; - - infoInstance.processName = "SourceTransTest"; - tokenId = GetAccessTokenId(&infoInstance); - SetSelfTokenID(tokenId); - OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); -} - -void DisablePermissionAccess(const uint64_t &tokenId) -{ - OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId); -} - /** * @tc.name: RegisterChannelListener_001 * @tc.desc: Verify the RegisterChannelListener function. @@ -110,11 +85,6 @@ HWTEST_F(ScreenSourceTransTest, SetUp_001, TestSize.Level1) */ HWTEST_F(ScreenSourceTransTest, SetUp_002, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); VideoParam localParam; localParam.SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264); localParam.SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420); @@ -129,10 +99,7 @@ HWTEST_F(ScreenSourceTransTest, SetUp_002, TestSize.Level1) remoteParam.SetVideoWidth(VIDEO_DATA_NUM); remoteParam.SetScreenHeight(VIDEO_DATA_NUM); remoteParam.SetScreenWidth(VIDEO_DATA_NUM); - int32_t actual = trans->SetUp(localParam, remoteParam, "peerDevId"); - DisablePermissionAccess(tokenId_); - EXPECT_EQ(DH_SUCCESS, actual); } @@ -144,18 +111,11 @@ HWTEST_F(ScreenSourceTransTest, SetUp_002, TestSize.Level1) */ HWTEST_F(ScreenSourceTransTest, InitScreenTrans_001, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); VideoParam localParam; VideoParam remoteParam; std::string peerDevId = "sinkDevId"; trans->screenChannel_ = std::make_shared(); int32_t actual = trans->InitScreenTrans(localParam, remoteParam, peerDevId); - DisablePermissionAccess(tokenId_); - EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, actual); } @@ -167,19 +127,12 @@ HWTEST_F(ScreenSourceTransTest, InitScreenTrans_001, TestSize.Level1) */ HWTEST_F(ScreenSourceTransTest, InitScreenTrans_002, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); VideoParam localParam; VideoParam remoteParam; std::string peerDevId = "sinkDevId"; trans->SetScreenVersion("0"); trans->screenChannel_ = std::make_shared(); int32_t actual = trans->InitScreenTrans(localParam, remoteParam, peerDevId); - DisablePermissionAccess(tokenId_); - EXPECT_EQ(ERR_DH_SCREEN_CODEC_CONFIGURE_FAILED, actual); } @@ -346,7 +299,7 @@ HWTEST_F(ScreenSourceTransTest, CheckVideoParam_001, TestSize.Level1) } /** - * @tc.name: CheckVideoParam + * @tc.name: CheckVideoParam_002 * @tc.desc: Verify the CheckVideoParam function. * @tc.type: FUNC * @tc.require: Issue Number @@ -356,13 +309,107 @@ HWTEST_F(ScreenSourceTransTest, CheckVideoParam_002, TestSize.Level1) VideoParam localParam; localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264; localParam.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888 + 1; - VideoParam remoteParam; - std::string peerDevId; int32_t actual = trans->CheckVideoParam(localParam); EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); } +/** + * @tc.name: CheckVideoParam_003 + * @tc.desc: Verify the CheckVideoParam function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenSourceTransTest, CheckVideoParam_003, TestSize.Level1) +{ + VideoParam localParam; + localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H265; + localParam.videoFormat_ = VIDEO_DATA_FORMAT_YUVI420; + localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH + 1; + localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT; + int32_t actual = trans->CheckVideoParam(localParam); + + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); +} + +/** + * @tc.name: CheckVideoParam_004 + * @tc.desc: Verify the CheckVideoParam function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenSourceTransTest, CheckVideoParam_004, TestSize.Level1) +{ + VideoParam localParam; + localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_MPEG4; + localParam.videoFormat_ = VIDEO_DATA_FORMAT_NV12; + localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH; + localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT + 1; + int32_t actual = trans->CheckVideoParam(localParam); + + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); +} + +/** + * @tc.name: CheckVideoParam_005 + * @tc.desc: Verify the CheckVideoParam function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenSourceTransTest, CheckVideoParam_005, TestSize.Level1) +{ + VideoParam localParam; + localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264; + localParam.videoFormat_ = VIDEO_DATA_FORMAT_NV21; + localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH; + localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT; + localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH + 1; + localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT; + int32_t actual = trans->CheckVideoParam(localParam); + + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); +} + +/** + * @tc.name: CheckVideoParam_006 + * @tc.desc: Verify the CheckVideoParam function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenSourceTransTest, CheckVideoParam_006, TestSize.Level1) +{ + VideoParam localParam; + localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264; + localParam.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888; + localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH; + localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT; + localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH; + localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT + 1; + int32_t actual = trans->CheckVideoParam(localParam); + + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ILLEGAL_PARAM, actual); +} + +/** + * @tc.name: CheckVideoParam_007 + * @tc.desc: Verify the CheckVideoParam function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenSourceTransTest, CheckVideoParam_007, TestSize.Level1) +{ + VideoParam localParam; + localParam.codecType_ = VIDEO_CODEC_TYPE_VIDEO_H264; + localParam.videoFormat_ = VIDEO_DATA_FORMAT_RGBA8888; + localParam.videoWidth_ = DSCREEN_MAX_VIDEO_DATA_WIDTH; + localParam.videoHeight_ = DSCREEN_MAX_VIDEO_DATA_HEIGHT; + localParam.screenWidth_ = DSCREEN_MAX_SCREEN_DATA_WIDTH; + localParam.screenHeight_ = DSCREEN_MAX_SCREEN_DATA_HEIGHT; + int32_t actual = trans->CheckVideoParam(localParam); + + EXPECT_EQ(DH_SUCCESS, actual); +} + /** * @tc.name: CheckTransParam_001 * @tc.desc: Verify the CheckTransParam function. diff --git a/services/softbusadapter/test/unittest/include/softbus_adapter_test.h b/services/softbusadapter/test/unittest/include/softbus_adapter_test.h index 5ace873ba2b8067fc552cc3b893e8976ade44f40..9aefe78a5ce9290e56ae0c268186d89ac8985b24 100644 --- a/services/softbusadapter/test/unittest/include/softbus_adapter_test.h +++ b/services/softbusadapter/test/unittest/include/softbus_adapter_test.h @@ -37,7 +37,7 @@ public: void SetUp(); void TearDown(); - SoftbusAdapter softbusAdapter; + std::shared_ptr softbusAdapter_ = nullptr; uint64_t tokenId_; }; class MockSoftbusListener : public ISoftbusListener { diff --git a/services/softbusadapter/test/unittest/src/softbus_adapter_test.cpp b/services/softbusadapter/test/unittest/src/softbus_adapter_test.cpp index d7be3eec02148b1655436675f1fa99b829b9d1e4..331eeecddb348f292f0dc2b340c78665d4ac8352 100644 --- a/services/softbusadapter/test/unittest/src/softbus_adapter_test.cpp +++ b/services/softbusadapter/test/unittest/src/softbus_adapter_test.cpp @@ -14,12 +14,18 @@ */ #include "softbus_adapter_test.h" -#include "accesstoken_kit.h" -#include "nativetoken_kit.h" +#include "socket.h" +#include "softbus_adapter.h" #include "token_setproc.h" using namespace testing::ext; +static int g_mockBindReturnIntValue = 0; +static int g_mockListenReturnIntValue = 0; +static int g_mockSendBytesReturnIntValue = 0; +static int g_mockSendStreamReturnIntValue = 0; +static int g_mockSocketReturnIntValue = 0; + namespace OHOS { namespace DistributedHardware { namespace { @@ -31,31 +37,19 @@ void SoftbusAdapterTest::SetUpTestCase(void) {} void SoftbusAdapterTest::TearDownTestCase(void) {} -void SoftbusAdapterTest::SetUp(void) {} - -void SoftbusAdapterTest::TearDown(void) {} - -void EnablePermissionAccess(const char* perms[], size_t permsNum, uint64_t &tokenId) +void SoftbusAdapterTest::SetUp(void) { - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permsNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_basic", - }; - - infoInstance.processName = "SoftBusAdapterTest"; - tokenId = GetAccessTokenId(&infoInstance); - SetSelfTokenID(tokenId); - OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + g_mockBindReturnIntValue = 0; + g_mockListenReturnIntValue = 0; + g_mockSendBytesReturnIntValue = 0; + g_mockSendStreamReturnIntValue = 0; + g_mockSocketReturnIntValue = 0; + softbusAdapter_ = std::make_shared(); } -void DisablePermissionAccess(const uint64_t &tokenId) +void SoftbusAdapterTest::TearDown(void) { - OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(tokenId); + softbusAdapter_ = nullptr; } static void ScreenOnSoftbusSessionOpened(int32_t sessionId, PeerSocketInfo info) {} @@ -77,16 +71,11 @@ static void ScreenOnMessageReceived(int sessionId, const void *data, unsigned in */ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_001, TestSize.Level1) { - const char* perms[] = { - "ohos.permission.DISTRIBUTED_DATASYNC", - "ohos.permission.CAPTURE_SCREEN", - }; - EnablePermissionAccess(perms, sizeof(perms) / sizeof(perms[0]), tokenId_); - softbusAdapter.sessListener_.OnBind = ScreenOnSoftbusSessionOpened; - softbusAdapter.sessListener_.OnShutdown = ScreenOnSoftbusSessionClosed; - softbusAdapter.sessListener_.OnBytes = ScreenOnBytesReceived; - softbusAdapter.sessListener_.OnStream = ScreenOnStreamReceived; - softbusAdapter.sessListener_.OnMessage = ScreenOnMessageReceived; + softbusAdapter_->sessListener_.OnBind = ScreenOnSoftbusSessionOpened; + softbusAdapter_->sessListener_.OnShutdown = ScreenOnSoftbusSessionClosed; + softbusAdapter_->sessListener_.OnBytes = ScreenOnBytesReceived; + softbusAdapter_->sessListener_.OnStream = ScreenOnStreamReceived; + softbusAdapter_->sessListener_.OnMessage = ScreenOnMessageReceived; std::string pkgname = PKG_NAME; std::string sessionName = DATA_SESSION_NAME; @@ -100,24 +89,30 @@ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_001, TestSize.Level1) StreamData *streamData = nullptr; StreamData *ext = nullptr; StreamFrameInfo *frameInfo = nullptr; - softbusAdapter.OnBytesReceived(sessionId, data, dataLen); - softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo); + softbusAdapter_->OnBytesReceived(sessionId, data, dataLen); + softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo); data = reinterpret_cast(&dataLen); streamData = &sData; - softbusAdapter.OnBytesReceived(sessionId, data, dataLen); - softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo); + softbusAdapter_->OnBytesReceived(sessionId, data, dataLen); + softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo); dataLen = DSCREEN_MAX_RECV_DATA_LEN + 1; sData.bufLen = DSCREEN_MAX_RECV_DATA_LEN + 1; - softbusAdapter.OnBytesReceived(sessionId, data, dataLen); - softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo); + softbusAdapter_->OnBytesReceived(sessionId, data, dataLen); + softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo); dataLen = 100; sData.bufLen = 100; - softbusAdapter.OnBytesReceived(sessionId, data, dataLen); - softbusAdapter.OnStreamReceived(sessionId, streamData, ext, frameInfo); - int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgname, sessionName, peerDevId); + softbusAdapter_->OnBytesReceived(sessionId, data, dataLen); + softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo); + + std::shared_ptr listener = std::make_shared(); + softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey"; + softbusAdapter_->mapListeners_["strListenerKey"] = listener; + softbusAdapter_->OnBytesReceived(sessionId, data, dataLen); + softbusAdapter_->OnStreamReceived(sessionId, streamData, ext, frameInfo); + + int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgname, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); - softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); - DisablePermissionAccess(tokenId_); + softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); } /** @@ -128,14 +123,12 @@ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_001, TestSize.Level1) */ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_002, TestSize.Level1) { - softbusAdapter.serverIdMap_.clear(); std::string pkgname = PKG_NAME; std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "peerDevId"; - - int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgname, sessionName, peerDevId); + int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgname, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); - softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); + softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); } /** @@ -149,9 +142,8 @@ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_003, TestSize.Level1) std::string pkgName = "ohos.dhardware.dscreentest"; std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "peerDevId"; - softbusAdapter.serverIdMap_.clear(); - softbusAdapter.serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId)); - int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgName, sessionName, peerDevId); + softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId)); + int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); } @@ -163,13 +155,19 @@ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_003, TestSize.Level1) */ HWTEST_F(SoftbusAdapterTest, CreateSoftbusSessionServer_004, TestSize.Level1) { - std::string pkgName = "ohos.dhardware.dscreentest"; + std::string pkgName = PKG_NAME; std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "peerDevId"; - softbusAdapter.serverIdMap_.clear(); - softbusAdapter.serverIdMap_.insert(std::make_pair(100000, sessionName + "__" + peerDevId)); - int32_t actual = softbusAdapter.CreateSoftbusSessionServer(pkgName, sessionName, peerDevId); + g_mockListenReturnIntValue = -1; + softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, "test")); + int32_t actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId); + EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_BAD_VALUE, actual); + + softbusAdapter_->serverIdMap_.clear(); + g_mockSocketReturnIntValue = -1; + actual = softbusAdapter_->CreateSoftbusSessionServer(pkgName, sessionName, peerDevId); EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_BAD_VALUE, actual); + softbusAdapter_->RemoveSoftbusSessionServer(pkgName, sessionName, peerDevId); } /** @@ -184,10 +182,10 @@ HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_001, TestSize.Level1) std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "testDevId"; - int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId); + int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); - actual = softbusAdapter.UnRegisterSoftbusListener(sessionName, peerDevId); + actual = softbusAdapter_->UnRegisterSoftbusListener(sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); } @@ -203,10 +201,10 @@ HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_002, TestSize.Level1) std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "testDevId"; - int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId); + int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); - actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId); + actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId); EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual); } @@ -222,7 +220,7 @@ HWTEST_F(SoftbusAdapterTest, RegisterSoftbusListener_003, TestSize.Level1) std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "testDevId"; - int32_t actual = softbusAdapter.RegisterSoftbusListener(listener, sessionName, peerDevId); + int32_t actual = softbusAdapter_->RegisterSoftbusListener(listener, sessionName, peerDevId); EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_REGISTER_SOFTBUS_LISTENER_FAIL, actual); } @@ -237,7 +235,7 @@ HWTEST_F(SoftbusAdapterTest, UnRegisterSoftbusListener_001, TestSize.Level1) std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "testDevId"; - int32_t actual = softbusAdapter.UnRegisterSoftbusListener(sessionName, peerDevId); + int32_t actual = softbusAdapter_->UnRegisterSoftbusListener(sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); } @@ -254,8 +252,11 @@ HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_001, TestSize.Level1) std::string sessionName = ""; std::string peerDevId = ""; - int32_t actual = softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); + int32_t actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); + EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual); + sessionName = "sessionName"; + actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, actual); } @@ -271,7 +272,7 @@ HWTEST_F(SoftbusAdapterTest, RemoveSoftbusSessionServer_002, TestSize.Level1) std::string sessionName = DATA_SESSION_NAME; std::string peerDevId = "peerDevId"; - int32_t actual = softbusAdapter.RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); + int32_t actual = softbusAdapter_->RemoveSoftbusSessionServer(pkgname, sessionName, peerDevId); EXPECT_EQ(DH_SUCCESS, actual); } @@ -286,7 +287,15 @@ HWTEST_F(SoftbusAdapterTest, OpenSoftbusSession_001, TestSize.Level1) std::string mySessionName = DATA_SESSION_NAME; std::string peerSessionName = DATA_SESSION_NAME; std::string peerDevId = "testDevId"; - int32_t actual = softbusAdapter.OpenSoftbusSession(mySessionName, peerSessionName, peerDevId); + int32_t actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId); + EXPECT_NE(DH_SUCCESS, actual); + + g_mockBindReturnIntValue = -1; + actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId); + EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_PARA_ERROR, actual); + + g_mockSocketReturnIntValue = -1; + actual = softbusAdapter_->OpenSoftbusSession(mySessionName, peerSessionName, peerDevId); EXPECT_EQ(ERR_DH_SCREEN_ADAPTER_PARA_ERROR, actual); } @@ -298,7 +307,7 @@ HWTEST_F(SoftbusAdapterTest, OpenSoftbusSession_001, TestSize.Level1) */ HWTEST_F(SoftbusAdapterTest, CloseSoftbusSession_001, TestSize.Level1) { - int32_t actual = softbusAdapter.CloseSoftbusSession(0); + int32_t actual = softbusAdapter_->CloseSoftbusSession(0); EXPECT_EQ(DH_SUCCESS, actual); } @@ -313,7 +322,11 @@ HWTEST_F(SoftbusAdapterTest, SendSoftbusBytes_001, TestSize.Level1) int32_t sessionId = 0; void *data = nullptr; int32_t dataLen = 0; - int32_t actual = softbusAdapter.SendSoftbusBytes(sessionId, data, dataLen); + int32_t actual = softbusAdapter_->SendSoftbusBytes(sessionId, data, dataLen); + EXPECT_EQ(DH_SUCCESS, actual); + + g_mockSendBytesReturnIntValue = -1; + actual = softbusAdapter_->SendSoftbusBytes(sessionId, data, dataLen); EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual); } @@ -329,35 +342,82 @@ HWTEST_F(SoftbusAdapterTest, SendSoftbusStream_001, TestSize.Level1) StreamData *data = nullptr; StreamData *ext = nullptr; StreamFrameInfo *param = nullptr; - int32_t actual = softbusAdapter.SendSoftbusStream(sessionId, data, ext, param); + int32_t actual = softbusAdapter_->SendSoftbusStream(sessionId, data, ext, param); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: OnSoftbusSessionOpened_001 + * @tc.desc: Verify the OnSoftbusSessionOpened function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1) +{ + PeerSocketInfo peerSocketInfo = { + .name = const_cast(PEER_SESSION_NAME.c_str()), + .networkId = const_cast(REMOTE_DEV_ID.c_str()), + .pkgName = const_cast(DSCREEN_PKG_NAME_TEST.c_str()), + .dataType = DATA_TYPE_BYTES + }; + int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo); EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual); } /** - * @tc.name: GetSoftbusListener_001 - * @tc.desc: Verify the GetSoftbusListener function. + * @tc.name: OnSoftbusSessionOpened_002 + * @tc.desc: Verify the OnSoftbusSessionOpened function. * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(SoftbusAdapterTest, GetSoftbusListener_001, TestSize.Level1) +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_002, TestSize.Level1) { + PeerSocketInfo peerSocketInfo = { + .name = const_cast(PEER_SESSION_NAME.c_str()), + .networkId = nullptr, + .pkgName = const_cast(DSCREEN_PKG_NAME_TEST.c_str()), + .dataType = DATA_TYPE_BYTES + }; + std::string pkgName = "ohos.dhardware.dscreentest"; + std::string sessionName = DATA_SESSION_NAME; + std::string peerDevId = "peerDevId"; + softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, sessionName + "_" + peerDevId)); + int32_t sessionId = 0; - SessionInfo sessionInfo; - sessionInfo.sessionName = "hello"; - sessionInfo.peerDevId = "world"; - std::shared_ptr listener = nullptr; - softbusAdapter.mapListeners_["hello_world"] = listener; - std::shared_ptr actual = softbusAdapter.GetSoftbusListenerById(sessionId); - EXPECT_EQ(nullptr, actual); + std::shared_ptr listener = std::make_shared(); + softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey"; + softbusAdapter_->mapListeners_["strListenerKey"] = listener; + + int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(sessionId, peerSocketInfo); + EXPECT_EQ(DH_SUCCESS, actual); } /** - * @tc.name: OnSoftbusSessionOpened_001 + * @tc.name: OnSoftbusSessionOpened_003 * @tc.desc: Verify the OnSoftbusSessionOpened function. * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1) +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_003, TestSize.Level1) +{ + PeerSocketInfo peerSocketInfo = { + .name = const_cast(PEER_SESSION_NAME.c_str()), + .networkId = const_cast(REMOTE_DEV_ID.c_str()), + .pkgName = const_cast(DSCREEN_PKG_NAME_TEST.c_str()), + .dataType = DATA_TYPE_BYTES + }; + softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, REMOTE_DEV_ID)); + int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo); + EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual); +} + +/** + * @tc.name: OnSoftbusSessionOpened_004 + * @tc.desc: Verify the OnSoftbusSessionOpened function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_004, TestSize.Level1) { PeerSocketInfo peerSocketInfo = { .name = const_cast(PEER_SESSION_NAME.c_str()), @@ -365,10 +425,86 @@ HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1) .pkgName = const_cast(DSCREEN_PKG_NAME_TEST.c_str()), .dataType = DATA_TYPE_BYTES }; - int32_t actual = softbusAdapter.OnSoftbusSessionOpened(0, peerSocketInfo); + softbusAdapter_->serverIdMap_.insert(std::make_pair(100000, "not exist id")); + int32_t actual = softbusAdapter_->OnSoftbusSessionOpened(0, peerSocketInfo); EXPECT_EQ(ERR_DH_SCREEN_TRANS_ERROR, actual); } +/** + * @tc.name: OnSoftbusSessionClosed_001 + * @tc.desc: Verify the OnSoftbusSessionClosed function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionClosed_001, TestSize.Level1) +{ + int32_t sessionId = 0; + ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN; + softbusAdapter_->mapSessListeners_[sessionId] = nullptr; + softbusAdapter_->OnSoftbusSessionClosed(sessionId, reason); + EXPECT_TRUE(softbusAdapter_->mapSessListeners_.size() > 0); +} + +/** + * @tc.name: OnSoftbusSessionClosed_002 + * @tc.desc: Verify the OnSoftbusSessionClosed function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionClosed_002, TestSize.Level1) +{ + int32_t sessionId = 0; + ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN; + std::shared_ptr listener = std::make_shared(); + softbusAdapter_->mapSessListeners_[sessionId] = listener; + softbusAdapter_->OnSoftbusSessionClosed(sessionId, reason); + EXPECT_TRUE(softbusAdapter_->mapSessListeners_.size() == 0); +} + +/** + * @tc.name: GetSoftbusListenerByName_001 + * @tc.desc: Verify the GetSoftbusListenerByName function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_001, TestSize.Level1) +{ + int32_t sessionId = 0; + softbusAdapter_->devId2SessIdMap_[sessionId] = "test"; + std::shared_ptr listener = softbusAdapter_->GetSoftbusListenerByName(sessionId); + EXPECT_EQ(nullptr, listener); +} + +/** + * @tc.name: GetSoftbusListenerByName_002 + * @tc.desc: Verify the GetSoftbusListenerByName function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_002, TestSize.Level1) +{ + int32_t sessionId = 0; + softbusAdapter_->devId2SessIdMap_[sessionId + 1] = "test"; + std::shared_ptr listener = softbusAdapter_->GetSoftbusListenerByName(sessionId); + EXPECT_EQ(nullptr, listener); +} + +/** + * @tc.name: GetSoftbusListenerByName_003 + * @tc.desc: Verify the GetSoftbusListenerByName function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerByName_003, TestSize.Level1) +{ + int32_t sessionId = 0; + std::shared_ptr listener = std::make_shared(); + softbusAdapter_->devId2SessIdMap_[sessionId] = "strListenerKey"; + softbusAdapter_->mapListeners_["strListenerKey"] = listener; + std::shared_ptr mapListener = softbusAdapter_->GetSoftbusListenerByName(sessionId); + EXPECT_NE(nullptr, mapListener); +} + /** * @tc.name: GetSoftbusListenerById_001 * @tc.desc: Verify the GetSoftbusListenerById function. @@ -378,9 +514,57 @@ HWTEST_F(SoftbusAdapterTest, OnSoftbusSessionOpened_001, TestSize.Level1) HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerById_001, TestSize.Level1) { int32_t sessionId = 0; - softbusAdapter.mapSessListeners_[sessionId] = nullptr; - std::shared_ptr listener = softbusAdapter.GetSoftbusListenerById(sessionId); + softbusAdapter_->mapSessListeners_[sessionId] = nullptr; + std::shared_ptr listener = softbusAdapter_->GetSoftbusListenerById(sessionId); EXPECT_EQ(nullptr, listener); } + +/** + * @tc.name: GetSoftbusListenerById_002 + * @tc.desc: Verify the GetSoftbusListenerById function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(SoftbusAdapterTest, GetSoftbusListenerById_002, TestSize.Level1) +{ + int32_t sessionId = 0; + SessionInfo sessionInfo; + sessionInfo.sessionName = "hello"; + sessionInfo.peerDevId = "world"; + std::shared_ptr listener = nullptr; + softbusAdapter_->mapListeners_["hello_world"] = listener; + std::shared_ptr actual = softbusAdapter_->GetSoftbusListenerById(sessionId); + EXPECT_EQ(nullptr, actual); +} } // DistributedHardware -} // OHOS \ No newline at end of file +} // OHOS + +extern "C" __attribute__((constructor)) int Socket(SocketInfo info) +{ + return g_mockSocketReturnIntValue; +} + +extern "C" __attribute__((constructor)) int Bind(int32_t socket, const QosTV qos[], uint32_t qosCount, + const ISocketListener *listener) +{ + return g_mockBindReturnIntValue; +} + +extern "C" __attribute__((constructor)) int Listen(int32_t socket, const QosTV qos[], uint32_t qosCount, + const ISocketListener *listener) +{ + return g_mockListenReturnIntValue; +} + +extern "C" __attribute__((constructor)) int SendBytes(int32_t socket, const void *data, uint32_t len) +{ + return g_mockSendBytesReturnIntValue; +} + +extern "C" __attribute__((constructor)) void Shutdown(int32_t socket) {} + +extern "C" __attribute__((constructor)) int SendStream(int32_t socket, const StreamData *data, const StreamData *ext, + const StreamFrameInfo *param) +{ + return g_mockSendStreamReturnIntValue; +}