diff --git a/test/commonunittest/UTTest_dm_anonymous.cpp b/test/commonunittest/UTTest_dm_anonymous.cpp
index d26792a0e4da9d327593550f9d95c3d901964ca3..547b4d9274babecd16c9de5644ad51b400e283e9 100644
--- a/test/commonunittest/UTTest_dm_anonymous.cpp
+++ b/test/commonunittest/UTTest_dm_anonymous.cpp
@@ -241,6 +241,24 @@ HWTEST_F(DmAnonymousTest, IsInt32_002, testing::ext::TestSize.Level0)
     EXPECT_EQ(ret, false);
 }
 
+/**
+ * @tc.name: IsUint32_001
+ * @tc.desc: Return false
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJK
+ */
+HWTEST_F(DmAnonymousTest, IsUint32_001, testing::ext::TestSize.Level0)
+{
+    std::string str = R"(
+    {
+        "AUTHTYPE" : "authtypeTest"
+    }
+    )";
+    nlohmann::json jsonObj = nlohmann::json::parse(str, nullptr, false);
+    bool ret = IsUint32(jsonObj, TAG_AUTH_TYPE);
+    EXPECT_EQ(ret, false);
+}
+
 /**
  * @tc.name: IsInt64_001
  * @tc.desc: Return true
@@ -367,6 +385,28 @@ HWTEST_F(DmAnonymousTest, IsBool_002, testing::ext::TestSize.Level0)
     bool ret = IsBool(jsonObj, TAG_CRYPTO_SUPPORT);
     EXPECT_EQ(ret, false);
 }
+
+/**
+ * @tc.name: ConvertCharArray2String_001
+ * @tc.desc: Return false
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJK
+ */
+HWTEST_F(DmAnonymousTest, ConvertCharArray2String_001, testing::ext::TestSize.Level0)
+{
+    char *srcData = nullptr;
+    uint32_t srcLen = 0;
+    std::string ret = ConvertCharArray2String(srcData, srcLen);
+    EXPECT_EQ(ret, "");
+    srcLen = 40 * 1024 * 1024 * 2;
+    char *srcData1 = new char[srcLen]();
+    if (srcData1 == nullptr) {
+        return;
+    }
+    ret = ConvertCharArray2String(srcData1, srcLen);
+    EXPECT_EQ(ret, "");
+    delete[] srcData1;
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/commonunittest/UTTest_dm_auth_manager_first.cpp b/test/commonunittest/UTTest_dm_auth_manager_first.cpp
index 187f8a9aab57d8455807755d144b244f3e2e96b6..894d4fabe35820396a2702ac6d83b4437adc10b6 100644
--- a/test/commonunittest/UTTest_dm_auth_manager_first.cpp
+++ b/test/commonunittest/UTTest_dm_auth_manager_first.cpp
@@ -64,57 +64,6 @@ namespace {
 const int32_t MIN_PIN_CODE = 100000;
 const int32_t MAX_PIN_CODE = 999999;
 
-HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
-{
-    std::string pkgName = "";
-    std::string networkId = "222";
-    int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
-    ASSERT_EQ(ret, ERR_DM_FAILED);
-}
-
-HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
-{
-    std::string pkgName = "ohos_test";
-    std::string networkId = "222";
-    authManager_->authRequestState_ = nullptr;
-    authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
-    authManager_->isAuthenticateDevice_ = false;
-    int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
-    ASSERT_EQ(ret, ERR_DM_FAILED);
-}
-
-HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
-{
-    std::string pkgName = "ohos_test";
-    std::string networkId = "222";
-    authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
-    authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
-    authManager_->isAuthenticateDevice_ = true;
-    authManager_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
-    int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
-    ASSERT_EQ(ret, DM_OK);
-}
-
-HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
-{
-    std::string pkgName = "ohos_test";
-    std::string networkId = "222";
-    authManager_->authRequestState_ = std::make_shared<AuthRequestReplyState>();
-    authManager_->isAuthenticateDevice_ = false;
-    int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
-    ASSERT_EQ(ret, ERR_DM_FAILED);
-}
-
-HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)
-{
-    std::string pkgName = "ohos_test";
-    std::string networkId = "networkId";
-    authManager_->authRequestState_ = nullptr;
-    authManager_->authResponseContext_ = nullptr;
-    int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
-    ASSERT_EQ(ret, SOFTBUS_IPC_ERR);
-}
-
 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSize.Level0)
 {
     std::string name = "test";
@@ -135,11 +84,23 @@ HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSiz
     ASSERT_TRUE(authManager_->authRequestState_ != nullptr);
 }
 
+HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_003, testing::ext::TestSize.Level0)
+{
+    std::string name = "test";
+    std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
+    authManager_->SetAuthRequestState(authRequestState);
+    authManager_->HandleAuthenticateTimeout(name);
+    std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
+    authManager_->SetAuthResponseState(authResponseState);
+    ASSERT_TRUE(authManager_->authRequestState_ != nullptr);
+}
+
 HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Level0)
 {
     std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
     std::shared_ptr<DmAuthResponseContext> authRequestContext = std::make_shared<DmAuthResponseContext>();
     std::string deviceId1;
+    authManager_->AbilityNegotiate();
     int32_t ret = authManager_->EstablishAuthChannel(deviceId1);
     ASSERT_EQ(ret, DM_OK);
 }
@@ -215,6 +176,9 @@ HWTEST_F(DmAuthManagerTest, AddMember_002, testing::ext::TestSize.Level0)
     authManager_->authResponseContext_ = nullptr;
     int32_t ret = authManager_->AddMember(pinCode);
     ASSERT_EQ(ret, ERR_DM_FAILED);
+    authManager_->isAddingMember_ = true;
+    ret = authManager_->AddMember(pinCode);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
 }
 
 HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0)
@@ -296,8 +260,15 @@ HWTEST_F(DmAuthManagerTest, SetPageId_002, testing::ext::TestSize.Level0)
     int32_t status = 2;
     authManager_->OnMemberJoin(requestId, status);
     authManager_->OnDataReceived(sessionId, message);
+    authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
+    authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
+    authManager_->authResponseState_ = nullptr;
+    authManager_->OnDataReceived(sessionId, message);
+    authManager_->authRequestState_ = nullptr;
+    authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
+    authManager_->OnDataReceived(sessionId, message);
     int32_t ret = authManager_->SetPageId(pageId);
-    ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
+    ASSERT_EQ(ret, DM_OK);
 }
 
 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_001, testing::ext::TestSize.Level0)
@@ -598,6 +569,20 @@ HWTEST_F(DmAuthManagerTest, UnBindDevice_004, testing::ext::TestSize.Level0)
     ASSERT_EQ(ret, ERR_DM_FAILED);
 }
 
