diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
index ca6d2307db5ed6524e5559d37086a1239ca3df56..efe7b17aa13d8c7f4c94bc44e761f7b471e65c21 100644
--- a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
+++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
@@ -43,11 +43,12 @@ void DmDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 
 int32_t IpcClientManager::ClientInit()
 {
+    LOGI("Start");
     if (dmInterface_ != nullptr) {
-        LOGD("Already Init");
+        LOGI("DeviceManagerService Already Init");
         return DM_OK;
     }
-    LOGI("Start");
+
     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (samgr == nullptr) {
         LOGE("Get SystemAbilityManager Failed");
@@ -68,7 +69,7 @@ int32_t IpcClientManager::ClientInit()
         LOGE("InitDeviceManagerService: AddDeathRecipient Failed");
     }
     dmInterface_ = iface_cast<IpcRemoteBroker>(object);
-    LOGD("Completed");
+    LOGI("Completed");
     return DM_OK;
 }
 
@@ -85,7 +86,11 @@ int32_t IpcClientManager::Init(const std::string &pkgName)
         LOGE("InitDeviceManager Failed with ret %{public}d", ret);
         return ret;
     }
-    CHECK_SIZE_RETURN(dmListener_, ERR_DM_FAILED);
+    if (dmListener_.size() >= MAX_CONTAINER_SIZE) {
+        LOGE("dmListener_ size is more than max size");
+        return ERR_DM_FAILED;
+    }
+
     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
@@ -111,7 +116,7 @@ int32_t IpcClientManager::UnInit(const std::string &pkgName)
         LOGE("Invalid parameter, pkgName is empty.");
         return ERR_DM_INPUT_PARA_INVALID;
     }
-    LOGI("pkgName %{public}s", pkgName.c_str());
+    LOGI("UnInit in, pkgName %{public}s", pkgName.c_str());
     std::lock_guard<std::mutex> autoLock(lock_);
     if (dmInterface_ == nullptr) {
         LOGE("DeviceManager not Init");
@@ -136,7 +141,7 @@ int32_t IpcClientManager::UnInit(const std::string &pkgName)
         }
         dmInterface_ = nullptr;
     }
-    LOGD("completed, pkgName: %{public}s", pkgName.c_str());
+    LOGI("completed, pkgName: %{public}s", pkgName.c_str());
     return DM_OK;
 }
 
@@ -161,7 +166,7 @@ int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq> r
 
 int32_t IpcClientManager::OnDmServiceDied()
 {
-    LOGI("begin");
+    LOGI("IpcClientManager::OnDmServiceDied begin");
     {
         std::lock_guard<std::mutex> autoLock(lock_);
         if (dmInterface_ == nullptr) {
@@ -174,7 +179,7 @@ int32_t IpcClientManager::OnDmServiceDied()
         }
         dmInterface_ = nullptr;
     }
-    LOGD("complete");
+    LOGI("IpcClientManager::OnDmServiceDied complete");
     return DM_OK;
 }
 
diff --git a/interfaces/kits/ndk/include/dm_client.h b/interfaces/kits/ndk/include/dm_client.h
index 1201d76c2f18cd50e9e2a7ad3ae50944b632a2c1..b59b840dba4ba2ce514a2fa0b973e6fe1e6d8551 100644
--- a/interfaces/kits/ndk/include/dm_client.h
+++ b/interfaces/kits/ndk/include/dm_client.h
@@ -30,6 +30,13 @@ public:
     int32_t UnInit();
     int32_t ReInit();
     int32_t GetLocalDeviceName(std::string &deviceName);
+private:
+    DmClient() = default;
+    ~DmClient() = default;
+    DmClient(const DmClient &) = delete;
+    DmClient &operator=(const DmClient &) = delete;
+    DmClient(DmClient &&) = delete;
+    DmClient &operator=(DmClient &&) = delete;
 private:
     std::mutex initMtx_;
     std::string pkgName_ = "";
diff --git a/interfaces/kits/ndk/src/dm_client.cpp b/interfaces/kits/ndk/src/dm_client.cpp
index 2d5c6273e40a7402a385d48b4f922b370f3136a0..6eeae32881e1bdb5542b639bbda45bafe2c5335d 100644
--- a/interfaces/kits/ndk/src/dm_client.cpp
+++ b/interfaces/kits/ndk/src/dm_client.cpp
@@ -78,7 +78,7 @@ int32_t DmClient::GetLocalDeviceName(std::string &deviceName)
     ret = DeviceManager::GetInstance().GetLocalDeviceName(deviceName);
     if (ret != DM_OK) {
         LOGE("Get local device name failed, ret=%{public}d", ret);
-        return DM_ERR_OBTAIN_BUNDLE_NAME;
+        return DM_ERR_FAILED;
     }
     return ERR_OK;
 }
