From 2fc89f4982b901392801728f9e6676e8678cc3d3 Mon Sep 17 00:00:00 2001 From: gaoqiang_strong Date: Thu, 17 Oct 2024 10:14:48 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A7=A3=E5=86=B3=E5=B7=AE=E5=BC=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gaoqiang_strong --- .../src/authentication/dm_auth_manager.cpp | 118 +++++++++++------- .../UTTest_device_manager_service.cpp | 109 ++++++++++++++-- 2 files changed, 174 insertions(+), 53 deletions(-) diff --git a/services/implementation/src/authentication/dm_auth_manager.cpp b/services/implementation/src/authentication/dm_auth_manager.cpp index 715e23cb3..b67fa0b2d 100644 --- a/services/implementation/src/authentication/dm_auth_manager.cpp +++ b/services/implementation/src/authentication/dm_auth_manager.cpp @@ -744,10 +744,12 @@ void DmAuthManager::StartNegotiate(const int32_t &sessionId) authMessageProcessor_->SetResponseContext(authResponseContext_); std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_NEGOTIATE); softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); - timer_->StartTimer(std::string(NEGOTIATE_TIMEOUT_TASK), - GetTaskTimeout(NEGOTIATE_TIMEOUT_TASK, NEGOTIATE_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(NEGOTIATE_TIMEOUT_TASK), + GetTaskTimeout(NEGOTIATE_TIMEOUT_TASK, NEGOTIATE_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } } void DmAuthManager::AbilityNegotiate() @@ -807,10 +809,12 @@ void DmAuthManager::RespNegotiate(const int32_t &sessionId) } else { ProRespNegotiate(sessionId); } - timer_->StartTimer(std::string(WAIT_REQUEST_TIMEOUT_TASK), - GetTaskTimeout(WAIT_REQUEST_TIMEOUT_TASK, WAIT_REQUEST_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(WAIT_REQUEST_TIMEOUT_TASK), + GetTaskTimeout(WAIT_REQUEST_TIMEOUT_TASK, WAIT_REQUEST_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } } void DmAuthManager::SendAuthRequest(const int32_t &sessionId) @@ -863,10 +867,12 @@ void DmAuthManager::ProcessAuthRequest(const int32_t &sessionId) listener_->OnAuthResult(authResponseContext_->hostPkgName, peerTargetId_.deviceId, authRequestContext_->token, STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK); listener_->OnBindResult(authResponseContext_->hostPkgName, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, ""); - timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK), - GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK), + GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } } void DmAuthManager::GetAuthRequestContext() @@ -937,10 +943,12 @@ void DmAuthManager::ProcessAuthRequestExt(const int32_t &sessionId) listener_->OnAuthResult(authResponseContext_->hostPkgName, peerTargetId_.deviceId, authRequestContext_->token, STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK); listener_->OnBindResult(authResponseContext_->hostPkgName, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, ""); - timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK), - GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK), + GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } } int32_t DmAuthManager::ConfirmProcess(const int32_t &action) @@ -1030,14 +1038,16 @@ void DmAuthManager::StartRespAuthProcess() action_ = USER_OPERATION_TYPE_ALLOW_AUTH; } if (authResponseContext_->reply == USER_OPERATION_TYPE_ALLOW_AUTH) { - timer_->StartTimer(std::string(INPUT_TIMEOUT_TASK), - GetTaskTimeout(INPUT_TIMEOUT_TASK, INPUT_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); - timer_->StartTimer(std::string(SESSION_HEARTBEAT_TIMEOUT_TASK), - GetTaskTimeout(SESSION_HEARTBEAT_TIMEOUT_TASK, SESSION_HEARTBEAT_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleSessionHeartbeat(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(INPUT_TIMEOUT_TASK), + GetTaskTimeout(INPUT_TIMEOUT_TASK, INPUT_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + timer_->StartTimer(std::string(SESSION_HEARTBEAT_TIMEOUT_TASK), + GetTaskTimeout(SESSION_HEARTBEAT_TIMEOUT_TASK, SESSION_HEARTBEAT_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleSessionHeartbeat(name); + }); + } listener_->OnAuthResult(authRequestContext_->hostPkgName, peerTargetId_.deviceId, authRequestContext_->token, STATUS_DM_SHOW_PIN_INPUT_UI, DM_OK); listener_->OnBindResult(authRequestContext_->hostPkgName, peerTargetId_, DM_OK, @@ -1079,10 +1089,12 @@ int32_t DmAuthManager::AddMember(int32_t pinCode) jsonObject[TAG_REQUEST_ID] = authResponseContext_->requestId; jsonObject[TAG_DEVICE_ID] = authResponseContext_->deviceId; std::string connectInfo = jsonObject.dump(); - timer_->StartTimer(std::string(ADD_TIMEOUT_TASK), - GetTaskTimeout(ADD_TIMEOUT_TASK, ADD_TIMEOUT), [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(ADD_TIMEOUT_TASK), + GetTaskTimeout(ADD_TIMEOUT_TASK, ADD_TIMEOUT), [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } if (authUiStateMgr_ == nullptr) { LOGE("DmAuthManager::AddMember authUiStateMgr is null."); return ERR_DM_FAILED; @@ -1128,7 +1140,9 @@ int32_t DmAuthManager::JoinNetwork() return ERR_DM_FAILED; } LOGI("DmAuthManager JoinNetwork start"); - timer_->DeleteTimer(std::string(AUTHENTICATE_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(AUTHENTICATE_TIMEOUT_TASK)); + } authResponseContext_->state = AuthState::AUTH_REQUEST_FINISH; authResponseContext_->isFinish = true; authRequestContext_->reason = DM_OK; @@ -1202,7 +1216,9 @@ void DmAuthManager::AuthenticateFinish() } else if (authRequestState_ != nullptr) { SrcAuthenticateFinish(); } - timer_->DeleteAll(); + if (timer_ != nullptr) { + timer_->DeleteAll(); + } isFinishOfLocal_ = true; authResponseContext_ = nullptr; authMessageProcessor_ = nullptr; @@ -1416,7 +1432,9 @@ int32_t DmAuthManager::ProcessPincode(int32_t pinCode) LOGE("failed to ProcessPincode because authResponseContext_ is nullptr"); return ERR_DM_FAILED; } - timer_->DeleteTimer(std::string(INPUT_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(INPUT_TIMEOUT_TASK)); + } if (authResponseContext_->dmVersion == DM_NEW_VERSION && authResponseContext_->bindLevel != INVALIED_TYPE) { return AuthDevice(pinCode); } else { @@ -1434,10 +1452,12 @@ int32_t DmAuthManager::AuthDevice(int32_t pinCode) } isAuthDevice_ = true; int32_t osAccountId = MultipleUserConnector::GetCurrentAccountUserID(); - timer_->StartTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK), AUTH_DEVICE_TIMEOUT, - [this] (std::string name) { - DmAuthManager::HandleAuthenticateTimeout(name); - }); + if (timer_ != nullptr) { + timer_->StartTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK), AUTH_DEVICE_TIMEOUT, + [this] (std::string name) { + DmAuthManager::HandleAuthenticateTimeout(name); + }); + } if (hiChainAuthConnector_->AuthDevice(pinCode, osAccountId, remoteDeviceId_, authResponseContext_->requestId) != DM_OK) { LOGE("DmAuthManager::AuthDevice failed."); @@ -1813,7 +1833,9 @@ void DmAuthManager::RequestCredentialDone() if (ImportCredential(remoteDeviceId_, authResponseContext_->publicKey) != DM_OK) { LOGE("ResponseCredential import credential failed."); } - timer_->DeleteTimer(std::string(AUTHENTICATE_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(AUTHENTICATE_TIMEOUT_TASK)); + } softbusConnector_->JoinLnn(authRequestContext_->ip); authResponseContext_->state = AuthState::AUTH_REQUEST_FINISH; authRequestContext_->reason = DM_OK; @@ -1878,7 +1900,9 @@ void DmAuthManager::SrcSyncDeleteAclDone() DeleteAcl(authRequestContext_->hostPkgName, remoteDeviceId_); } softbusConnector_->GetSoftbusSession()->CloseUnbindSession(authRequestContext_->sessionId); - timer_->DeleteAll(); + if (timer_ != nullptr) { + timer_->DeleteAll(); + } isFinishOfLocal_ = true; authRequestContext_ = nullptr; authResponseContext_ = nullptr; @@ -1904,7 +1928,9 @@ void DmAuthManager::SinkSyncDeleteAclDone() DeleteAcl(authResponseContext_->hostPkgName, remoteDeviceId_); } } - timer_->DeleteAll(); + if (timer_ != nullptr) { + timer_->DeleteAll(); + } isFinishOfLocal_ = true; authResponseContext_ = nullptr; authResponseState_ = nullptr; @@ -1937,7 +1963,9 @@ void DmAuthManager::ResponseCredential() void DmAuthManager::ResponseSyncDeleteAcl() { LOGI("ResponseSyncDeleteAcl start."); - timer_->DeleteTimer(std::string(SYNC_DELETE_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(SYNC_DELETE_TIMEOUT_TASK)); + } remoteDeviceId_ = authResponseContext_->localDeviceId; authResponseState_->TransitionTo(std::make_shared()); } @@ -2028,7 +2056,9 @@ void DmAuthManager::AuthDeviceFinish(int64_t requestId) return; } isAuthDevice_ = false; - timer_->DeleteTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK)); + } if (authRequestState_ != nullptr && authResponseState_ == nullptr) { PutAccessControlList(); SrcAuthDeviceFinish(); @@ -2053,7 +2083,9 @@ void DmAuthManager::AuthDeviceError(int64_t requestId, int32_t errorCode) return; } authTimes_++; - timer_->DeleteTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(AUTH_DEVICE_TIMEOUT_TASK)); + } if (errorCode != DM_OK || requestId != authResponseContext_->requestId) { if (authRequestState_ != nullptr && authTimes_ >= MAX_AUTH_TIMES) { authResponseContext_->state = AuthState::AUTH_REQUEST_JOIN; @@ -2463,7 +2495,9 @@ void DmAuthManager::PutAccessControlList() void DmAuthManager::HandleSessionHeartbeat(std::string name) { - timer_->DeleteTimer(std::string(SESSION_HEARTBEAT_TIMEOUT_TASK)); + if (timer_ != nullptr) { + timer_->DeleteTimer(std::string(SESSION_HEARTBEAT_TIMEOUT_TASK)); + } LOGI("DmAuthManager::HandleSessionHeartbeat name %{public}s", name.c_str()); nlohmann::json jsonObj; jsonObj[TAG_SESSION_HEARTBEAT] = TAG_SESSION_HEARTBEAT; diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp index b6cf66480..7e6c6a530 100644 --- a/test/unittest/UTTest_device_manager_service.cpp +++ b/test/unittest/UTTest_device_manager_service.cpp @@ -102,6 +102,7 @@ HWTEST_F(DeviceManagerServiceTest, InitDMServiceListener_001, testing::ext::Test { int ret = DeviceManagerService::GetInstance().InitDMServiceListener(); EXPECT_EQ(ret, DM_OK); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } /** @@ -150,6 +151,7 @@ HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestS DeviceManagerService::GetInstance().InitDMServiceListener(); int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } /** @@ -164,7 +166,8 @@ HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSi uint16_t subscribeId = 1; DeviceManagerService::GetInstance().InitDMServiceListener(); int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } /** @@ -181,6 +184,21 @@ HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSi EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } +/** + * @tc.name:StopDeviceDiscovery_003 + * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0) +{ + DeletePermission(); + std::string pkgName = "StopDeviceDiscovery_003"; + uint16_t subscribeId = 1; + int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + /** * @tc.name: PublishDeviceDiscovery_001 * @tc.desc: Publish device discovery and return ERR_DM_NO_PERMISSION @@ -229,7 +247,26 @@ HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_003, testing::ext::Tes int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); pkgName = "1com.ohos.test1"; ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); +} + +/** + * @tc.name: PublishDeviceDiscovery_004 + * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return + * SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM + * @tc.type: FUNC + * @tc.require: I5N1K3 + */ +HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "PublishDeviceDiscovery_004"; + DmPublishInfo publishInfo; + DeviceManagerService::GetInstance().InitDMServiceListener(); + int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); + pkgName = "1com.ohos.test1"; + ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } /** @@ -243,7 +280,7 @@ HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::T std::string pkgName = "com.ohos.test"; int32_t publishId = 1; int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); } /** @@ -259,6 +296,23 @@ HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_002, testing::ext::T DeviceManagerService::GetInstance().InitDMServiceListener(); int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + DeviceManagerService::GetInstance().UninitDMServiceListener(); +} + +/** + * @tc.name: UnPublishDeviceDiscovery_003 + * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID + * @tc.type: FUNC + * @tc.require: I5N1K3 + */ +HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test003"; + int32_t publishId = 1; + DeviceManagerService::GetInstance().InitDMServiceListener(); + int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } /** @@ -291,6 +345,25 @@ HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_002, testing::ext::TestS EXPECT_EQ(ret, ERR_DM_POINT_NULL); } +/** + * @tc.name: GetTrustedDeviceList_003 + * @tc.desc:Set the intFlag of GetTrustedDeviceList to true; Return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "ohos_test"; + std::string extra = "jdddd"; + std::vector deviceList; + DeviceManagerService::GetInstance().softbusListener_ = std::make_shared(); + DeviceManagerService::GetInstance().InitDMServiceListener(); + int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); + EXPECT_EQ(ret, DM_OK); + DeviceManagerService::GetInstance().UninitDMServiceListener(); + DeviceManagerService::GetInstance().softbusListener_ = nullptr; +} + /** * @tc.name: ShiftLNNGear_001 * @tc.desc:Set the pkgName to null, callerId not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID @@ -409,11 +482,12 @@ HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_005, testing::ext::TestSize.Leve */ HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_006, testing::ext::TestSize.Level0) { - std::string pkgName = "com.ohos.test"; - std::string callerId = "com.ohos.test"; + std::string pkgName = "ShiftLNNGear_006"; + std::string callerId = "ShiftLNNGear_006"; bool isRefresh = true; + DeviceManagerService::GetInstance().softbusListener_ = nullptr; int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); - EXPECT_NE(ret, DM_OK); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); } /** @@ -1576,8 +1650,9 @@ HWTEST_F(DeviceManagerServiceTest, StartDiscovering_003, testing::ext::TestSize. std::map filterOptions; DeviceManagerService::GetInstance().InitDMServiceListener(); int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL); DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } HWTEST_F(DeviceManagerServiceTest, StartDiscovering_004, testing::ext::TestSize.Level0) @@ -1593,8 +1668,9 @@ HWTEST_F(DeviceManagerServiceTest, StartDiscovering_004, testing::ext::TestSize. std::map filterOptions; DeviceManagerService::GetInstance().InitDMServiceListener(); int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL); DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } HWTEST_F(DeviceManagerServiceTest, StopDiscovering_001, testing::ext::TestSize.Level0) @@ -1621,6 +1697,7 @@ HWTEST_F(DeviceManagerServiceTest, StopDiscovering_003, testing::ext::TestSize.L DeviceManagerService::GetInstance().InitDMServiceListener(); int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); EXPECT_NE(ret, DM_OK); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_001, testing::ext::TestSize.Level0) @@ -1673,7 +1750,7 @@ HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_003, testing::ext::T std::string pkgName = "pkgName"; std::map extraParam; int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); } HWTEST_F(DeviceManagerServiceTest, StartAdvertising_001, testing::ext::TestSize.Level0) @@ -1728,7 +1805,17 @@ HWTEST_F(DeviceManagerServiceTest, StopAdvertising_003, testing::ext::TestSize.L std::string pkgName = "pkgName"; std::map advertiseParam; int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); - EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); +} + +HWTEST_F(DeviceManagerServiceTest, StopAdvertising_004, testing::ext::TestSize.Level0) +{ + std::string pkgName = "StopAdvertising_004"; + std::map advertiseParam; + DeviceManagerService::GetInstance().InitDMServiceListener(); + int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); + EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); + DeviceManagerService::GetInstance().UninitDMServiceListener(); } HWTEST_F(DeviceManagerServiceTest, BindTarget_004, testing::ext::TestSize.Level0) @@ -2026,6 +2113,6 @@ HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_206, testing::ext::TestSize.Level int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } -} // namespace +} } // namespace DistributedHardware } // namespace OHOS -- Gitee