+HWTEST_F(DmAuthManagerTest, UnBindDevice_005, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "ohos_test";
+    std::string udidHash = "networkId";
+    authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
+    authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
+    authManager_->isAuthenticateDevice_ = false;
+    int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
+    authManager_->isAuthenticateDevice_ = true;
+    ret = authManager_->UnBindDevice(pkgName, udidHash);
+    ASSERT_EQ(ret, DM_OK);
+}
+
 HWTEST_F(DmAuthManagerTest, RequestCredential001, testing::ext::TestSize.Level0)
 {
     authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
@@ -1075,6 +1060,12 @@ HWTEST_F(DmAuthManagerTest, PutAccessControlList001, testing::ext::TestSize.Leve
 {
     authManager_->PutAccessControlList();
     ASSERT_EQ(authManager_->isAuthDevice_, false);
+    authManager_->authResponseContext_->isIdenticalAccount = true;
+    authManager_->PutAccessControlList();
+    ASSERT_EQ(authManager_->isAuthDevice_, false);
+    authManager_->authResponseContext_->isIdenticalAccount = true;
+    authManager_->PutAccessControlList();
+    ASSERT_EQ(authManager_->isAuthDevice_, false);
 }
 
 HWTEST_F(DmAuthManagerTest, BindSocketFail_001, testing::ext::TestSize.Level0)
diff --git a/test/commonunittest/UTTest_dm_auth_manager_second.cpp b/test/commonunittest/UTTest_dm_auth_manager_second.cpp
index 3fec91f627810af23cef62d7ecabab27de4341a7..5fbfd788d889b300ad7542cf45b1bdcfaac7c6ab 100644
--- a/test/commonunittest/UTTest_dm_auth_manager_second.cpp
+++ b/test/commonunittest/UTTest_dm_auth_manager_second.cpp
@@ -18,6 +18,7 @@
 #include "nlohmann/json.hpp"
 
 #include "dm_log.h"
+#include "dm_crypto.h"
 #include "dm_constants.h"
 #include "dm_auth_manager.h"
 #include "auth_message_processor.h"
@@ -260,6 +261,15 @@ HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_003, testing::ext::Te
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
+HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_004, testing::ext::TestSize.Level0)
+{
+    int64_t requestId = 1;
+    int32_t status = 0;
+    authManager_->authResponseContext_->requestId = 0;
+    authManager_->HandleMemberJoinImportAuthCode(requestId, status);
+    ASSERT_EQ(authManager_->isFinishOfLocal_, true);
+}
+
 HWTEST_F(DmAuthManagerTest, RespNegotiate_001, testing::ext::TestSize.Level0)
 {
     int64_t requestId = 1;
@@ -295,6 +305,19 @@ HWTEST_F(DmAuthManagerTest, RespNegotiate_004, testing::ext::TestSize.Level0)
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
+HWTEST_F(DmAuthManagerTest, RespNegotiate_005, testing::ext::TestSize.Level0)
+{
+    int64_t requestId = 1;
+    authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
+    authManager_->authResponseContext_->dmVersion = "4.1.5.1";
+    authManager_->authResponseContext_->bindLevel = 0;
+    authManager_->RespNegotiate(requestId);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 1;
+    authManager_->RespNegotiate(requestId);
+    ASSERT_EQ(authManager_->isFinishOfLocal_, true);
+}
+
 HWTEST_F(DmAuthManagerTest, SendAuthRequest_001, testing::ext::TestSize.Level0)
 {
     int64_t sessionId = 1;
@@ -329,6 +352,15 @@ HWTEST_F(DmAuthManagerTest, SendAuthRequest_003, testing::ext::TestSize.Level0)
     authManager_->authResponseContext_->deviceId = "deviceId";
     authManager_->authResponseContext_->reply = -20018;
     authManager_->SendAuthRequest(sessionId);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 0;
+    authManager_->SendAuthRequest(sessionId);
+    authManager_->authResponseContext_->dmVersion = "";
+    authManager_->authResponseContext_->bindLevel = 1;
+    authManager_->SendAuthRequest(sessionId);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 1;
+    authManager_->SendAuthRequest(sessionId);
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
@@ -341,6 +373,11 @@ HWTEST_F(DmAuthManagerTest, GetAuthRequestContext_001, testing::ext::TestSize.Le
     authManager_->authRequestContext_->localAccountId = "123456789";
     authManager_->authResponseContext_->localUserId = 123456789;
     authManager_->GetAuthRequestContext();
+    authManager_->authResponseContext_->isOnline = false;
+    authManager_->GetAuthRequestContext();
+    authManager_->authResponseContext_->isOnline = true;
+    authManager_->authResponseContext_->haveCredential = true;
+    authManager_->GetAuthRequestContext();
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
@@ -371,6 +408,19 @@ HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_004, testing::ext::TestSize.Le
     authManager_->authResponseContext_->isIdenticalAccount = false;
     authManager_->authResponseContext_->isAuthCodeReady = false;
     authManager_->ProcessAuthRequestExt(sessionId);
+    authManager_->authResponseContext_->isOnline = true;
+    authManager_->authResponseContext_->authed = true;
+    authManager_->ProcessAuthRequestExt(sessionId);
+    authManager_->authResponseContext_->authed = false;
+    authManager_->authResponseContext_->isOnline = false;
+    authManager_->ProcessAuthRequestExt(sessionId);
+    authManager_->authResponseContext_->isIdenticalAccount = true;
+    authManager_->ProcessAuthRequestExt(sessionId);
+    authManager_->authResponseContext_->isIdenticalAccount = false;
+    authManager_->authResponseContext_->authed = true;
+    authManager_->ProcessAuthRequestExt(sessionId);
+    authManager_->authResponseContext_->isOnline = true;
+    authManager_->ProcessAuthRequestExt(sessionId);
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
@@ -677,7 +727,16 @@ HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_004, testing::ext::TestSize.Leve
     authManager_->authResponseContext_->dmVersion = "";
     authManager_->authResponseContext_->bindLevel = 0;
     authManager_->ShowStartAuthDialog();
-    ASSERT_EQ(authManager_->authResponseContext_->bindLevel, 0);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 0;
+    authManager_->ShowStartAuthDialog();
+    authManager_->authResponseContext_->dmVersion = "";
+    authManager_->authResponseContext_->bindLevel = 1;
+    authManager_->ShowStartAuthDialog();
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 1;
+    authManager_->ShowStartAuthDialog();
+    ASSERT_EQ(authManager_->authResponseContext_->bindLevel, 1);
 }
 
 HWTEST_F(DmAuthManagerTest, ProcessPincode_001, testing::ext::TestSize.Level0)
@@ -706,6 +765,18 @@ HWTEST_F(DmAuthManagerTest, ProcessPincode_003, testing::ext::TestSize.Level0)
     authManager_->authUiStateMgr_ = nullptr;
     int32_t ret = authManager_->ProcessPincode(pinCode);
     ASSERT_EQ(ret, ERR_DM_FAILED);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 0;
+    ret = authManager_->ProcessPincode(pinCode);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
+    authManager_->authResponseContext_->dmVersion = "";
+    authManager_->authResponseContext_->bindLevel = 1;
+    ret = authManager_->ProcessPincode(pinCode);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
+    authManager_->authResponseContext_->dmVersion = "5.0.1";
+    authManager_->authResponseContext_->bindLevel = 1;
+    ret = authManager_->ProcessPincode(pinCode);
+    ASSERT_EQ(ret, DM_OK);
 }
 
 HWTEST_F(DmAuthManagerTest, AuthDevice_001, testing::ext::TestSize.Level0)
@@ -1320,6 +1391,9 @@ HWTEST_F(DmAuthManagerTest, InitAuthState_001, testing::ext::TestSize.Level0)
     authManager_->timer_ = nullptr;
     authManager_->InitAuthState(pkgName, authType, deviceId, extra);
     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
+    authManager_->timer_ = std::make_shared<DmTimer>();
+    authManager_->InitAuthState(pkgName, authType, deviceId, extra);
+    ASSERT_EQ(authManager_->isFinishOfLocal_, true);
 }
 
 HWTEST_F(DmAuthManagerTest, HandleSessionHeartbeat_001, testing::ext::TestSize.Level0)
@@ -1390,6 +1464,37 @@ HWTEST_F(DmAuthManagerTest, CheckTrustState_005, testing::ext::TestSize.Level0)
     int32_t ret = authManager_->CheckTrustState();
     ASSERT_EQ(ret, DM_OK);
 }