diff --git a/services/implementation/src/attest/dm_auth_attest_common.cpp b/services/implementation/src/attest/dm_auth_attest_common.cpp
index 2ac048f9d4328f2e79416b6e7d10eaebb9818411..de2ad7ce777d0cb0f37adf5ce0c7ab27b4a11da8 100644
--- a/services/implementation/src/attest/dm_auth_attest_common.cpp
+++ b/services/implementation/src/attest/dm_auth_attest_common.cpp
@@ -92,6 +92,10 @@ bool ValidateInputJson(const std::string &data)
 
  bool ProcessCertItem(const JsonItemObject &item, DmBlob &cert, uint32_t processedIndex)
  {
+    if (!item.IsString()) {
+        LOGE("input param is invalid.");
+        return false;
+    }
     std::string hexStr = item.Get<std::string>();
     const size_t hexLen = hexStr.length();
     if (hexLen == 0 || hexLen % HEX_TO_UINT8 != 0) {
@@ -158,12 +162,7 @@ bool AuthAttestCommon::DeserializeDmCertChain(const std::string &data, DmCertCha
         delete[] certs;
         return false;
     }
-    if (outChain->cert != nullptr) {
-        for (uint32_t i = 0; i < outChain->certCount; ++i) {
-            delete[] outChain->cert[i].data;
-        }
-        delete[] outChain->cert;
-    }
+    FreeDmCertChain(*outChain);
     outChain->cert = certs;
     outChain->certCount = certCount;
     return true;
@@ -171,16 +170,19 @@ bool AuthAttestCommon::DeserializeDmCertChain(const std::string &data, DmCertCha
 
 void AuthAttestCommon::FreeDmCertChain(DmCertChain &chain)
 {
-    if (chain.cert != nullptr) {
-        for (uint32_t i = 0; i < chain.certCount; ++i) {
+    if (chain.cert == nullptr) {
+        return;
+    }
+    for (uint32_t i = 0; i < chain.certCount; ++i) {
+        if (chain.cert[i].data != nullptr) {
             delete[] chain.cert[i].data;
             chain.cert[i].data = nullptr;
-            chain.cert[i].size = 0;
         }
-        delete[] chain.cert;
-        chain.cert = nullptr;
-        chain.certCount = 0;
+        chain.cert[i].size = 0;
     }
+    delete[] chain.cert;
+    chain.cert = nullptr;
+    chain.certCount = 0;
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/implementation/src/attest/dm_auth_cert.cpp b/services/implementation/src/attest/dm_auth_cert.cpp
index 1587ae6bc362b6fd00d7d5ca6086155d3ce301b1..4c57a9494784ae98a895b6075a3937a2c138fdb1 100644
--- a/services/implementation/src/attest/dm_auth_cert.cpp
+++ b/services/implementation/src/attest/dm_auth_cert.cpp
@@ -31,6 +31,11 @@ AuthCert::AuthCert()
 AuthCert::~AuthCert()
 {
     LOGD("AuthCert destructor");
+    if (authCertSoHandle_ != nullptr) {
+        LOGI("dm auth cert authCertSoHandle_ is not nullptr.");
+        dlclose(authCertSoHandle_);
+        authCertSoHandle_ = nullptr;
+    }
 }
 
 bool AuthCert::IsDMAdapterAuthCertLoaded()
diff --git a/services/service/include/relationshipsyncmgr/dm_comm_tool.h b/services/service/include/relationshipsyncmgr/dm_comm_tool.h
index ca1136c1307ee80cf48903d9ad271f31cc814a31..782c2404c28016e04a2cc8376c402fd47b9e895e 100644
--- a/services/service/include/relationshipsyncmgr/dm_comm_tool.h
+++ b/services/service/include/relationshipsyncmgr/dm_comm_tool.h
@@ -42,7 +42,7 @@ public:
     int32_t SendUnBindAppObj(int32_t userId, int32_t tokenId, const std::string &extra, const std::string &networkId,
         const std::string &udid);
 
-    void RspLocalFrontOrBackUserIds(const std::string rmtNetworkId, const std::vector<uint32_t> &foregroundUserIds,
+    void RspLocalFrontOrBackUserIds(const std::string &rmtNetworkId, const std::vector<uint32_t> &foregroundUserIds,
         const std::vector<uint32_t> &backgroundUserIds, int32_t socketId);
     int32_t CreateUserStopMessage(int32_t stopUserId, std::string &msgStr);
     int32_t SendMsg(const std::string rmtNetworkId, int32_t msgType, const std::string &msg);
@@ -51,8 +51,8 @@ public:
     void ProcessReceiveUserStopEvent(const std::shared_ptr<InnerCommMsg> commMsg);
     void RspUserStop(const std::string rmtNetworkId, int32_t socketId, int32_t stopUserId);
     void ProcessResponseUserStopEvent(const std::shared_ptr<InnerCommMsg> commMsg);
-    int32_t RspAppUninstall(const std::string rmtNetworkId, int32_t socketId);
-    int32_t RspAppUnbind(const std::string rmtNetworkId, int32_t socketId);
+    int32_t RspAppUninstall(const std::string &rmtNetworkId, int32_t socketId);
+    int32_t RspAppUnbind(const std::string &rmtNetworkId, int32_t socketId);
     void StopSocket(const std::string &networkId);
     void ProcessReceiveRspAppUninstallEvent(const std::shared_ptr<InnerCommMsg> commMsg);
     void ProcessReceiveRspAppUnbindEvent(const std::shared_ptr<InnerCommMsg> commMsg);
@@ -81,8 +81,8 @@ public:
     int32_t StartCommonEvent(std::string commonEventType, EventCallback eventCallback);
     void ProcessReceiveCommonEvent(const std::shared_ptr<InnerCommMsg> commMsg);
     void ProcessResponseCommonEvent(const std::shared_ptr<InnerCommMsg> commMsg);
-    void ProcessReceiveUninstAppEvent(const std::shared_ptr<InnerCommMsg> commMsg);
-    void ProcessReceiveUnBindAppEvent(const std::shared_ptr<InnerCommMsg> commMsg);
+    void ProcessReceiveUninstAppEvent(const std::shared_ptr<InnerCommMsg> &commMsg);
+    void ProcessReceiveUnBindAppEvent(const std::shared_ptr<InnerCommMsg> &commMsg);
 private:
     std::shared_ptr<DMTransport> dmTransportPtr_;
     std::shared_ptr<DMCommTool::DMCommToolEventHandler> eventHandler_;
diff --git a/services/service/src/publishcommonevent/dm_datashare_common_event.cpp b/services/service/src/publishcommonevent/dm_datashare_common_event.cpp
index fbf0fc8355d20d296b125e8d1d972834f15fa8d4..a18715aa233f84708fcedcb836b38b1a7059bac1 100644
--- a/services/service/src/publishcommonevent/dm_datashare_common_event.cpp
+++ b/services/service/src/publishcommonevent/dm_datashare_common_event.cpp
@@ -95,7 +95,6 @@ bool DmDataShareCommonEventManager::SubscribeDataShareCommonEvent(const std::vec
     return true;
 }
 
-//LCOV_EXCL_START
 bool DmDataShareCommonEventManager::UnsubscribeDataShareCommonEvent()
 {
     std::lock_guard<std::mutex> locker(evenSubscriberMutex_);
@@ -131,7 +130,6 @@ bool DmDataShareCommonEventManager::UnsubscribeDataShareCommonEvent()
     eventValidFlag_ = false;
     return true;
 }
-//LCOV_EXCL_STOP
 
 void DmDataShareEventSubscriber::OnReceiveEvent(const CommonEventData &data)
 {
diff --git a/services/service/src/relationshipsyncmgr/dm_comm_tool.cpp b/services/service/src/relationshipsyncmgr/dm_comm_tool.cpp
index 088d4e61c69e6213baedd49124667ae1330eb314..91d0905dcb79fa2867de1562c89e2a2ddfdd9b53 100644
--- a/services/service/src/relationshipsyncmgr/dm_comm_tool.cpp
+++ b/services/service/src/relationshipsyncmgr/dm_comm_tool.cpp
@@ -110,7 +110,7 @@ int32_t DMCommTool::SendUserIds(const std::string rmtNetworkId,
         LOGE("Send local foreground userids failed, ret: %{public}d", ret);
         return ERR_DM_FAILED;
     }
-    LOGI("success");
+    LOGI("Send local foreground userids success");
     return DM_OK;
 }
 
@@ -159,7 +159,7 @@ int32_t DMCommTool::SendUninstAppObj(int32_t userId, int32_t tokenId, const std:
     return DM_OK;
 }
 
-int32_t DMCommTool::RspAppUninstall(const std::string rmtNetworkId, int32_t socketId)
+int32_t DMCommTool::RspAppUninstall(const std::string &rmtNetworkId, int32_t socketId)
 {
     LOGI("RspAppUninstall Start.");
     if (dmTransportPtr_ == nullptr) {
@@ -184,7 +184,7 @@ int32_t DMCommTool::RspAppUninstall(const std::string rmtNetworkId, int32_t sock
     return DM_OK;
 }
 
-int32_t DMCommTool::RspAppUnbind(const std::string rmtNetworkId, int32_t socketId)
+int32_t DMCommTool::RspAppUnbind(const std::string &rmtNetworkId, int32_t socketId)
 {
     LOGI("RspAppUnbind Start.");
     if (dmTransportPtr_ == nullptr) {
@@ -258,7 +258,7 @@ int32_t DMCommTool::SendUnBindAppObj(int32_t userId, int32_t tokenId, const std:
     return DM_OK;
 }
 
-void DMCommTool::RspLocalFrontOrBackUserIds(const std::string rmtNetworkId,
+void DMCommTool::RspLocalFrontOrBackUserIds(const std::string &rmtNetworkId,
     const std::vector<uint32_t> &foregroundUserIds, const std::vector<uint32_t> &backgroundUserIds, int32_t socketId)
 {
     UserIdsMsg userIdsMsg(foregroundUserIds, backgroundUserIds, true);
@@ -288,7 +288,7 @@ void DMCommTool::RspLocalFrontOrBackUserIds(const std::string rmtNetworkId,
         LOGE("Response local foreground userids failed, ret: %{public}d", ret);
         return;
     }
-    LOGI("success");
+    LOGI("Response local foreground userids success");
 }
 
 DMCommTool::DMCommToolEventHandler::DMCommToolEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> runner,
@@ -393,7 +393,7 @@ void DMCommTool::DMCommToolEventHandler::HandleLocalUserIdEvent(const std::share
 
 void DMCommTool::ProcessReceiveCommonEvent(const std::shared_ptr<InnerCommMsg> commMsg)
 {
-    LOGI("start");
+    LOGI("ProcessReceiveCommonEvent, process and rsp local userid");
     std::string rmtUdid = "";
     SoftbusCache::GetInstance().GetUdidFromCache(commMsg->remoteNetworkId.c_str(), rmtUdid);
     if (rmtUdid.empty()) {
@@ -436,7 +436,7 @@ void DMCommTool::ProcessReceiveCommonEvent(const std::shared_ptr<InnerCommMsg> c
 
 void DMCommTool::ProcessResponseCommonEvent(const std::shared_ptr<InnerCommMsg> commMsg)
 {
-    LOGI("start");
+    LOGI("process receive remote userids response");
     // step1: close socket
     this->dmTransportPtr_->StopSocket(commMsg->remoteNetworkId);
 
@@ -462,7 +462,7 @@ void DMCommTool::ProcessResponseCommonEvent(const std::shared_ptr<InnerCommMsg>
 
 void DMCommTool::ProcessReceiveUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg)
 {
-    LOGI("start");
+    LOGI("Receive remote userids, process and rsp local userid");
     std::string rmtUdid = "";
     SoftbusCache::GetInstance().GetUdidFromCache(commMsg->remoteNetworkId.c_str(), rmtUdid);
     if (rmtUdid.empty()) {
@@ -510,7 +510,7 @@ void DMCommTool::ProcessReceiveUserIdsEvent(const std::shared_ptr<InnerCommMsg>
     }
 }
 
-void DMCommTool::ProcessReceiveUninstAppEvent(const std::shared_ptr<InnerCommMsg> commMsg)
+void DMCommTool::ProcessReceiveUninstAppEvent(const std::shared_ptr<InnerCommMsg> &commMsg)
 {
     if (commMsg == nullptr || commMsg->commMsg == nullptr) {
         LOGE("commMsg or commMsg->commMsg is null");
@@ -539,7 +539,7 @@ void DMCommTool::ProcessReceiveUninstAppEvent(const std::shared_ptr<InnerCommMsg
     }
 }
 
-void DMCommTool::ProcessReceiveUnBindAppEvent(const std::shared_ptr<InnerCommMsg> commMsg)
+void DMCommTool::ProcessReceiveUnBindAppEvent(const std::shared_ptr<InnerCommMsg> &commMsg)
 {
     if (commMsg == nullptr || commMsg->commMsg == nullptr) {
         LOGE("commMsg or commMsg->commMsg is null");
@@ -569,7 +569,7 @@ void DMCommTool::ProcessReceiveUnBindAppEvent(const std::shared_ptr<InnerCommMsg
 
 void DMCommTool::StopSocket(const std::string &networkId)
 {
-    LOGI("DMCommTool::StopSocket, networkId = %{public}s", GetAnonyString(networkId).c_str());
+    LOGI("DMCommTool::StopSocket, networkId = %{public}s", networkId.c_str());
     if (dmTransportPtr_ == nullptr) {
         LOGE("dmTransportPtr_ is null");
         return;
@@ -621,7 +621,7 @@ void DMCommTool::ProcessReceiveRspAppUnbindEvent(const std::shared_ptr<InnerComm
 
 void DMCommTool::ProcessResponseUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg)
 {
-    LOGI("start");
+    LOGI("process receive remote userids response");
     // step1: close socket
     this->dmTransportPtr_->StopSocket(commMsg->remoteNetworkId);
 
@@ -846,7 +846,7 @@ int32_t DMCommTool::SendLogoutAccountInfo(const std::string &rmtNetworkId,
         LOGE("Send account logout failed, ret: %{public}d", ret);
         return ERR_DM_FAILED;
     }
-    LOGI("success");
+    LOGI("Send account logout success");
     return DM_OK;
 }
 
@@ -881,7 +881,7 @@ void DMCommTool::ProcessReceiveLogoutEvent(const std::shared_ptr<InnerCommMsg> c
     }
     DeviceManagerService::GetInstance().ProcessSyncAccountLogout(logoutAccountMsg.accountId,
         rmtUdid, logoutAccountMsg.userId);
-    LOGI("success.");
+    LOGI("process remote logout success.");
 }
 
 int32_t DMCommTool::StartCommonEvent(std::string commonEventType, EventCallback eventCallback)
@@ -891,7 +891,7 @@ int32_t DMCommTool::StartCommonEvent(std::string commonEventType, EventCallback
         return ERR_DM_INPUT_PARA_INVALID;
     }
     CHECK_NULL_RETURN(eventQueue_, ERR_DM_POINT_NULL);
-    LOGI("start eventType: %{public}s", commonEventType.c_str());
+    LOGI("StartCommonEvent start eventType: %{public}s", commonEventType.c_str());
     std::lock_guard<std::mutex> locker(eventMutex_);
     auto taskFunc = [eventCallback] () { eventCallback(); };
     eventQueue_->submit(taskFunc);
diff --git a/services/service/src/softbus/softbus_publish.cpp b/services/service/src/softbus/softbus_publish.cpp
index c6ccd4425f086fa19e4777531c28140fb8756c1c..94a605c1424d5e3ecc1614a5e4c0d1614cfb893b 100644
--- a/services/service/src/softbus/softbus_publish.cpp
+++ b/services/service/src/softbus/softbus_publish.cpp
@@ -40,7 +40,7 @@ std::mutex g_publishMutex;
 
 void PublishCommonEventCallback(int32_t bluetoothState, int32_t wifiState, int32_t screenState)
 {
-    LOGI("start, bleState: %{public}d, wifiState: %{public}d, screenState: %{public}d",
+    LOGI("PublishCommonEventCallback start, bleState: %{public}d, wifiState: %{public}d, screenState: %{public}d",
         bluetoothState, wifiState, screenState);
     std::lock_guard<std::mutex> saLock(g_publishMutex);
     DmDeviceInfo info;
@@ -49,6 +49,7 @@ void PublishCommonEventCallback(int32_t bluetoothState, int32_t wifiState, int32
         LOGE("deviceType: %{public}d is watch, not publish", static_cast<int32_t>(info.deviceTypeId));
         return;
     }
+    LOGI("deviceType: %{public}d", static_cast<int32_t>(info.deviceTypeId));
     SoftbusPublish softbusPublish;
     if (screenState == DM_SCREEN_OFF) {
         int32_t ret = softbusPublish.StopPublishSoftbusLNN(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID);
@@ -100,7 +101,7 @@ SoftbusPublish::~SoftbusPublish()
 
 void SoftbusPublish::OnSoftbusPublishResult(int publishId, PublishResult result)
 {
-    LOGD("publishId: %{public}d, result: %{public}d.", publishId, result);
+    LOGD("OnSoftbusPublishResult, publishId: %{public}d, result: %{public}d.", publishId, result);
 }
 
 int32_t SoftbusPublish::PublishSoftbusLNN()
@@ -113,7 +114,10 @@ int32_t SoftbusPublish::PublishSoftbusLNN()
     publishInfo.capability = DM_CAPABILITY_OSD;
     publishInfo.ranging = false;
 
-    LOGI("Begin");
+    LOGI("Begin, publishId: %{public}d, mode: 0x%{public}x, medium: %{public}d, capability:"
+        "%{public}s, ranging: %{public}d, freq: %{public}d.", publishInfo.publishId, publishInfo.mode,
+        publishInfo.medium, publishInfo.capability, publishInfo.ranging, publishInfo.freq);
+
     int32_t ret = PublishLNN(DM_PKG_NAME, &publishInfo, &softbusPublishCallback_);
     if (ret != DM_OK) {
         LOGE("[SOFTBUS]PublishLNN failed, ret: %{public}d.", ret);
diff --git a/test/commonfuzztest/authcredential_fuzzer/auth_credential_fuzzer.h b/test/commonfuzztest/authcredential_fuzzer/auth_credential_fuzzer.h
index 6e30090a78af52782e611ce889b13336f8a51412..79e49a457e9e3c1445eecd7c8386e478cb33260e 100644
--- a/test/commonfuzztest/authcredential_fuzzer/auth_credential_fuzzer.h
+++ b/test/commonfuzztest/authcredential_fuzzer/auth_credential_fuzzer.h
@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
-#ifndef AUTH_ACL_FUZZER_H
-#define AUTH_ACL_FUZZER_H
+#ifndef AUTH_CREDENTIAL_FUZZER_H
+#define AUTH_CREDENTIAL_FUZZER_H
 
-#define FUZZ_PROJECT_NAME "authacl_fuzzer"
+#define FUZZ_PROJECT_NAME "authcredential_fuzzer"
 
-#endif // AUTH_ACL_FUZZER_H
\ No newline at end of file
+#endif // AUTH_CREDENTIAL_FUZZER_H
\ No newline at end of file
diff --git a/test/commonunittest/UTTest_discovery_manager.cpp b/test/commonunittest/UTTest_discovery_manager.cpp
index 64fd6de726af282366cfc00d5043f08311923f4f..1fba2eea82e88b311d40fa6d5a4215f82429e7e7 100644
--- a/test/commonunittest/UTTest_discovery_manager.cpp
+++ b/test/commonunittest/UTTest_discovery_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -307,6 +307,27 @@ HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_003, testing::ext::TestSize.L
     EXPECT_NE(manager->discoveryContextMap_.empty(), true);
 }
 
+HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_004, testing::ext::TestSize.Level0)
+{
+    std::string pkgName = "pkgName";
+    int32_t subscribeId = 1;
+    int32_t result = 1;
+    manager->pkgNameSet_.insert(pkgName);
+    DiscoveryContext context;
+    manager->discoveryContextMap_.emplace(pkgName, context);
+    manager->listener_ = std::make_shared<DeviceManagerServiceListener>();
+    manager->OnDiscoveringResult(pkgName, subscribeId, result);
+    EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
+}
+
+HWTEST_F(DiscoveryManagerTest, StartDiscoveryTimer_001, testing::ext::TestSize.Level0)
+{
+    manager->timer_ = nullptr;
+    std::string pkgName = "timeTest";
+    manager->StartDiscoveryTimer(pkgName);
+    EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
+}
+
 HWTEST_F(DiscoveryManagerTest, HandleDiscoveryQueue_001, testing::ext::TestSize.Level0)
 {
     std::string pkgName = "pkgName";
@@ -356,6 +377,19 @@ HWTEST_F(DiscoveryManagerTest, GetDeviceAclParam_001, testing::ext::TestSize.Lev
     EXPECT_EQ(ret, DM_OK);
 }
 
+HWTEST_F(DiscoveryManagerTest, GetCommonDependencyObj_001, testing::ext::TestSize.Level0)
+{
+    auto ret = manager->GetCommonDependencyObj();
+    EXPECT_NE(ret, nullptr);
+}
+
+HWTEST_F(DiscoveryManagerTest, IsCommonDependencyReady_001, testing::ext::TestSize.Level0)
+{
+    manager->isSoLoaded_ = false;
+    bool ret = manager->IsCommonDependencyReady();
+    EXPECT_EQ(ret, true);
+}
+
 HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_001, testing::ext::TestSize.Level0)
 {
     manager->isSoLoaded_ = false;
diff --git a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/BUILD.gn b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/BUILD.gn
index a7e9c70382236ee1d7ae696f97438bb8ea36608b..6a5abb9a62502c5ca118b590a2ffc4bd08843fc8 100755
--- a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/BUILD.gn
+++ b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+# Copyright (c) 2025 Huawei Device Co., Ltd.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
diff --git a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/corpus/init b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/corpus/init
index 79c5ba7b76709fb31f739049a3ce0441f6af4327..490dc43564005848ae0dfbd1d6f79cd81c28e2db 100755
--- a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/corpus/init
+++ b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/corpus/init
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+# Copyright (c) 2025 Huawei Device Co., Ltd.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
diff --git a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/project.xml b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/project.xml
index afd90798db45dd3853b00cf9c476ad4b245107e1..9613ca7b6153d89b284e3278cfd8a1723dfdf40a 100755
--- a/test/interfacesfuzztest/devicemanagerimpl_fuzzer/project.xml
+++ b/test/interfacesfuzztest/devicemanagerimpl_fuzzer/project.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+<!-- Copyright (c) 2025 Huawei Device Co., Ltd.
 
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
diff --git a/test/servicesfuzztest/authmanager_fuzzer/auth_manager_fuzzer.cpp b/test/servicesfuzztest/authmanager_fuzzer/auth_manager_fuzzer.cpp
index 0e8e6668bdd0b2f11ed685f36b299f3286cd419f..26923ede83e36a066f1bdc902420afbeec357a73 100644
--- a/test/servicesfuzztest/authmanager_fuzzer/auth_manager_fuzzer.cpp
+++ b/test/servicesfuzztest/authmanager_fuzzer/auth_manager_fuzzer.cpp
@@ -384,32 +384,6 @@ void HandleBusinessEventsFuzzTest(FuzzedDataProvider &fdp)
     authManager->PrepareSoftbusSessionCallback();
 }
 
-void CheckProxyAuthParamVaildFuzzTest(FuzzedDataProvider &fdp)
-{
-    std::string extra = fdp.ConsumeRandomLengthString();
-    authManager->CheckProxyAuthParamVaild(extra);
-
-    JsonObject jsonObject;
-    jsonObject[PARAM_KEY_IS_PROXY_BIND] = "true";
-    std::string bundleNameDemoA = "com.ohos.devicemanagerdemoA";
-    std::string bundleNameDemoGame = "com.game.gamenearbydemo";
-    JsonObject jsonA;
-    jsonA["pakgName"] = bundleNameDemoA;
-    jsonA["bundleName"] = bundleNameDemoA;
-
-    JsonObject jsonGame;
-    jsonGame["pakgName"] = bundleNameDemoGame;
-    jsonGame["bundleName"] = bundleNameDemoGame;
-
-    JsonObject subJsonArr(JsonCreateType::JSON_CREATE_TYPE_ARRAY);
-    subJsonArr.PushBack(jsonA);
-    subJsonArr.PushBack(jsonGame);
-    jsonObject[PARAM_KEY_SUBJECT_PROXYED_SUBJECTS] = subJsonArr.Dump();
-    std::string extra1 = jsonObject.Dump();
-    authManager->CheckProxyAuthParamVaild(extra1);
-    authManager->ParseProxyJsonObject(jsonObject);
-}
-
 void ParseProxyJsonObjectFuzzTest(FuzzedDataProvider &fdp)
 {
     JsonObject jsonObject;
@@ -473,7 +447,6 @@ void AuthManagerFuzzTest(const uint8_t* data, size_t size)
     AuthSinkDeviceSessionKeyFuzzTest(fdp);
     AuthSinkDeviceRequestFuzzTest(fdp);
     HandleBusinessEventsFuzzTest(fdp);
-    CheckProxyAuthParamVaildFuzzTest(fdp);
     ParseProxyJsonObjectFuzzTest(fdp);
     GetBindLevelByBundleNameFuzzTest(fdp);
 }
diff --git a/test/servicesfuzztest/dmsoftbuslistener_fuzzer/dm_softbus_listener_fuzzer.cpp b/test/servicesfuzztest/dmsoftbuslistener_fuzzer/dm_softbus_listener_fuzzer.cpp
index c2471bb76c80e64816efd178a8ce09417acfca5e..d189ad1ae564f1616ab3bcc7942f9807718585fd 100644
--- a/test/servicesfuzztest/dmsoftbuslistener_fuzzer/dm_softbus_listener_fuzzer.cpp
+++ b/test/servicesfuzztest/dmsoftbuslistener_fuzzer/dm_softbus_listener_fuzzer.cpp
@@ -33,7 +33,7 @@ void DmSoftbusListenerFuzzTestNext(FuzzedDataProvider &fdp)
 {
     SoftbusListener listener;
     std::string networkIdStr = fdp.ConsumeRandomLengthString();
-    if (!networkIdStr.empty()) { 
+    if (!networkIdStr.empty()) {
         int32_t networkType = fdp.ConsumeIntegral<std::int32_t>();
         listener.GetNetworkTypeByNetworkId(networkIdStr.c_str(), networkType);
     }
diff --git a/test/servicesfuzztest/hichainlistener_fuzzer/BUILD.gn b/test/servicesfuzztest/hichainlistener_fuzzer/BUILD.gn
index 9af74300d622a309b6c1e10b8f52acce15500687..f1da9be7cd685b2b201baa2725aeefcde839c778 100644
--- a/test/servicesfuzztest/hichainlistener_fuzzer/BUILD.gn
+++ b/test/servicesfuzztest/hichainlistener_fuzzer/BUILD.gn
@@ -81,8 +81,6 @@ ohos_fuzztest("HiChainListenerFuzzTest") {
     "napi:ace_napi",
     "safwk:system_ability_fwk",
   ]
-
-  public_deps = [ "${utils_path}:devicemanagerutilstest" ]
 }
 
 ###############################################################################
diff --git a/test/servicesfuzztest/ipcmodelcodec_fuzzer/BUILD.gn b/test/servicesfuzztest/ipcmodelcodec_fuzzer/BUILD.gn
index 2f9a6ef537f3cace7dcdb28567e4dbbb6d819b98..40b27a7c9b326670819a9d1c020e66e4c351e432 100644
--- a/test/servicesfuzztest/ipcmodelcodec_fuzzer/BUILD.gn
+++ b/test/servicesfuzztest/ipcmodelcodec_fuzzer/BUILD.gn
@@ -67,7 +67,10 @@ ohos_fuzztest("IpcModelCodecFuzzTest") {
     "LOG_DOMAIN=0xD004110",
   ]
 
-  deps = [ "${innerkits_path}/native_cpp:devicemanagersdk" ]
+  deps = [
+    "${innerkits_path}/native_cpp:devicemanagersdk",
+    "${utils_path}:devicemanagerutilstest"
+    ]
 
   external_deps = [
     "c_utils:utils",
@@ -77,8 +80,6 @@ ohos_fuzztest("IpcModelCodecFuzzTest") {
     "napi:ace_napi",
     "safwk:system_ability_fwk",
   ]
-
-  public_deps = [ "${utils_path}:devicemanagerutilstest" ]
 }
 
 ###############################################################################
diff --git a/test/softbusunittest/UTTest_softbus_listener.cpp b/test/softbusunittest/UTTest_softbus_listener.cpp
index 6408c81478fe877e484e89cf09095d00aaa2b849..b68adb9009a20b6800cabcdacb1a2ca4b98e94dc 100644
--- a/test/softbusunittest/UTTest_softbus_listener.cpp
+++ b/test/softbusunittest/UTTest_softbus_listener.cpp
@@ -122,7 +122,7 @@ HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceOnline_001, testing::ext::TestSize.
     }
     softbusListener->OnSoftbusDeviceOnline(&info);
     softbusListener->OnSoftbusDeviceOffline(&info);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 /**
@@ -189,7 +189,7 @@ HWTEST_F(SoftbusListenerTest, DeviceOnLine_001, testing::ext::TestSize.Level1)
     softbusListener->DeviceOnLine(deviceInf);
     softbusListener->DeviceNameChange(deviceInf);
     softbusListener->DeviceOffLine(deviceInf);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_001, testing::ext::TestSize.Level1)
@@ -200,7 +200,7 @@ HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_001, testing::ext::Test
         softbusListener = std::make_shared<SoftbusListener>();
     }
     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_002, testing::ext::TestSize.Level1)
@@ -212,7 +212,7 @@ HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_002, testing::ext::Test
         softbusListener = std::make_shared<SoftbusListener>();
     }
     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_003, testing::ext::TestSize.Level1)
@@ -224,7 +224,7 @@ HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_003, testing::ext::Test
         softbusListener = std::make_shared<SoftbusListener>();
     }
     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceFound_001, testing::ext::TestSize.Level1)
@@ -234,7 +234,7 @@ HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceFound_001, testing::ext::TestSize.L
         softbusListener = std::make_shared<SoftbusListener>();
     }
     softbusListener->OnSoftbusDeviceFound(device);
-    EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
+    EXPECT_NE(softbusListener->isRadarSoLoad_, true);
 }
 
 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceFound_002, testing::ext::TestSize.Level1)
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 5342cfb74d7af959f1b5f3c89f0ef41d9064d567..53280a13ecad922482dedfce42d84da4fdc5a0c0 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -45,6 +45,8 @@ group("unittest") {
     ":UTTest_discovery_manager",
     ":UTTest_dm_account_common_event",
     ":UTTest_dm_adapter_manager",
+    ":UTTest_dm_auth_attest_common",
+    ":UTTest_dm_auth_cert",
     ":UTTest_dm_anonymous",
     ":UTTest_dm_auth_manager_first",
     ":UTTest_dm_auth_manager_second",
@@ -161,6 +163,48 @@ ohos_unittest("UTTest_pin_auth_ui") {
 
 ## UnitTest UTTest_pin_auth_ui }}}
 
+## UnitTest UTTest_dm_auth_attest_common {{{
+ohos_unittest("UTTest_dm_auth_attest_common") {
+  module_out_path = module_out_path
+
+  sources = [ "UTTest_dm_auth_attest_common.cpp" ]
+ 
+  deps = [ ":device_manager_test_common" ]
+ 
+  external_deps = [
+    "device_auth:deviceauth_sdk",
+    "device_info_manager:distributed_device_profile_common",
+    "device_info_manager:distributed_device_profile_sdk",
+    "dsoftbus:softbus_client",
+    "ffrt:libffrt",
+    "googletest:gmock",
+    "hilog:libhilog",
+  ]
+}
+ 
+## UnitTest UTTest_dm_auth_attest_common }}}
+ 
+## UnitTest UTTest_dm_auth_cert {{{
+ohos_unittest("UTTest_dm_auth_cert") {
+  module_out_path = module_out_path
+ 
+  sources = [ "UTTest_dm_auth_cert.cpp" ]
+ 
+  deps = [ ":device_manager_test_common" ]
+ 
+  external_deps = [
+    "device_auth:deviceauth_sdk",
+    "device_info_manager:distributed_device_profile_common",
+    "device_info_manager:distributed_device_profile_sdk",
+    "dsoftbus:softbus_client",
+    "ffrt:libffrt",
+    "googletest:gmock",
+    "hilog:libhilog",
+  ]
+}
+ 
+## UnitTest UTTest_dm_auth_cert }}}
+
 ## UnitTest UTTest_ipc_cmd_parser_client {{{
 ohos_unittest("UTTest_ipc_cmd_parser_client") {
   module_out_path = module_out_path
diff --git a/test/unittest/UTTest_auth_acl.cpp b/test/unittest/UTTest_auth_acl.cpp
index 922aa65f5becb5172be34b0e84b4b33c923231f9..8b2be452d2f50640c18274234aad5d58ade24978 100644
--- a/test/unittest/UTTest_auth_acl.cpp
+++ b/test/unittest/UTTest_auth_acl.cpp
@@ -61,23 +61,6 @@ void AuthAclTest::TearDown()
     Mock::VerifyAndClearExpectations(&*DmSoftbusSession::dmSoftbusSession);
 }
 
-HWTEST_F(AuthAclTest, AuthSinkAcl_001, testing::ext::TestSize.Level1)
-{
-    authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
-        hiChainAuthConnector);
-    context = authManager->GetAuthContext();
-    std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSinkDataSyncState>();
-    context->accessee.deviceId = "accessee_deviceId";
-    context->accesser.deviceId = "accesser_deviceId";
-    context->accesser.aclStrList = "aclList";
-    EXPECT_CALL(*dmSoftbusConnectorMock, SyncLocalAclListProcess(_, _, _)).WillOnce(Return(DM_OK));
-    EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
-        .WillOnce(Return(TEST_NONE_EMPTY_STRING));
-    EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
-
-    EXPECT_EQ(authState->Action(context), DM_OK);
-}
-
 HWTEST_F(AuthAclTest, AuthSinkAcl_002, testing::ext::TestSize.Level1)
 {
     authManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector, listener,
@@ -88,21 +71,6 @@ HWTEST_F(AuthAclTest, AuthSinkAcl_002, testing::ext::TestSize.Level1)
     EXPECT_EQ(authState->GetStateType(), DmAuthStateType::AUTH_SINK_DATA_SYNC_STATE);
 }
 
-HWTEST_F(AuthAclTest, AuthSrcAcl_001, testing::ext::TestSize.Level1)
-{
-    authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
-        hiChainAuthConnector);
-    context = authManager->GetAuthContext();
-    std::shared_ptr<DmAuthState> authState = std::make_shared<AuthSrcDataSyncState>();
-    context->direction = DM_AUTH_SOURCE;
-    context->accesser.isAuthed = true; // no need to agree acl
-    context->accesser.isOnline = true; // no need to join network
-    EXPECT_CALL(*DmAuthMessageProcessorMock::dmAuthMessageProcessorMock, CreateMessage(_, _))
-        .WillOnce(Return(TEST_NONE_EMPTY_STRING));
-    EXPECT_CALL(*dmSoftbusSessionMock, SendData(_, _)).WillOnce(Return(DM_OK));
-    EXPECT_EQ(authState->Action(context), DM_OK);
-}
-
 HWTEST_F(AuthAclTest, AuthSrcAcl_002, testing::ext::TestSize.Level1)
 {
     authManager = std::make_shared<AuthSrcManager>(softbusConnector, hiChainConnector, listener,
diff --git a/test/unittest/UTTest_auth_manager.cpp b/test/unittest/UTTest_auth_manager.cpp
index 0e6a8cf857f6c67b583d0d96147ef8ae1b171ba2..c9dba1afba1aaa6acae4e97d2a01e09d97bbfc10 100644
--- a/test/unittest/UTTest_auth_manager.cpp
+++ b/test/unittest/UTTest_auth_manager.cpp
@@ -24,6 +24,7 @@ namespace DistributedHardware {
 
 void AuthManagerTest::SetUp()
 {
+    InitDeviceAuthService();
     softbusConnector = std::make_shared<SoftbusConnector>();
     deviceManagerServicelistener = std::make_shared<DeviceManagerServiceListener>();
     hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
diff --git a/test/unittest/UTTest_dm_auth_attest_common.cpp b/test/unittest/UTTest_dm_auth_attest_common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..325166bde5f204934205510215837140a71dd9de
--- /dev/null
+++ b/test/unittest/UTTest_dm_auth_attest_common.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+#include "gtest/gtest.h"
+#include "dm_auth_cert.h"
+#include "dm_error_type.h"
+#include "dm_log.h"
+#include "UTTest_dm_auth_attest_common.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+
+void DmAuthAttestCommonTest::SetUp()
+{
+}
+void DmAuthAttestCommonTest::TearDown()
+{
+}
+void DmAuthAttestCommonTest::SetUpTestCase()
+{
+}
+void DmAuthAttestCommonTest::TearDownTestCase()
+{
+}
+
+/**
+ * @tc.name: SerializeDmCertChain_001
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthAttestCommonTest, SerializeDmCertChain_001, testing::ext::TestSize.Level1) {
+    AuthAttestCommon authAttestCommon;
+    DmCertChain *chain = nullptr;
+    std::string result = authAttestCommon.SerializeDmCertChain(chain);
+    EXPECT_EQ(result, "{}");
+}
+
+/**
+ * @tc.name: DeserializeDmCertChain_001
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthAttestCommonTest, DeserializeDmCertChain_001, testing::ext::TestSize.Level1) {
+    AuthAttestCommon authAttestCommon;
+    std::string data = R"({"certCount":2,"cert":["cert1","cert2"]})";
+    DmCertChain *outChain = nullptr;
+
+    bool result = authAttestCommon.DeserializeDmCertChain(data, outChain);
+
+    EXPECT_FALSE(result);
+}
+
+/**
+ * @tc.name: DeserializeDmCertChain_002
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthAttestCommonTest, DeserializeDmCertChain_002, testing::ext::TestSize.Level1) {
+    AuthAttestCommon authAttestCommon;
+    std::string data = "";
+    DmCertChain outChain;
+
+    bool result = authAttestCommon.DeserializeDmCertChain(data, &outChain);
+
+    EXPECT_FALSE(result);
+}
+}
+}
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_auth_attest_common.h b/test/unittest/UTTest_dm_auth_attest_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..46b2b622569021ab606cf88af09ef76e33010827
--- /dev/null
+++ b/test/unittest/UTTest_dm_auth_attest_common.h
@@ -0,0 +1,41 @@
+/*
+* Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTTEST_DM_AUTH_ATTEST_COMMON_H
+#define UTTEST_DM_AUTH_ATTEST_COMMON_H
+
+#include <gtest/gtest.h>
+#include <string>
+#include <securec.h>
+#include "hichain_auth_connector_mock.h"
+#include "softbus_session_mock.h"
+#include "dm_auth_state_machine_mock.h"
+#include "dm_auth_attest_common.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+
+
+class DmAuthAttestCommonTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+
+}
+}
+#endif
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_auth_cert.cpp b/test/unittest/UTTest_dm_auth_cert.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf223dc20e8335447e1a8725dfa82a549a179db6
--- /dev/null
+++ b/test/unittest/UTTest_dm_auth_cert.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+#include "gtest/gtest.h"
+#include "dm_auth_cert.h"
+#include "dm_error_type.h"
+#include "dm_log.h"
+#include "UTTest_dm_auth_cert.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+
+void DmAuthCertTest::SetUp()
+{
+}
+void DmAuthCertTest::TearDown()
+{
+}
+void DmAuthCertTest::SetUpTestCase()
+{
+}
+void DmAuthCertTest::TearDownTestCase()
+{
+}
+
+/**
+ * @tc.name  : VerifyCertificate_ShouldReturnFailed_WhenCertModuleNotLoaded
+ * @tc.number: VerifyCertificateTest_001
+ * @tc.desc  : 测试当认证证书模块未加载时,VerifyCertificate 函数应返回 ERR_DM_FAILED
+ */
+HWTEST_F(DmAuthCertTest, VerifyCertificate_001, testing::ext::TestSize.Level1) {
+    DmCertChain dmCertChain;
+    AuthCert authCert;
+    const char *deviceIdHash = "testDeviceIdHash";
+    int32_t result = authCert.VerifyCertificate(dmCertChain, deviceIdHash);
+    EXPECT_NE(result, ERR_DM_INPUT_PARA_INVALID);
+}
+
+/**
+ * @tc.name: IsDMAdapterAuthCertLoaded_001
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthCertTest, IsDMAdapterAuthCertLoaded_001, testing::ext::TestSize.Level1) {
+    AuthCert authCert;
+    authCert.isAdapterAuthCertSoLoaded_ = false;
+    bool result = authCert.IsDMAdapterAuthCertLoaded();
+    EXPECT_EQ(result, false);
+}
+
+/**
+ * @tc.name: IsDMAdapterAuthCertLoaded_002
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthCertTest, IsDMAdapterAuthCertLoaded_002, testing::ext::TestSize.Level1) {
+    AuthCert authCert;
+    authCert.isAdapterAuthCertSoLoaded_ = true;
+    authCert.dmAuthCertExt_ = std::shared_ptr<IDMAuthCertExt>();
+    bool result = authCert.IsDMAdapterAuthCertLoaded();
+    EXPECT_NE(result, true);
+}
+
+/**
+ * @tc.name: GenerateCertificate_001
+ * @tc.type: FUNC
+ */
+HWTEST_F(DmAuthCertTest, GenerateCertificate_001, testing::ext::TestSize.Level1) {
+    AuthCert authCert;
+    DmCertChain dmCertChain;
+    int32_t result = authCert.GenerateCertificate(dmCertChain);
+    int32_t errCode = -10005;
+    EXPECT_NE(result, errCode);
+}
+}
+}
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_auth_cert.h b/test/unittest/UTTest_dm_auth_cert.h
new file mode 100644
index 0000000000000000000000000000000000000000..59a1587668fdfcf98d491fadbe15ff2e7514ebbb
--- /dev/null
+++ b/test/unittest/UTTest_dm_auth_cert.h
@@ -0,0 +1,39 @@
+/*
+* Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTTEST_DM_AUTH_CERT_H
+#define UTTEST_DM_AUTH_CERT_H
+
+#include <gtest/gtest.h>
+#include "hichain_auth_connector_mock.h"
+#include "softbus_session_mock.h"
+#include "dm_auth_state_machine_mock.h"
+#include "dm_auth_cert.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+
+
+class DmAuthCertTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+};
+
+}
+}
+#endif
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_auth_message_processor.cpp b/test/unittest/UTTest_dm_auth_message_processor.cpp
index 94ed79026b013795ebaa7211e4072bc751b4f190..52214cbc97bda84b925b38791ddcb00d42be2ed3 100644
--- a/test/unittest/UTTest_dm_auth_message_processor.cpp
+++ b/test/unittest/UTTest_dm_auth_message_processor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
diff --git a/test/unittest/UTTest_dm_import_auth_code.cpp b/test/unittest/UTTest_dm_import_auth_code.cpp
index c7ad2bb7cefb5d6b16c55a887677d2ac86678469..67f0fba6f410620bc4b7d51c8deba4f968394a76 100644
--- a/test/unittest/UTTest_dm_import_auth_code.cpp
+++ b/test/unittest/UTTest_dm_import_auth_code.cpp
@@ -72,8 +72,8 @@ HWTEST_F(DMImportAuthCodeTest, ImportAuthCode_001, testing::ext::TestSize.Level0
     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(pkgName, initcallback);
     ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
-    bool result = (ret == ERR_DM_NO_PERMISSION) || (ret == DM_OK);
-    ASSERT_EQ(result, true);
+    bool res = (ret == ERR_DM_NO_PERMISSION) || (ret == DM_OK);
+    ASSERT_EQ(res, true);
     DeviceManager::GetInstance().UnInitDeviceManager(pkgName);
 }
 
@@ -84,8 +84,8 @@ HWTEST_F(DMImportAuthCodeTest, ExportAuthCode_001, testing::ext::TestSize.Level0
     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(pkgName, initcallback);
     ret = DeviceManager::GetInstance().ExportAuthCode(authCode);
-    bool result = (ret == ERR_DM_NO_PERMISSION) || (ret == DM_OK);
-    ASSERT_EQ(result, true);
+    bool res = (ret == ERR_DM_NO_PERMISSION) || (ret == DM_OK);
+    ASSERT_EQ(res, true);
     DeviceManager::GetInstance().UnInitDeviceManager(pkgName);
 }
 
diff --git a/test/unittest/mock/dm_softbus_error_code.h b/test/unittest/mock/dm_softbus_error_code.h
index 87c4790d4be2b1ece1deeb8b160d10b9c0d1a576..746604d6d6b4157316116441c2dfec898bfff3c1 100644
--- a/test/unittest/mock/dm_softbus_error_code.h
+++ b/test/unittest/mock/dm_softbus_error_code.h
@@ -25,6 +25,8 @@ namespace OHOS {
 namespace DistributedHardware {
 constexpr int32_t SOFTBUS_IPC_ERR = -426442720;
 constexpr int32_t SOFTBUS_INVALID_PARAM = -426442749;
+constexpr int32_t SOFTBUS_PERMISSION_DENIED = -426442743;
+constexpr int32_t SOFTBUS_NETWORK_NOT_INIT = -426049518;
 constexpr int32_t SOFTBUS_WIFI_DIRECT_INIT_FAILED = -426442707;
 constexpr int32_t SOFTBUS_ERR = -426442706;
 constexpr int32_t SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM = -425799671;