diff --git a/test/commonunittest/UTTest_dm_deviceprofile_connector_second.cpp b/test/commonunittest/UTTest_dm_deviceprofile_connector_second.cpp
index 526a5f0b3b1fbf1be3d5d59d363fff62d0d17aba..de578f338e99e8f3d42adedfd77727140c9b0f6e 100644
--- a/test/commonunittest/UTTest_dm_deviceprofile_connector_second.cpp
+++ b/test/commonunittest/UTTest_dm_deviceprofile_connector_second.cpp
@@ -20,6 +20,7 @@
 #include <iterator>
 #include "dp_inited_callback_stub.h"
 #include "dm_error_type.h"
+#include "dm_crypto.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -936,6 +937,743 @@ HWTEST_F(DeviceProfileConnectorSecondTest, GetAuthFormMap_007, testing::ext::Tes
     EXPECT_EQ(ret[trustDeviceId], DmAuthForm::IDENTICAL_ACCOUNT);
 }
 
+HWTEST_F(DeviceProfileConnectorSecondTest, GetVersionByExtra_001, testing::ext::TestSize.Level1)
+{
+    std::string extraInfo = "";
+    std::string dmVersion;
+
+    int32_t ret = DeviceProfileConnector::GetInstance().GetVersionByExtra(extraInfo, dmVersion);
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+}
+HWTEST_F(DeviceProfileConnectorSecondTest, GetVersionByExtra_002, testing::ext::TestSize.Level1)
+{
+    std::string extraInfo = "invalid_json";
+    std::string dmVersion;
+
+    int32_t ret = DeviceProfileConnector::GetInstance().GetVersionByExtra(extraInfo, dmVersion);
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetVersionByExtra_003, testing::ext::TestSize.Level1)
+{
+    std::string extraInfo = R"({"key": "value"})";
+    std::string dmVersion;
+
+    int32_t ret = DeviceProfileConnector::GetInstance().GetVersionByExtra(extraInfo, dmVersion);
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetVersionByExtra_004, testing::ext::TestSize.Level1)
+{
+    std::string extraInfo = R"({"dmVersion": "5.1.0"})";
+    std::string dmVersion;
+
+    int32_t ret = DeviceProfileConnector::GetInstance().GetVersionByExtra(extraInfo, dmVersion);
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_EQ(dmVersion, "5.1.0");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAllVerionAclMap_001, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = "";
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GetAllVerionAclMap(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 1);
+    EXPECT_TRUE(aclMap.find(DM_VERSION_5_1_0) != aclMap.end());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAllVerionAclMap_002, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = DM_VERSION_5_1_0;
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GetAllVerionAclMap(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 1);
+    EXPECT_TRUE(aclMap.find(dmVersion) != aclMap.end());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAllVerionAclMap_003, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = "invalid_version";
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GetAllVerionAclMap(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 0);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAllVerionAclMap_004, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = DM_VERSION_5_1_0;
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GetAllVerionAclMap(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 1);
+    EXPECT_TRUE(aclMap.find(dmVersion) != aclMap.end());
+    EXPECT_FALSE(aclMap[dmVersion].empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GenerateAclHash_001, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = DM_VERSION_5_1_0;
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GenerateAclHash(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 1);
+    EXPECT_TRUE(aclMap.find(dmVersion) != aclMap.end());
+    EXPECT_FALSE(aclMap[dmVersion].empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GenerateAclHash_002, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = "invalid_version";
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GenerateAclHash(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 0);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GenerateAclHash_003, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::map<std::string, std::vector<std::string>> aclMap;
+    std::string dmVersion = DM_VERSION_5_1_0;;
+    aclMap[dmVersion].push_back("existing_hash");
+
+    EXPECT_NO_THROW(DeviceProfileConnector::GetInstance().GenerateAclHash(acl, aclMap, dmVersion));
+    EXPECT_EQ(aclMap.size(), 1);
+    EXPECT_TRUE(aclMap.find(dmVersion) != aclMap.end());
+    EXPECT_EQ(aclMap[dmVersion].size(), 2);
+}
+
+
+HWTEST_F(DeviceProfileConnectorSecondTest, IsAuthNewVersion_001, testing::ext::TestSize.Level1)
+{
+    int32_t bindLevel = 0;
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .IsAuthNewVersion(bindLevel, localUdid, remoteUdid, tokenId, userId);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, IsAuthNewVersion_002, testing::ext::TestSize.Level1)
+{
+    int32_t bindLevel = 4;
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .IsAuthNewVersion(bindLevel, localUdid, remoteUdid, tokenId, userId);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, ChecksumAcl_001, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::vector<std::string> acLStrList;
+
+    bool result = DeviceProfileConnector::GetInstance().ChecksumAcl(acl, acLStrList);
+    EXPECT_FALSE(result);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, ChecksumAcl_002, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::string aclStr = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+    std::string aclHash = Crypto::Sha256(aclStr);
+
+    std::vector<std::string> acLStrList = {aclHash};
+
+    bool result = DeviceProfileConnector::GetInstance().ChecksumAcl(acl, acLStrList);
+    EXPECT_TRUE(result);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, ChecksumAcl_003, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::vector<std::string> acLStrList = {"invalid_hash"};
+
+    bool result = DeviceProfileConnector::GetInstance().ChecksumAcl(acl, acLStrList);
+    EXPECT_FALSE(result);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, ChecksumAcl_004, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+    acl.SetAccessControlId(12345);
+    acl.SetAccesserId(1);
+    acl.SetAccesseeId(2);
+    acl.SetTrustDeviceId("trustDeviceId");
+    acl.SetBindType(256);
+    acl.SetAuthenticationType(2);
+    acl.SetDeviceIdType(1);
+    acl.SetStatus(1);
+    acl.SetBindLevel(1);
+
+    std::string aclStr = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+    std::string aclHash = Crypto::Sha256(aclStr);
+
+    std::vector<std::string> acLStrList = {"invalid_hash1", aclHash, "invalid_hash2"};
+
+    bool result = DeviceProfileConnector::GetInstance().ChecksumAcl(acl, acLStrList);
+    EXPECT_TRUE(result);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, ChecksumAcl_005, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+
+    std::vector<std::string> acLStrList = {"some_hash"};
+
+    bool result = DeviceProfileConnector::GetInstance().ChecksumAcl(acl, acLStrList);
+    EXPECT_FALSE(result);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, AccessToStr_001, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId("accesserDeviceId");
+    accesser.SetAccesserUserId(1001);
+    accesser.SetAccesserAccountId("accesserAccountId");
+    accesser.SetAccesserTokenId(2001);
+    accesser.SetAccesserBundleName("accesserBundleName");
+    accesser.SetAccesserHapSignature("accesserHapSignature");
+    accesser.SetAccesserBindLevel(1);
+    accesser.SetAccesserCredentialIdStr("accesserCredentialIdStr");
+    accesser.SetAccesserStatus(1);
+    accesser.SetAccesserSKTimeStamp(1234567890);
+
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId("accesseeDeviceId");
+    accessee.SetAccesseeUserId(1002);
+    accessee.SetAccesseeAccountId("accesseeAccountId");
+    accessee.SetAccesseeTokenId(2002);
+    accessee.SetAccesseeBundleName("accesseeBundleName");
+    accessee.SetAccesseeHapSignature("accesseeHapSignature");
+    accessee.SetAccesseeBindLevel(2);
+    accessee.SetAccesseeCredentialIdStr("accesseeCredentialIdStr");
+    accessee.SetAccesseeStatus(2);
+    accessee.SetAccesseeSKTimeStamp(987654321);
+
+    acl.SetAccesser(accesser);
+    acl.SetAccessee(accessee);
+
+    std::string result = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(result.find("accesserDeviceId"), std::string::npos);
+    EXPECT_NE(result.find("accesserAccountId"), std::string::npos);
+    EXPECT_NE(result.find("accesseeDeviceId"), std::string::npos);
+    EXPECT_NE(result.find("accesseeAccountId"), std::string::npos);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, AccessToStr_002, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId("accesserDeviceId");
+    accesser.SetAccesserUserId(1001);
+    accesser.SetAccesserAccountId("accesserAccountId");
+    accesser.SetAccesserTokenId(2001);
+    accesser.SetAccesserBundleName("accesserBundleName");
+    accesser.SetAccesserHapSignature("accesserHapSignature");
+    accesser.SetAccesserBindLevel(1);
+    accesser.SetAccesserCredentialIdStr("accesserCredentialIdStr");
+    accesser.SetAccesserStatus(1);
+    accesser.SetAccesserSKTimeStamp(1234567890);
+
+    acl.SetAccesser(accesser);
+
+    std::string result = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(result.find("accesserDeviceId"), std::string::npos);
+    EXPECT_NE(result.find("accesserAccountId"), std::string::npos);
+    EXPECT_EQ(result.find("accesseeDeviceId"), std::string::npos);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, AccessToStr_003, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId("accesseeDeviceId");
+    accessee.SetAccesseeUserId(1002);
+    accessee.SetAccesseeAccountId("accesseeAccountId");
+    accessee.SetAccesseeTokenId(2002);
+    accessee.SetAccesseeBundleName("accesseeBundleName");
+    accessee.SetAccesseeHapSignature("accesseeHapSignature");
+    accessee.SetAccesseeBindLevel(2);
+    accessee.SetAccesseeCredentialIdStr("accesseeCredentialIdStr");
+    accessee.SetAccesseeStatus(2);
+    accessee.SetAccesseeSKTimeStamp(987654321);
+
+    acl.SetAccessee(accessee);
+
+    std::string result = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+
+    EXPECT_FALSE(result.empty());
+    EXPECT_EQ(result.find("accesserDeviceId"), std::string::npos);
+    EXPECT_NE(result.find("accesseeDeviceId"), std::string::npos);
+    EXPECT_NE(result.find("accesseeAccountId"), std::string::npos);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, AccessToStr_004, testing::ext::TestSize.Level1)
+{
+    DistributedDeviceProfile::AccessControlProfile acl;
+
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId("accesserDeviceId");
+    accesser.SetAccesserUserId(1001);
+    accesser.SetAccesserAccountId("");
+    accesser.SetAccesserTokenId(2001);
+    accesser.SetAccesserBundleName("");
+    accesser.SetAccesserHapSignature("accesserHapSignature");
+    accesser.SetAccesserBindLevel(1);
+    accesser.SetAccesserCredentialIdStr("");
+    accesser.SetAccesserStatus(1);
+    accesser.SetAccesserSKTimeStamp(1234567890);
+
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId("");
+    accessee.SetAccesseeUserId(1002);
+    accessee.SetAccesseeAccountId("accesseeAccountId");
+    accessee.SetAccesseeTokenId(2002);
+    accessee.SetAccesseeBundleName("accesseeBundleName");
+    accessee.SetAccesseeHapSignature("");
+    accessee.SetAccesseeBindLevel(2);
+    accessee.SetAccesseeCredentialIdStr("accesseeCredentialIdStr");
+    accessee.SetAccesseeStatus(2);
+    accessee.SetAccesseeSKTimeStamp(987654321);
+
+    acl.SetAccesser(accesser);
+    acl.SetAccessee(accessee);
+    std::string result = DeviceProfileConnector::GetInstance().AccessToStr(acl);
+
+    EXPECT_FALSE(result.empty());
+    EXPECT_NE(result.find("accesserDeviceId"), std::string::npos);
+    EXPECT_EQ(result.find("accesserAccountId"), std::string::npos);
+    EXPECT_NE(result.find("accesseeAccountId"), std::string::npos);
+    EXPECT_EQ(result.find("accesseeDeviceId"), std::string::npos);
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_001, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_002, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_IDENTICAL_ACCOUNT);
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_003, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindLevel(USER);
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_004, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(APP);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserUserId(userId);
+    accesser.SetAccesserTokenId(tokenId);
+    accesser.SetAccesserDeviceId(localUdid);
+    accesser.SetAccesserExtraData("5.1.0");
+    profile.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile.SetAccessee(accessee);
+    
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_EQ(result, "5.1.0");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_005, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(SERVICE);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId(remoteUdid);
+    profile.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeUserId(userId);
+    accessee.SetAccesseeTokenId(tokenId);
+    accessee.SetAccesseeDeviceId(localUdid);
+    accessee.SetAccesseeExtraData("5.1.0");
+    profile.SetAccessee(accessee);
+    
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_EQ(result, "5.1.0");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_006, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(APP);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserUserId(9999);
+    accesser.SetAccesserTokenId(tokenId);
+    accesser.SetAccesserDeviceId(localUdid);
+    accesser.SetAccesserExtraData("5.1.0");
+    profile.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile.SetAccessee(accessee);
+    
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_007, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(SERVICE);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserUserId(userId);
+    accesser.SetAccesserTokenId(9999);
+    accesser.SetAccesserDeviceId(localUdid);
+    accesser.SetAccesserExtraData("5.1.0");
+    profile.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile.SetAccessee(accessee);
+    
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_008, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_ACROSS_ACCOUNT);
+    profile.SetBindLevel(APP);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserUserId(userId);
+    accesser.SetAccesserTokenId(tokenId);
+    accesser.SetAccesserDeviceId("wrongDeviceId");
+    accesser.SetAccesserExtraData("5.1.0");
+    profile.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile.SetAccessee(accessee);
+    
+    profiles.push_back(profile);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_TRUE(result.empty());
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetAppServiceAuthVersionInfo_009, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    int32_t tokenId = 12345;
+    int32_t userId = 1001;
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    DistributedDeviceProfile::AccessControlProfile profile1;
+    profile1.SetBindType(DM_IDENTICAL_ACCOUNT);
+    profiles.push_back(profile1);
+
+    DistributedDeviceProfile::AccessControlProfile profile2;
+    profile2.SetBindType(DM_ACROSS_ACCOUNT);
+    profile2.SetBindLevel(USER);
+    profiles.push_back(profile2);
+
+    DistributedDeviceProfile::AccessControlProfile profile3;
+    profile3.SetBindType(DM_ACROSS_ACCOUNT);
+    profile3.SetBindLevel(APP);
+    
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserUserId(userId);
+    accesser.SetAccesserTokenId(tokenId);
+    accesser.SetAccesserDeviceId(localUdid);
+    accesser.SetAccesserExtraData("5.1.0");
+    profile3.SetAccesser(accesser);
+    
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile3.SetAccessee(accessee);
+    
+    profiles.push_back(profile3);
+
+    std::string result = DeviceProfileConnector::GetInstance().GetAppServiceAuthVersionInfo(
+        localUdid, remoteUdid, tokenId, userId, profiles);
+    EXPECT_EQ(result, "5.1.0");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_001, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_002, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_IDENTICAL_ACCOUNT);
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles = {profile};
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_003, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(APP);
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles = {profile};
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_004, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(USER);
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId(localUdid);
+    accesser.SetAccesserExtraData("AccesserExtraData");
+    profile.SetAccesser(accesser);
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(remoteUdid);
+    profile.SetAccessee(accessee);
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles = {profile};
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "AccesserExtraData");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_005, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(USER);
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId(remoteUdid);
+    profile.SetAccesser(accesser);
+    DistributedDeviceProfile::Accessee accessee;
+    accessee.SetAccesseeDeviceId(localUdid);
+    accessee.SetAccesseeExtraData("AccesseeExtraData");
+    profile.SetAccessee(accessee);
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles = {profile};
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "AccesseeExtraData");
+}
+
+HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceAuthVersionInfo_006, testing::ext::TestSize.Level1)
+{
+    std::string localUdid = "localDeviceId";
+    std::string remoteUdid = "remoteDeviceId";
+    DistributedDeviceProfile::AccessControlProfile profile;
+    profile.SetBindType(DM_POINT_TO_POINT);
+    profile.SetBindLevel(USER);
+    DistributedDeviceProfile::Accesser accesser;
+    accesser.SetAccesserDeviceId("differentDeviceId");
+    profile.SetAccesser(accesser);
+    std::vector<DistributedDeviceProfile::AccessControlProfile> profiles = {profile};
+
+    std::string result = DeviceProfileConnector::GetInstance()
+        .GetDeviceAuthVersionInfo(localUdid, remoteUdid, profiles);
+    EXPECT_EQ(result, "");
+}
 HWTEST_F(DeviceProfileConnectorSecondTest, GetDeviceIdAndUdidListByTokenId_001, testing::ext::TestSize.Level1)
 {
     std::vector<int32_t> userIds;
diff --git a/test/unittest/UTTest_dm_pin_holder.cpp b/test/unittest/UTTest_dm_pin_holder.cpp
index 64ff9c5d8303a16afc1b78c1b9208f3cd1822f43..c5c0a8f116183c23e9b59154fe537a599330443c 100644
--- a/test/unittest/UTTest_dm_pin_holder.cpp
+++ b/test/unittest/UTTest_dm_pin_holder.cpp
@@ -1117,6 +1117,257 @@ HWTEST_F(DmPinHolderTest, OnSessionOpened_105, testing::ext::TestSize.Level1)
     pinHolderSession->OnSessionClosed(closeSessionId);
     EXPECT_EQ(ret, ERR_DM_FAILED);
 }