+
+HWTEST_F(DmAuthManagerTest, CheckTrustState_006, testing::ext::TestSize.Level0)
+{
+    std::string udid = "";
+    authManager_->authResponseContext_->isOnline = false;
+    authManager_->authResponseContext_->authType = 6;
+    authManager_->authResponseContext_->importAuthCode = "importAuthCode";
+    authManager_->importAuthCode_ = "importAuthCode_";
+    authManager_->authResponseContext_->isIdenticalAccount = false;
+    authManager_->authResponseContext_->reply = 1;
+    authManager_->authResponseContext_->authType = 1;
+    authManager_->authResponseContext_->isAuthCodeReady = true;
+    int32_t ret = authManager_->CheckTrustState();
+    ASSERT_EQ(ret, DM_OK);
+    authManager_->importAuthCode_ = Crypto::Sha256("importAuthCode_");
+    ret = authManager_->CheckTrustState();
+    ASSERT_EQ(ret, DM_OK);
+    authManager_->authResponseContext_->isOnline = false;
+    authManager_->authResponseContext_->isIdenticalAccount = true;
+    ret = authManager_->CheckTrustState();
+    ASSERT_EQ(ret, DM_OK);
+    authManager_->authResponseContext_->reply = ERR_DM_AUTH_PEER_REJECT;
+    ret = authManager_->CheckTrustState();
+    authManager_->OnScreenLocked();
+    authManager_->HandleDeviceNotTrust(udid);
+    udid = "udidTest";
+    authManager_->HandleDeviceNotTrust(udid);
+    authManager_->authRequestState_ = nullptr;
+    authManager_->OnScreenLocked();
+    ASSERT_EQ(ret, DM_OK);
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/commonunittest/UTTest_dm_deviceprofile_connector.cpp b/test/commonunittest/UTTest_dm_deviceprofile_connector.cpp
index 5d6308a28b324c7e945c0b3da42b541f0c2611ac..57033f325da7ad62e5921936d4be26e37fe2c40b 100644
--- a/test/commonunittest/UTTest_dm_deviceprofile_connector.cpp
+++ b/test/commonunittest/UTTest_dm_deviceprofile_connector.cpp
@@ -739,5 +739,68 @@ HWTEST_F(DeviceProfileConnectorTest, IsSameAccount_002, testing::ext::TestSize.L
     int32_t ret = DeviceProfileConnector::GetInstance().IsSameAccount(udid);
     EXPECT_EQ(ret, DM_OK);
 }
+
+HWTEST_F(DeviceProfileConnectorTest, GetAuthForm_001, testing::ext::TestSize.Level0)
+{
+    DistributedDeviceProfile::AccessControlProfile profile;
+    std::string trustDev = "";
+    std::string reqDev = "";
+    int32_t ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, INVALIED_TYPE);
+    profile.SetBindType(DM_IDENTICAL_ACCOUNT);
+    ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, IDENTICAL_ACCOUNT_TYPE);
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(DEVICE);
+    ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, DEVICE_PEER_TO_PEER_TYPE);
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(DEVICE);
+    ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, DEVICE_ACROSS_ACCOUNT_TYPE);
+    profile.SetBindLevel(APP);
+    ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, APP_ACROSS_ACCOUNT_TYPE);
+    profile.SetBindType(INVALIED_TYPE);
+    ret = DeviceProfileConnector::GetInstance().GetAuthForm(profile, trustDev, reqDev);
+    EXPECT_EQ(ret, INVALIED_TYPE);
+}
+
+HWTEST_F(DeviceProfileConnectorTest, SingleUserProcess_001, testing::ext::TestSize.Level0)
+{
+    DistributedDeviceProfile::AccessControlProfile profile;
+    DmAccessCaller caller;
+    DmAccessCallee callee;
+    int32_t ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, false);
+    profile.SetBindType(DM_IDENTICAL_ACCOUNT);
+    profile.accessee_.SetAccesseeBundleName("pkgName");
+    profile.accessee_.SetAccesseeDeviceId("localDeviceId");
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(DEVICE);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindLevel(APP);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindLevel(SERVICE);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(DEVICE);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindLevel(APP);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindLevel(SERVICE);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, true);
+    profile.SetBindType(INVALIED_TYPE);
+    ret = DeviceProfileConnector::GetInstance().SingleUserProcess(profile, caller, callee);
+    EXPECT_EQ(ret, false);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/softbusunittest/UTTest_softbus_session.cpp b/test/softbusunittest/UTTest_softbus_session.cpp
index 08f2b0df3bf8ebf4ac1b6be6db774bfabe0412f2..84ff8726a95936bccf8af285e5b35eaa015a0992 100644
--- a/test/softbusunittest/UTTest_softbus_session.cpp
+++ b/test/softbusunittest/UTTest_softbus_session.cpp
@@ -259,6 +259,9 @@ HWTEST_F(SoftbusSessionTest, OnSessionOpened_001, testing::ext::TestSize.Level0)
     void *data = nullptr;
     unsigned int dataLen = 1;
     softbusSession->OnBytesReceived(sessionId, data, dataLen);
