diff --git a/test/commonunittest/UTTest_discovery_manager.cpp b/test/commonunittest/UTTest_discovery_manager.cpp
index d73b1f55fb93909aa00cc31101a5d5a8d038d6ae..a6b14fdfc5a1f0d6f8cad0bb60cb2d4123aca3c7 100644
--- a/test/commonunittest/UTTest_discovery_manager.cpp
+++ b/test/commonunittest/UTTest_discovery_manager.cpp
@@ -358,6 +358,259 @@ HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_002, testing::ext::TestS
     bool ret = manager->CloseCommonDependencyObj();
     EXPECT_EQ(ret, true);
 }
+
+HWTEST_F(DiscoveryManagerTest, OnDeviceFound_003, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgName";
+    uint32_t capabilityType = 1;
+    DmDeviceInfo info;
+    DeviceFilterPara filterPara;
+    manager->OnDeviceFound(pkgName, capabilityType, info, filterPara);
+    EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
+
+    DiscoveryContext context;
+    manager->discoveryContextMap_.emplace(pkgName, context);
+
+    manager->OnDeviceFound(pkgName, capabilityType, info, filterPara);
+    EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
+    manager->discoveryContextMap_.erase(pkgName);
+}
+
+HWTEST_F(DiscoveryManagerTest, CompareCapability_001, testing::ext::TestSize.Level0)
+{
+    uint32_t capabilityType = 1;
+    std::string capabilityStr = "capabilityStr";
+    auto ret = manager->CompareCapability(capabilityType, capabilityStr);
+    EXPECT_EQ(ret, false);
+
+    capabilityStr = "hicall";
+    ret = manager->CompareCapability(capabilityType, capabilityStr);
+    EXPECT_EQ(ret, true);
+}
+
+HWTEST_F(DiscoveryManagerTest, UpdateInfoFreq_001, testing::ext::TestSize.Level0)
+{
+    std::map<std::string, std::string> discoverParam;
+    discoverParam.emplace(PARAM_KEY_DISC_FREQ, "8");
+    DmSubscribeInfo dmSubInfo;
+    dmSubInfo.freq = DM_MID;
+    manager->UpdateInfoFreq(discoverParam, dmSubInfo);
+    EXPECT_EQ(dmSubInfo.freq, DM_MID);
+
+    discoverParam[PARAM_KEY_DISC_FREQ] = "3";
+    manager->UpdateInfoFreq(discoverParam, dmSubInfo);
+    EXPECT_EQ(dmSubInfo.freq, DM_SUPER_HIGH);
+}
+
+HWTEST_F(DiscoveryManagerTest, UpdateInfoMedium_001, testing::ext::TestSize.Level0)
+{
+    std::map<std::string, std::string> discoverParam;
+    discoverParam.emplace(PARAM_KEY_DISC_MEDIUM, "8");
+    DmSubscribeInfo dmSubInfo;
+
+    manager->UpdateInfoMedium(discoverParam, dmSubInfo);
+    EXPECT_EQ(dmSubInfo.medium, 8);
+}
+
+HWTEST_F(DiscoveryManagerTest, ClearDiscoveryCache_001, testing::ext::TestSize.Level0)
+{
+    ProcessInfo processInfo;
+    processInfo.pkgName = "pkgName";
+    processInfo.userId = 1;
+
+    
+    EXPECT_NO_THROW(manager->ClearDiscoveryCache(processInfo));
+}
+
+HWTEST_F(DiscoveryManagerTest, ClearDiscoveryPkgName_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgName";
+    std::set<uint16_t> subscribeIdSet;
+    DiscoveryContext context;
+    context.subscribeId = 1;
+    auto &pkgNameSet = manager->pkgNameSet_;
+    auto &discoveryContextMap = manager->discoveryContextMap_;
+    auto &capabilityMap = manager->capabilityMap_;
+
+    
+    pkgNameSet.emplace("1");
+    discoveryContextMap.emplace(pkgName, context);
+    capabilityMap.emplace(pkgName, "123");
+    subscribeIdSet.insert(discoveryContextMap[pkgName].subscribeId);
+
+    
+    auto ret = manager->ClearDiscoveryPkgName(pkgName);
+    
+    
+    EXPECT_EQ(ret, subscribeIdSet);
+    EXPECT_EQ(pkgNameSet.find(pkgName), pkgNameSet.end());
+    EXPECT_EQ(capabilityMap.find(pkgName), capabilityMap.end());
+}
+
+HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_004, testing::ext::TestSize.Level0)
+{
+    std::string pkgName;
+    std::map<std::string, std::string> extraParam;
+    extraParam.emplace(PARAM_KEY_SUBSCRIBE_ID, "123");
+    int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
+HWTEST_F(DiscoveryManagerTest, ConfigDiscParam_001, testing::ext::TestSize.Level0)
+{
+    std::map<std::string, std::string> discoverParam;
+    DmSubscribeInfo *dmSubInfo;
+    dmSubInfo = nullptr;
+    
+    EXPECT_NO_THROW(manager->ConfigDiscParam(discoverParam, dmSubInfo););
+
+    dmSubInfo = new DmSubscribeInfo();
+    discoverParam.emplace(PARAM_KEY_DISC_FREQ, "1");
+    discoverParam.emplace(PARAM_KEY_DISC_MODE, "170");
+    manager->ConfigDiscParam(discoverParam, dmSubInfo);
+    EXPECT_EQ(dmSubInfo->freq, DM_MID);
+    EXPECT_EQ(dmSubInfo->mode, DM_DISCOVER_MODE_ACTIVE);
+    
+
+    delete dmSubInfo;
+    dmSubInfo = nullptr;
+}
+
+
+HWTEST_F(DiscoveryManagerTest, StartDiscoveringNoMetaType_005, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgNameTest05";
+    DmSubscribeInfo dmSubInfo;
+    std::map<std::string, std::string> param;
+
+    param.emplace("DISC_CAPABILITY", "1");
+    int32_t ret = manager->StartDiscoveringNoMetaType(pkgName, dmSubInfo, param);
+    EXPECT_NE(ret, DM_OK);
+}
+
+HWTEST_F(DiscoveryManagerTest, StartDiscovering4MetaType_005, testing::ext::TestSize.Level0)
+{
+    DmSubscribeInfo dmSubInfo;
+    std::string pkgName = "pkgNameTest05";
+    std::map<std::string, std::string> param;
+    param.emplace("CUSTOM_DATA", "1");
+    param.emplace("META_TYPE", "5");
+    int32_t ret = manager->StartDiscovering4MetaType(pkgName, dmSubInfo, param);
+    EXPECT_NE(ret, DM_OK);
+}
+
+HWTEST_F(DiscoveryManagerTest, StopDiscoveringByInnerSubId_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "";
+    uint16_t subscribeId = 0;
+    int32_t ret = manager->StopDiscoveringByInnerSubId(pkgName, subscribeId);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
+
+HWTEST_F(DiscoveryManagerTest, OnDeviceFound_004, testing::ext::TestSize.Level0)
+{
+    std::string pkgName;
+    DmDeviceInfo info;
+    bool isOnline = false;
+
+    info.extraData = R"({"identicalCredType":1,"DISC_CAPABILITY":1,"pointTopointCredType":256,"lnnCredType":3})";
+
+    manager->OnDeviceFound(pkgName, info, isOnline);
+
+    EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
+}
+
+HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_004, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgName";
+    int32_t subscribeId = 1;
+    int32_t result = 1;
+    manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
+    manager->OnDiscoveringResult(pkgName, subscribeId, result);
+    EXPECT_NE(manager->discoveryContextMap_.empty(), true);
+}
+
+HWTEST_F(DiscoveryManagerTest, StartDiscoveryTimer_004, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgName";
+
+    manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
+    manager->StartDiscoveryTimer(pkgName);
+
+    EXPECT_NE(manager->timer_, nullptr);
+}
+
+HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_003, testing::ext::TestSize.Level0)
+{
+    manager->isSoLoaded_ = true;
+
+    manager->dpConnector_ = nullptr;
+    manager->dpConnectorHandle_ = nullptr;
+    
+    bool ret = manager->CloseCommonDependencyObj();
+    EXPECT_EQ(ret, false);
+}
+
+    
+HWTEST_F(DiscoveryManagerTest, ClearDiscoveryCache_002, testing::ext::TestSize.Level0)
+{
+    ProcessInfo processInfo;
+    processInfo.pkgName = "pkgName";
+    processInfo.userId = 1;
+    DiscoveryContext context;
+
+    auto &pkgNameSet = manager->pkgNameSet_;
+    auto &discoveryContextMap = manager->discoveryContextMap_;
+    auto &capabilityMap = manager->capabilityMap_;
+    
+    pkgNameSet.emplace("1");
+    discoveryContextMap.emplace(processInfo.pkgName, context);
+    capabilityMap.emplace(processInfo.pkgName, "123");
+
+    EXPECT_NO_THROW(manager->ClearDiscoveryCache(processInfo));
+
+    pkgNameSet.erase("1");
+    discoveryContextMap.erase(processInfo.pkgName);
+    capabilityMap.erase(processInfo.pkgName);
+}
+
+HWTEST_F(DiscoveryManagerTest, ClearDiscoveryPkgName_002, testing::ext::TestSize.Level0)
+{
+    string pkgName = "1";
+    DiscoveryContext context;
+
+    auto &pkgNameSet = manager->pkgNameSet_;
+    auto &discoveryContextMap = manager->discoveryContextMap_;
+    auto &capabilityMap = manager->capabilityMap_;
+
+    
+    pkgNameSet.emplace("1");
+    discoveryContextMap.emplace(pkgName, context);
+    capabilityMap.emplace(pkgName, "123");
+
+
+    EXPECT_NO_THROW(manager->ClearDiscoveryPkgName(pkgName));
+
+    pkgNameSet.erase("1");
+    discoveryContextMap.erase(pkgName);
+    capabilityMap.erase(pkgName);
+}
+
+HWTEST_F(DiscoveryManagerTest, GetPkgNameAndUserId_001, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "1";
+    std::string callerPkgName;
+    int32_t userId;
+    MultiUserDiscovery multiUserDiscovery;
+    multiUserDiscovery.pkgName = "1";
+    multiUserDiscovery.userId = 123;
+    manager->multiUserDiscMap_.emplace("1", multiUserDiscovery);
+
+    manager->GetPkgNameAndUserId(pkgName, callerPkgName, userId);
+    EXPECT_EQ(userId, manager->multiUserDiscMap_["1"].userId);
+
+    manager->multiUserDiscMap_.erase("1");
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/softbusunittest/UTTest_softbus_connector.cpp b/test/softbusunittest/UTTest_softbus_connector.cpp
index 7d97ecee6ed72975ee1f41599c66f7caf37ac763..f16f5d6b083232fdd16bbf889bf9216111e7b6d0 100644
--- a/test/softbusunittest/UTTest_softbus_connector.cpp
+++ b/test/softbusunittest/UTTest_softbus_connector.cpp
@@ -414,9 +414,10 @@ HWTEST_F(SoftbusConnectorTest, ConvertDeviceInfoToDmDevice_001, testing::ext::Te
  */
 HWTEST_F(SoftbusConnectorTest, JoinLnn_001, testing::ext::TestSize.Level1)
 {
-    std::string deviceId;
+    std::string deviceId = "";
+    const std::string remoteUdidHash = "";
     std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
-    softbusConnector->JoinLnn(deviceId);
+    softbusConnector->JoinLnn(deviceId, remoteUdidHash);
     EXPECT_EQ(SoftbusConnector::discoveryDeviceInfoMap_.empty(), true);
 }
 
@@ -845,6 +846,165 @@ HWTEST_F(SoftbusConnectorTest, GetDeviceUdidHashByUdid_002, testing::ext::TestSi
     bool isForceJoin = false;
     softbusConnector->JoinLnn(deviceId, isForceJoin);
 }
+
+HWTEST_F(SoftbusConnectorTest, SyncAclList_001, testing::ext::TestSize.Level1)
+{
+    int32_t userId = 1;
+    std::string credId = "";
+    int32_t sessionKeyId = 1;
+    int32_t aclId = 1;
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    softbusConnector->hiChainAuthConnector_ = nullptr;
+    EXPECT_NO_THROW(softbusConnector->SyncAclList(userId, credId, sessionKeyId, aclId));
+
+    softbusConnector->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
+    EXPECT_NO_THROW(softbusConnector->SyncAclList(userId, credId, sessionKeyId, aclId));
+}
+
+HWTEST_F(SoftbusConnectorTest, SyncLocalAclList5_1_0_001, testing::ext::TestSize.Level1)
+{
+    const std::string localUdid = "123";
+    const std::string remoteUdid = "321";
+
+    OHOS::DistributedDeviceProfile::AccessControlProfile localAcl;
+    std::vector<std::string> acLStrList = {""};
+    OHOS::DistributedDeviceProfile::Accesser accesser;
+    OHOS::DistributedDeviceProfile::Accessee accessee;
+    accesser.SetAccesserId(123);
+    accessee.SetAccesseeId(321);
+    localAcl.SetAccesser(accesser);
+    localAcl.SetAccessee(accessee);
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->SyncLocalAclList5_1_0(localUdid, remoteUdid, localAcl, acLStrList);
+    EXPECT_EQ(ret, 0);
+
+    accesser.SetAccesserId(321);
+    accessee.SetAccesseeId(123);
+    localAcl.SetAccesser(accesser);
+    localAcl.SetAccessee(accessee);
+    ret = softbusConnector->SyncLocalAclList5_1_0(localUdid, remoteUdid, localAcl, acLStrList);
+    EXPECT_EQ(ret, 0);
+}
+
+HWTEST_F(SoftbusConnectorTest, UnRegisterConnectorCallback_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->UnRegisterConnectorCallback();
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, ParaseAclChecksumList_001, testing::ext::TestSize.Level1)
+{
+    std::string jsonString = "";
+    std::vector<AclHashItem> remoteAllAclList;
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+
+    int32_t ret = softbusConnector->ParaseAclChecksumList(jsonString, remoteAllAclList);
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+
+    jsonString.assign(R"({"identicalCredType":1,"shareCredType":2,"pointTopointCredType":256,"lnnCredType":3})");
+
+    ret = softbusConnector->ParaseAclChecksumList(jsonString, remoteAllAclList);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, GetLocalVersion_001, testing::ext::TestSize.Level1)
+{
+    const std::string localUdid = "123";
+    const std::string remoteUdid = "321";
+    std::string localVersion;
+    OHOS::DistributedDeviceProfile::AccessControlProfile localAcl;
+    OHOS::DistributedDeviceProfile::Accesser accesser;
+    OHOS::DistributedDeviceProfile::Accessee accessee;
+    accesser.SetAccesserId(123456789);
+    accessee.SetAccesseeId(321654987);
+    localAcl.SetAccesser(accesser);
+    localAcl.SetAccessee(accessee);
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->GetLocalVersion(localUdid, remoteUdid, localVersion, localAcl);
+    EXPECT_EQ(ret, DM_OK);
+
+    accesser.SetAccesserId(321);
+    accessee.SetAccesseeId(123);
+    localAcl.SetAccesser(accesser);
+    localAcl.SetAccessee(accessee);
+    ret = softbusConnector->GetLocalVersion(localUdid, remoteUdid, localVersion, localAcl);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, SortAclListDesc_001, testing::ext::TestSize.Level1)
+{
+    std::vector<AclHashItem> remoteAllAclList;
+    struct AclHashItem aclHashItem;
+    aclHashItem.version = "1";
+    aclHashItem.aclHashList.push_back({});
+    remoteAllAclList.push_back(aclHashItem);
+    aclHashItem.version = "2";
+    remoteAllAclList.push_back(aclHashItem);
+    aclHashItem.version = "3";
+    remoteAllAclList.push_back(aclHashItem);
+    std::vector<std::string> aclVerDesc;
+    
+    std::map<std::string, AclHashItem> remoteAllAclMap;
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    EXPECT_NO_THROW(softbusConnector->SortAclListDesc(remoteAllAclList, aclVerDesc, remoteAllAclMap)) ;
+}
+
+HWTEST_F(SoftbusConnectorTest, SyncLocalAclListProcess_001, testing::ext::TestSize.Level1)
+{
+    DevUserInfo localDevUserInfo;
+    DevUserInfo remoteDevUserInfo;
+    std::string remoteAclList = {""};
+    
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    EXPECT_EQ(softbusConnector->SyncLocalAclListProcess(localDevUserInfo, remoteDevUserInfo,
+        remoteAclList), ERR_DM_FAILED);
+
+    remoteAclList = "123";
+    EXPECT_EQ(softbusConnector->SyncLocalAclListProcess(localDevUserInfo, remoteDevUserInfo, remoteAclList), DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, GetAclListHash_001, testing::ext::TestSize.Level1)
+{
+    DevUserInfo localDevUserInfo;
+    DevUserInfo remoteDevUserInfo;
+    std::string aclList = {""};
+    
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    EXPECT_EQ(softbusConnector->GetAclListHash(localDevUserInfo, remoteDevUserInfo, aclList), DM_OK);
+}
+
+/**
+ * @tc.name: JoinLnn_002
+ * @tc.type: FUNC
+ */
+HWTEST_F(SoftbusConnectorTest, JoinLnn_002, testing::ext::TestSize.Level1)
+{
+    std::string deviceId("123");
+    std::string remoteUdidHash("");
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    EXPECT_NO_THROW(softbusConnector->JoinLnn(deviceId, remoteUdidHash));
+}
+
+HWTEST_F(SoftbusConnectorTest, JoinLNNBySkId_002, testing::ext::TestSize.Level1)
+{
+    int32_t sessionId = 0;
+    int32_t sessionKeyId = 0;
+    int32_t remoteSessionKeyId = 0;
+    std::string udid = "";
+    std::string udidHash = "";
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    EXPECT_NO_THROW(softbusConnector->JoinLNNBySkId(sessionId, sessionKeyId, remoteSessionKeyId, udid, udidHash));
+
+    udid = "123546789";
+    EXPECT_NO_THROW(softbusConnector->JoinLNNBySkId(sessionId, sessionKeyId, remoteSessionKeyId, udid, udidHash));
+
+    sessionKeyId = 1;
+    remoteSessionKeyId = 1;
+    EXPECT_NO_THROW(softbusConnector->JoinLNNBySkId(sessionId, sessionKeyId, remoteSessionKeyId, udid, udidHash));
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS-
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_comm_tool.cpp b/test/unittest/UTTest_dm_comm_tool.cpp
index 1d940323223f1bbe760cbf27f678680ec39f5950..8246a5d5d7e8d4b73040e3058254c394d9f2ddbe 100644
--- a/test/unittest/UTTest_dm_comm_tool.cpp
+++ b/test/unittest/UTTest_dm_comm_tool.cpp
@@ -468,6 +468,219 @@ HWTEST_F(DMCommToolTest, ProcessResponseUserStopEvent_004, testing::ext::TestSiz
     EXPECT_NO_THROW(dmCommTool->ProcessResponseUserStopEvent(commMsg));
 }
 
+HWTEST_F(DMCommToolTest, ParseUserIdsMsg_001, testing::ext::TestSize.Level1)
+{
+    std::string invalidNetworkMsg = "";
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, invalidNetworkMsg);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    UserIdsMsg userIdsMsg;
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ParseUserIdsMsg(commMsg, userIdsMsg));
+}
+
+HWTEST_F(DMCommToolTest, ParseUserIdsMsg_002, testing::ext::TestSize.Level1)
+{
+    std::string validJson = R"({ "stopUserId": 12345 })";
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, validJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    UserIdsMsg userIdsMsg;
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ParseUserIdsMsg(commMsg, userIdsMsg));
+}
+
+HWTEST_F(DMCommToolTest, ProcessReceiveCommonEvent_001, testing::ext::TestSize.Level1)
+{
+    std::string errjson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid"
+        })";
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, errjson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->ProcessReceiveCommonEvent(commMsg));
+}
+
+HWTEST_F(DMCommToolTest, ProcessReceiveCommonEvent_002, testing::ext::TestSize.Level1)
+{
+    std::string errjson = "";
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, errjson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_NO_THROW(dmCommTool->ProcessReceiveCommonEvent(commMsg));
+}
+
+HWTEST_F(DMCommToolTest, ProcessResponseCommonEvent_001, testing::ext::TestSize.Level1)
+{
+    std::string errjson = "";
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(1, errjson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_NO_THROW(dmCommTool->ProcessResponseCommonEvent(commMsg));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_001, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 1
+        "isNewEvent": "true",
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_002, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 1
+        "isNewEvent": "false",
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_003, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 2,
+        "isNewEvent": "true"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_004, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 2,
+        "isNewEvent": "false"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_005, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 3,
+        "isNewEvent": "false"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_006, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 4,
+        "isNewEvent": "false"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_007, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": 5,
+        "isNewEvent": "false"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, ProcessEvent_008, testing::ext::TestSize.Level1)
+{
+    std::string msgJson = R"({
+        "userId": 12345,
+        "networkId": "networkId",
+        "remoteUdid": "remoteUdid",
+        "innerEventId_": -1,
+        "isNewEvent": "false"
+        })";
+    int32_t msgCode = 1;
+    std::shared_ptr<CommMsg> commMsg_ = std::make_shared<CommMsg>(msgCode, msgJson);
+    std::shared_ptr<InnerCommMsg> commMsg = std::make_shared<InnerCommMsg>("networkId", commMsg_, 0);
+    AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg_->code, commMsg);
+    EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _))
+        .WillOnce(DoAll(SetArgReferee<1>("validUdid"), Return(DM_OK)));
+    EXPECT_CALL(*dmTransportMock_, Send(_, _, _)).WillOnce(Return(DM_OK));
+    EXPECT_NO_THROW(dmCommTool->eventHandler_->ProcessEvent(msgEvent));
+}
+
+HWTEST_F(DMCommToolTest, SendLogoutAccountInfo_001, testing::ext::TestSize.Level1)
+{
+    std::string rmtNetworkId;
+    rmtNetworkId.append(300, 'a');
+    std::string accountId = "accountId";
+    int32_t userId = 12345;
+    auto ret = dmCommTool->SendLogoutAccountInfo(rmtNetworkId, accountId, userId);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
+}
 HWTEST_F(DMCommToolTest, SendUninstAppObj_001, testing::ext::TestSize.Level1)
 {
     int32_t userId = 0;