+
+HWTEST_F(DmPinHolderTest, CreatePinholder_109, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    PeerTargetId targetId = {
+        .deviceId = "deviceId",
+        .brMac = "brMac",
+        .bleMac = "bleMac",
+        .wifiIp = "wifiIp",
+    };
+
+    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
+    std::string payload;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->processInfo_.pkgName = packName;
+    pinHolder->processInfo_.userId = 100;
+    pinHolder->sourceState_ = SOURCE_INIT;
+    pinHolder->sessionId_ = 0;
+    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmPinHolderTest, CreatePinholder_110, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    PeerTargetId targetId = {
+        .deviceId = "deviceId",
+        .brMac = "brMac",
+        .bleMac = "bleMac",
+        .wifiIp = "wifiIp",
+    };
+    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
+    std::string payload;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->processInfo_.pkgName = packName;
+    pinHolder->processInfo_.userId = 100;
+    pinHolder->sourceState_ = SOURCE_INIT;
+    int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload);
+    ASSERT_EQ(ret, -1);
+}
+
+HWTEST_F(DmPinHolderTest, DestroyPinHolder_107, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    PeerTargetId targetId = {
+        .deviceId = "deviceId",
+        .brMac = "brMac",
+        .bleMac = "bleMac",
+        .wifiIp = "wifiIp",
+    };
+    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
+    std::string payload;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->processInfo_.pkgName = packName;
+    pinHolder->processInfo_.userId = 100;
+    pinHolder->sessionId_ = SESSION_ID_INVALID;
+    pinHolder->listener_ = std::make_shared<IDeviceManagerServiceListenerTest>();
+    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+ HWTEST_F(DmPinHolderTest, DestroyPinHolder_108, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    PeerTargetId targetId = {
+        .deviceId = "deviceId",
+        .brMac = "brMac",
+        .bleMac = "bleMac",
+        .wifiIp = "wifiIp",
+    };
+    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
+    std::string payload;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->processInfo_.pkgName = packName;
+    pinHolder->processInfo_.userId = 100;
+    pinHolder->sessionId_ = 0;
+    pinHolder->sourceState_ = SOURCE_CREATE;
+    pinHolder->listener_ = std::make_shared<IDeviceManagerServiceListenerTest>();
+    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
+    ASSERT_NE(ret, DM_OK);
+}
+
+HWTEST_F(DmPinHolderTest, DestroyPinHolder_109, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    PeerTargetId targetId = {
+        .deviceId = "deviceId",
+        .brMac = "brMac",
+        .bleMac = "bleMac",
+        .wifiIp = "wifiIp",
+    };
+    DmPinType pinType = DmPinType::NUMBER_PIN_CODE;
+    std::string payload;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->processInfo_.pkgName = packName;
+    pinHolder->processInfo_.userId = 100;
+    pinHolder->sessionId_ = 0;
+    pinHolder->sourceState_ = SOURCE_CREATE;
+    pinHolder->timer_ = std::make_shared<DmTimer>();
+    pinHolder->listener_ = std::make_shared<IDeviceManagerServiceListenerTest>();
+    int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload);
+    ASSERT_NE(ret, DM_OK);
+}
+ HWTEST_F(DmPinHolderTest, ProcessCloseSessionMsg_101, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message;
+    pinHolder->listener_ = nullptr;
+    pinHolder->ProcessCloseSessionMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, ProcessCloseSessionMsg_102, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message;
+    pinHolder->session_ = nullptr;
+    pinHolder->ProcessCloseSessionMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_106, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    JsonObject jsonObject;
+    jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC;
+    jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC;
+    std::string message = SafetyDump(jsonObject);
+    pinHolder->sinkState_ = SINK_CREATE;
+    pinHolder->ProcessDestroyMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+ HWTEST_F(DmPinHolderTest, CloseSession_102, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string name;
+    pinHolder->listener_ = nullptr;
+    pinHolder->CloseSession(name);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, CloseSession_103, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string name;
+    pinHolder->timer_ = std::make_shared<DmTimer>();
+    pinHolder->CloseSession(name);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, ProcessDestroyResMsg_101, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message;
+    pinHolder->ProcessDestroyResMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, ProcessDestroyResMsg_102, testing::ext::TestSize.Level1)
+{
+    JsonObject jsonObject;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message = SafetyDump(jsonObject);
+    jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE;
+    pinHolder->ProcessDestroyResMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, ProcessDestroyResMsg_103, testing::ext::TestSize.Level1)
+{
+    JsonObject jsonObject;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message = SafetyDump(jsonObject);
+    jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE;
+    pinHolder->session_ = nullptr;
+    pinHolder->ProcessDestroyResMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, ProcessDestroyResMsg_104, testing::ext::TestSize.Level1)
+{
+    JsonObject jsonObject;
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    std::string message = SafetyDump(jsonObject);
+    jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE;
+    pinHolder->listener_ = nullptr;
+    pinHolder->ProcessDestroyResMsg(message);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+ HWTEST_F(DmPinHolderTest, UnRegisterPinHolderCallback_101, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->session_ = nullptr;
+    int32_t ret = pinHolder->UnRegisterPinHolderCallback(packName);
+    ASSERT_EQ(ret, ERR_DM_FAILED);
+}
+
+HWTEST_F(DmPinHolderTest, UnRegisterPinHolderCallback_102, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    pinHolder->session_ = std::make_shared<PinHolderSession>();
+    int32_t ret = pinHolder->UnRegisterPinHolderCallback(packName);
+    ASSERT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmPinHolderTest, OnSessionClosed_101, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    int32_t sessionId = 1;
+    pinHolder->OnSessionClosed(sessionId);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+
+HWTEST_F(DmPinHolderTest, OnSessionClosed_102, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    int32_t sessionId = pinHolder->sessionId_;
+    pinHolder->timer_ = std::make_shared<DmTimer>();
+    pinHolder->OnSessionClosed(sessionId);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
+HWTEST_F(DmPinHolderTest, OnSessionClosed_103, testing::ext::TestSize.Level1)
+{
+    std::string packName = "com.ohos.dmtest";
+    std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<IDeviceManagerServiceListenerTest>();
+    std::shared_ptr<PinHolder> pinHolder = std::make_shared<PinHolder>(listener);
+    int32_t sessionId = pinHolder->sessionId_;
+    pinHolder->OnSessionClosed(sessionId);
+    ASSERT_NE(pinHolder->timer_, nullptr);
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file