+    softbusSession->OnBytesReceived(sessionId, data, -1);
+    sessionId = -1;
+    softbusSession->OnBytesReceived(sessionId, data, dataLen);
     int ret = softbusSession->OnSessionOpened(sessionId, result);
     softbusSession->OnSessionClosed(sessionId);
     EXPECT_EQ(ret, DM_OK);
diff --git a/test/unittest/UTTest_auth_message_processor.cpp b/test/unittest/UTTest_auth_message_processor.cpp
index 1bed5dffec46c51ce8a5110f3420a954f84ac9ea..1275093a433928f60634b5f98f06ced2f8bf016f 100644
--- a/test/unittest/UTTest_auth_message_processor.cpp
+++ b/test/unittest/UTTest_auth_message_processor.cpp
@@ -133,6 +133,8 @@ HWTEST_F(AuthMessageProcessorTest, CreateNegotiateMessage_001, testing::ext::Tes
     authMessageProcessor->cryptoAdapter_ = nullptr;
     authMessageProcessor->CreateNegotiateMessage(jsonObj);
     std::string str1 = jsonObj.dump();
+    authMessageProcessor->cryptoAdapter_ = std::make_shared<CryptoAdapterTest>();
+    authMessageProcessor->CreateNegotiateMessage(jsonObj);
 
     nlohmann::json jsonObject;
     jsonObject[TAG_ACCOUNT_GROUPID] = "";
@@ -274,6 +276,7 @@ HWTEST_F(AuthMessageProcessorTest, ParseResponseFinishMessage_002, testing::ext:
     authMessageProcessor->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
     nlohmann::json jsonObj;
     jsonObj[TAG_REPLY] = 22;
+    jsonObj[TAG_AUTH_FINISH] = true;
     authMessageProcessor->ParseResponseFinishMessage(jsonObj);
     ASSERT_EQ(authMessageProcessor->authResponseContext_->reply, jsonObj[TAG_REPLY]);
 }
@@ -607,6 +610,22 @@ HWTEST_F(AuthMessageProcessorTest, ParseAuthRequestMessage_002, testing::ext::Te
     jsonThumbnail[TAG_DEVICE_TYPE] = 1;
     int32_t ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
     ASSERT_EQ(ret, DM_OK);
+    jsonThumbnail[TAG_INDEX] = 1;
+    ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
+    ASSERT_EQ(ret, DM_OK);
+    jsonThumbnail[TAG_SLICE_NUM] = 10;
+    ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
+    ASSERT_EQ(ret, DM_OK);
+    jsonThumbnail[TAG_SLICE_NUM] = 1;
+    jsonThumbnail[TAG_IS_SHOW_DIALOG] = true;
+    ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
+    ASSERT_EQ(ret, DM_OK);
+    jsonThumbnail[TAG_BIND_TYPE_SIZE] = 10001;
+    ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
+    jsonThumbnail[TAG_BIND_TYPE_SIZE] = 1;
+    ret = authMessageProcessor->ParseAuthRequestMessage(jsonThumbnail);
+    ASSERT_EQ(ret, DM_OK);
 }
 
 /**
@@ -807,6 +826,42 @@ HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_005, testing::ext::Test
     ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext);
 }
 
+/**
+ * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_006
+ * @tc.desc: Compare authResponseContext before and after assignment
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJK
+ */
+HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_006, testing::ext::TestSize.Level0)
+{
+    std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
+    std::shared_ptr<DmAuthManager> data =
+        std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector_, listener, hiChainAuthConnector);
+    std::shared_ptr<AuthMessageProcessor> authMessageProcessor = std::make_shared<AuthMessageProcessor>(data);
+    std::shared_ptr<DmAuthResponseContext> authResponseContext = std::make_shared<DmAuthResponseContext>();
+    authMessageProcessor->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
+    nlohmann::json jsonObj;
+    authResponseContext->localDeviceId = "22";
+    authResponseContext->authType = 1;
+    authResponseContext->reply = 33;
+    jsonObj[TAG_LOCAL_DEVICE_ID] = "LOCALDEVICEID";
+    jsonObj[TAG_LOCAL_DEVICE_ID] = authResponseContext->localDeviceId;
+    jsonObj[TAG_AUTH_TYPE] = authResponseContext->authType;
+    jsonObj[TAG_LOCAL_DEVICE_ID] = authResponseContext->localDeviceId;
+    jsonObj[TAG_REPLY] = authResponseContext->reply;
+    jsonObj[TAG_CRYPTO_SUPPORT] = true;
+    jsonObj[TAG_CRYPTO_NAME] = "NAMETEST";
+    jsonObj[TAG_CRYPTO_VERSION] = "1.0";
+    jsonObj[TAG_ACCOUNT_GROUPID] = "GROUPID";
+    authMessageProcessor->ParseNegotiateMessage(jsonObj);
+    jsonObj[TAG_ACCOUNT_GROUPID] = 12;
+    jsonObj[TAG_HOST] = "12";
+    jsonObj[TAG_AUTH_TYPE] = "12";
+    authMessageProcessor->SetResponseContext(authResponseContext);
+    authMessageProcessor->ParseNegotiateMessage(jsonObj);
+    ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext);
+}
+
 /**
  * @tc.name: AuthMessageProcessor::ParseRespNegotiateMessage_001
  * @tc.desc: return true
@@ -869,6 +924,7 @@ HWTEST_F(AuthMessageProcessorTest, ParseRespNegotiateMessage_003, testing::ext::
     jsonObj[TAG_NET_ID] = "1212";
     jsonObj[TAG_TOKENID] = "1212";
     jsonObj[TAG_TARGET_DEVICE_NAME] = "1212";
+    jsonObj[TAG_IMPORT_AUTH_CODE] = "1212";
     authMessageProcessor->ParseRespNegotiateMessage(jsonObj);
     ASSERT_EQ(authMessageProcessor->authResponseContext_->isIdenticalAccount, true);
 }
@@ -1038,6 +1094,9 @@ HWTEST_F(AuthMessageProcessorTest, CreateSimpleMessage_001, testing::ext::TestSi
     msgType = MSG_TYPE_RESP_NEGOTIATE;
     ret = authMessageProcessor->CreateSimpleMessage(msgType);
     ASSERT_NE(ret.size(), 0);
+    msgType = MSG_TYPE_UNKNOWN;
+    ret = authMessageProcessor->CreateSimpleMessage(msgType);
+    ASSERT_NE(ret.size(), 0);
 }
 
 /**
@@ -1591,6 +1650,9 @@ HWTEST_F(AuthMessageProcessorTest, ParsePkgNegotiateMessage_002, testing::ext::T
     jsonObj[TAG_HAVECREDENTIAL] = "1212";
     jsonObj[TAG_BIND_TYPE_SIZE] = "1212";
     authMessageProcessor->ParsePkgNegotiateMessage(jsonObj);
+    jsonObj[TAG_BIND_TYPE_SIZE] = 1212;
+    jsonObj[TAG_HOST_PKGLABEL] = "1212";
+    authMessageProcessor->ParsePkgNegotiateMessage(jsonObj);
     ASSERT_NE(authMessageProcessor->authResponseContext_->authType, 21);
 }
 
diff --git a/test/unittest/UTTest_device_manager_impl.cpp b/test/unittest/UTTest_device_manager_impl.cpp
index aa8c4203204babd30ba0ab05215f3e1d13cc74b7..228335f5f095c66b74edd2f02bed151aaa1599be 100644
--- a/test/unittest/UTTest_device_manager_impl.cpp
+++ b/test/unittest/UTTest_device_manager_impl.cpp
@@ -1495,6 +1495,314 @@ HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_007, testing::ext::TestSize
     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
 }
 
+/**
+ * @tc.name: GetTrustedDeviceList_008
+ * @tc.desc: 1. set packName not null
+ *              set extra null
+ *              set deviceList null
+ *              set isRefresh true
+ *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
+ *           3. check ret is DM_OK
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_008, testing::ext::TestSize.Level0)
+{
+    std::string packName = "";
+    std::map<std::string, std::string> filterOptions;
+    bool isRefresh = false;
+    std::vector<DmDeviceInfo> deviceList;
+    int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    packName = "packNameTest";
+    ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
+    ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
+}
+
+/**
+ * @tc.name: ImportCredential_001
+ * @tc.desc: 1. set pkgName not null
+ *              set reqJsonStr null
+ *              set returnJsonStr null
+ *           2. call DeviceManagerImpl::ImportCredential with parameter
+ *           3. check ret is DM_OK
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::string reqJsonStr = "";
+    std::string returnJsonStr = "";
+    int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "";
+    reqJsonStr = "reqJsonStrTest";
+    ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
+    ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, DM_OK);
+    ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: RequestCredential_001
+ * @tc.desc: 1. set pkgName not null
+ *              set reqJsonStr null
+ *              set returnJsonStr null
+ *           2. call DeviceManagerImpl::RequestCredential with parameter
+ *           3. check ret is DM_OK
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::string reqJsonStr = "";
+    std::string returnJsonStr = "";
+    int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
+    ASSERT_EQ(ret, DM_OK);
+    ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "";
+    reqJsonStr = "reqJsonStrTest";
+    ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
+    ASSERT_EQ(ret, DM_OK);
+    ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: GenerateEncryptedUuid_001
+ * @tc.desc: 1. set packName null
+ *              set extra null
+ *              set deviceList null
+ *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::string uuid = "";
+    std::string appId = "";
+    std::string encryptedUuid = "";
+    int32_t ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "";
+    uuid = "uuidTest";
+    ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
+    ASSERT_EQ(ret, DM_OK);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: GetNetworkTypeByNetworkId_001
+ * @tc.desc: 1. set pkgName null
+ *              set networkId null
+ *              set networkType null
+ *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::string networkId = "";
+    int32_t netWorkType = 0;
+    int32_t ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "";
+    networkId = "networkIdTest";
+    ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
+    ASSERT_EQ(ret, DM_OK);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: ImportAuthCode_001
+ * @tc.desc: 1. set packName null
+ *              set authCode null
+ *           2. call DeviceManagerImpl::ImportAuthCode with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::string authCode = "";
+    int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "";
+    authCode = "authCodeTest";
+    ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    authCode = "authoCo";
+    ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
+/**
+ * @tc.name: RegisterDiscoveryCallback_001
+ * @tc.desc: 1. set packName null
+ *              set discoverParam null
+ *              set filterOptions null
+ *              set callback null
+ *           2. call DeviceManagerImpl::RegisterDiscoveryCallback with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::map<std::string, std::string> discoverParam;
+    std::map<std::string, std::string> filterOptions;
+    std::shared_ptr<DiscoveryCallback> callback = nullptr;
+    int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName,
+        discoverParam, filterOptions, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    callback = std::make_shared<DeviceDiscoveryCallbackTest>();
+    ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
+/**
+ * @tc.name: StartAdvertising_001
+ * @tc.desc: 1. set packName null
+ *              set discoverParam null
+ *              set filterOptions null
+ *              set callback null
+ *           2. call DeviceManagerImpl::StartAdvertising with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, StartAdvertising_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::map<std::string, std::string> advertiseParam;
+    std::shared_ptr<PublishCallback> callback = nullptr;
+    int32_t ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    callback = std::make_shared<DevicePublishCallbackTest>();
+    ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: BindTarget_001
+ * @tc.desc: 1. set packName null
+ *              set targetId null
+ *              set unbindParam null
+ *              set callback null
+ *           2. call DeviceManagerImpl::BindTarget with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, BindTarget_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    PeerTargetId targetId;
+    std::map<std::string, std::string> unbindParam;
+    std::shared_ptr<BindTargetCallback> callback = nullptr;
+    std::shared_ptr<UnbindTargetCallback> uncallback = nullptr;
+    int32_t ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    targetId.deviceId = "deviceIdTest";
+    targetId.brMac = "brMacTest";
+    targetId.bleMac = "bleMacTest";
+    targetId.wifiIp = "wifiIpTest";
+    ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
+    ASSERT_EQ(ret, DM_OK);
+    ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
+    ASSERT_EQ(ret, DM_OK);
+}
+
 /**
  * @tc.name: GetLocalDeviceInfo_001
  * @tc.desc: 1. set packName null
@@ -1765,6 +2073,35 @@ HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::Test
     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
 }
 
+/**
+ * @tc.name: RegisterDevStateCallback_006
+ * @tc.desc: 1. set packName not null
+ *              set extra not null
+ *              set callback null
+ *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
+ *           3. check ret is ERR_DM_INPUT_PARA_INVALID
+ * deviceTypeId
+ * @tc.type: FUNC
+ * @tc.require: AR000GHSJK
+ */
+HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::map<std::string, std::string> extraParam;
+    std::shared_ptr<DeviceStateCallback> callback = nullptr;
+    int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    callback = std::make_shared<DeviceStateCallbackTest>();
+    ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
+    ASSERT_EQ(ret, DM_OK);
+    pkgName = "";
+    ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
 /**
  * @tc.name: UnRegisterDevStateCallback_001
  * @tc.desc: 1. set packName null
@@ -2040,7 +2377,164 @@ HWTEST_F(DeviceManagerImplTest, IsSameAccount_002, testing::ext::TestSize.Level0
     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
     DeviceManager::GetInstance().InitDeviceManager(pkgName, initCallback);
     bool ret = DeviceManager::GetInstance().IsSameAccount(udid);
-    ASSERT_EQ(ret, false);
+    ASSERT_EQ(ret, true);
+}
+
+/**
+ * @tc.name: AddPublishCallback_001
+ * @tc.desc: 1. set udid and bundleName not null
+ *           2. call DeviceManagerImpl::AddPublishCallback with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, AddPublishcCllback_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "com.ohos.test";
+    int32_t ret = DeviceManagerImpl::GetInstance().AddPublishCallback(pkgName);
+    ASSERT_NE(ret, 0);
+    ret = DeviceManagerImpl::GetInstance().RemovePublishCallback(pkgName);
+    ASSERT_NE(ret, 0);
+}
+
+/**
+ * @tc.name: RegisterPinHolderCallback_001
+ * @tc.desc: 1. set udid and bundleName not null
+ *           2. call DeviceManagerImpl::RegisterPinHolderCallback with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    std::shared_ptr<PinHolderCallback> callback = nullptr;
+    int32_t ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "pkgNameTest";
+    ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
+/**
+ * @tc.name: CreatePinHolder_001
+ * @tc.desc: 1. set udid and bundleName not null
+ *           2. call DeviceManagerImpl::CreatePinHolder with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, CreatePinHolder_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    PeerTargetId targetId;
+    DmPinType pinType = DmPinType::QR_CODE;
+    std::string payload = "payload";
+    int32_t ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "com.ohos.test";
+    targetId.deviceId = "deviceIdTest";
+    targetId.brMac = "brMacTest";
+    targetId.bleMac = "bleMacTest";
+    targetId.wifiIp = "wifiIpTest";
+    pinType = static_cast<DmPinType>(6);
+    ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pinType = DmPinType::QR_CODE;
+    payload.resize(DM_STRING_LENGTH_MAX * 2);
+    ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    payload.resize(10);
+    ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: DestroyPinHolder_001
+ * @tc.desc: 1. set udid and bundleName not null
+ *           2. call DeviceManagerImpl::DestroyPinHolder with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, DestoryPinHolder_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    PeerTargetId targetId;
+    DmPinType pinType = DmPinType::QR_CODE;
+    std::string payload = "payload";
+    int32_t ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "com.ohos.test";
+    targetId.deviceId = "deviceIdTest";
+    targetId.brMac = "brMacTest";
+    targetId.bleMac = "bleMacTest";
+    targetId.wifiIp = "wifiIpTest";
+    pinType = static_cast<DmPinType>(6);
+    ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pinType = DmPinType::QR_CODE;
+    payload.resize(DM_STRING_LENGTH_MAX * 2);
+    ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    payload.resize(10);
+    ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: DpAclAdd_001
+ * @tc.desc: 1. set DpAclAdd and Udid not null
+ *           2. call DeviceManagerImpl::DpAclAdd with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, DpAclAdd_001, testing::ext::TestSize.Level0)
+{
+    int64_t accessControlId = 0;
+    std::string udid = "udidTest";
+    int32_t bindType = PEER_TO_PEER;
+    int32_t ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
+    ASSERT_EQ(ret, DM_OK);
+    bindType = IDENTICAL_ACCOUNT;
+    ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
+    ASSERT_EQ(ret, DM_OK);
+    std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
+    std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
+    ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+/**
+ * @tc.name: GetDeviceSecurityLevel_001
+ * @tc.desc: 1. set DpAclAdd and Udid not null
+ *           2. call DeviceManagerImpl::GetDeviceSecurityLevel with parameter
+ *           3. check ret is true
+ * @tc.type: FUNC
+ */
+HWTEST_F(DeviceManagerImplTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0)
+{
+    int32_t securityLevel = 3;
+    std::string pkgName = "";
+    std::string netWorkId = "";
+    int32_t ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    pkgName = "com.ohos.test";
+    ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+    netWorkId = "netWorkIdTest";
+    ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
+    ASSERT_EQ(ret, DM_OK);
+    pkgName = "";
+    ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
+    ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
 }
 } // namespace
 } // namespace DistributedHardware
diff --git a/test/unittest/UTTest_ipc_client_proxy.cpp b/test/unittest/UTTest_ipc_client_proxy.cpp
index a39e3a58e1a9e6449be423c20c9433f1f183610b..666f5f940651d5943852fb46152b525170536a7e 100644
--- a/test/unittest/UTTest_ipc_client_proxy.cpp
+++ b/test/unittest/UTTest_ipc_client_proxy.cpp
@@ -409,6 +409,10 @@ HWTEST_F(IpcClientProxyTest, SendRequest5, testing::ext::TestSize.Level0)
     int32_t ret = ipcClientProxy->SendRequest(0, req, rsp);
     // 4. check ret is DM_OK
     ASSERT_EQ(ret, DM_OK);
+    ret = ipcClientProxy->SendRequest(-1, req, rsp);
+    ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
+    ret = ipcClientProxy->SendRequest(IPC_MSG_SEV, req, rsp);
+    ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
 }
 
 /**
@@ -461,6 +465,9 @@ HWTEST_F(IpcClientProxyTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
     int32_t ret = ipcClientProxy->OnDmServiceDied();
     // 4. check ret is DM_OK
     ASSERT_EQ(ret, DM_OK);
+    ipcClientProxy->ipcClientManager_ = nullptr;
+    ret = ipcClientProxy->OnDmServiceDied();
+    ASSERT_EQ(ret, ERR_DM_POINT_NULL);
 }
 } // namespace
 } // namespace DistributedHardware