diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_capability_info_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_capability_info_manager.h
index 425466ea30c66f8d55f6f57c6101fd677787b64e..af43086033dd71abd7c1228e313ff0d3f9bc64a5 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_capability_info_manager.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_capability_info_manager.h
@@ -30,7 +30,7 @@ public:
         std::shared_ptr<CapabilityInfo> &capPtr) = 0;
     virtual void GetCapabilitiesByDeviceId(const std::string &deviceId,
         std::vector<std::shared_ptr<CapabilityInfo>> &resInfos);
-    static std::shared_ptr<ICapabilityInfoManager> GetOrCtreateInstance();
+    static std::shared_ptr<ICapabilityInfoManager> GetOrCreateInstance();
     static void ReleaseInstance();
 
 private:
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_component_loader.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_component_loader.h
index 71b1a4d272a27c2c481a7cef6c73110c70591632..7217678e198eb19e630eef852ee51717b0209fdc 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_component_loader.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_component_loader.h
@@ -37,7 +37,7 @@ public:
     virtual int32_t GetLocalDHVersion(DHVersion &dhVersion) = 0;
     virtual std::map<std::string, bool> GetCompResourceDesc() = 0;
 
-    static std::shared_ptr<IComponentLoader> GetOrCtreateInstance();
+    static std::shared_ptr<IComponentLoader> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IComponentLoader> componentLoaderInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_device_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_device_manager.h
index 9539b2ee122c70ea452910ff95240178a6640fbe..3021b601ef7a843989b161652b82755244eae97f 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_device_manager.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_device_manager.h
@@ -27,7 +27,7 @@ public:
     virtual ~IDeviceManager() = default;
     virtual int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
     std::vector<DmDeviceInfo> &deviceList) = 0;
-    static std::shared_ptr<IDeviceManager> GetOrCtreateInstance();
+    static std::shared_ptr<IDeviceManager> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IDeviceManager> deviceManagerInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_context.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_context.h
index 90548c78e59affc2cc16097a4de5ef295cc47d26..e11debfcca2527a9d846e139f0355919efd537ee 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_context.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_context.h
@@ -29,7 +29,7 @@ public:
     virtual const DeviceInfo& GetDeviceInfo() = 0;
     virtual std::string GetUUIDByNetworkId(const std::string &networkId) = 0;
     virtual std::string GetUUIDByDeviceId(const std::string &deviceId) = 0;
-    static std::shared_ptr<IDHContext> GetOrCtreateInstance();
+    static std::shared_ptr<IDHContext> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IDHContext> dHContextInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_utils_tool.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_utils_tool.h
index b7b742bec42f1c77646b251b7ec6c97564518659..a422595fa827c18cab85bdc6b0b3deac13ed367f 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_utils_tool.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_dh_utils_tool.h
@@ -27,7 +27,7 @@ public:
     virtual ~IDHUtilTool() = default;
 
     virtual DeviceInfo GetLocalDeviceInfo() = 0;
-    static std::shared_ptr<IDHUtilTool> GetOrCtreateInstance();
+    static std::shared_ptr<IDHUtilTool> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IDHUtilTool> UtilToolInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_meta_info_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_meta_info_manager.h
index 79bc99852800a23052713841575231e22e07aaa6..afa4c787c5bd3b8a913afbcc7b9fa276ff9f8201 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_meta_info_manager.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_meta_info_manager.h
@@ -30,7 +30,7 @@ public:
     virtual int32_t GetMetaCapInfo(const std::string &udidHash,
         const std::string &dhId, std::shared_ptr<MetaCapabilityInfo> &metaCapPtr);
 
-    static std::shared_ptr<IMetaInfoManager> GetOrCtreateInstance();
+    static std::shared_ptr<IMetaInfoManager> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IMetaInfoManager> metaInfoManagerInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_version_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_version_manager.h
index 843b071c5d7b7da160a7e1ea9d76d7189bfc7cee..e0916c207a8396651897bfc151d8bb369abaf7da 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_version_manager.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/include/mock_version_manager.h
@@ -27,7 +27,7 @@ public:
     virtual ~IVersionManager() = default;
     virtual int32_t GetCompVersion(const std::string &uuid, const DHType dhType, CompVersion &compVersion) = 0;
 
-    static std::shared_ptr<IVersionManager> GetOrCtreateInstance();
+    static std::shared_ptr<IVersionManager> GetOrCreateInstance();
     static void ReleaseInstance();
 private:
     static std::shared_ptr<IVersionManager> versionManagerInstance_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test_ext.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test_ext.cpp
index 614645cbce193485990748c1791544e8ff438e6a..b243ae070a67c1d948dfb48e23f5eb6be868ca33 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test_ext.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test_ext.cpp
@@ -74,19 +74,19 @@ void ComponentManagerTestExt::TearDownTestCase(void)
 
 void ComponentManagerTestExt::SetUp()
 {
-    auto capabilityInfoManager = ICapabilityInfoManager::GetOrCtreateInstance();
+    auto capabilityInfoManager = ICapabilityInfoManager::GetOrCreateInstance();
     capabilityInfoManager_ = std::static_pointer_cast<MockCapabilityInfoManager>(capabilityInfoManager);
-    auto componentLoader = IComponentLoader::GetOrCtreateInstance();
+    auto componentLoader = IComponentLoader::GetOrCreateInstance();
     componentLoader_ = std::static_pointer_cast<MockComponentLoader>(componentLoader);
-    auto dhContext = IDHContext::GetOrCtreateInstance();
+    auto dhContext = IDHContext::GetOrCreateInstance();
     dhContext_ = std::static_pointer_cast<MockDHContext>(dhContext);
-    auto utilTool = IDHUtilTool::GetOrCtreateInstance();
+    auto utilTool = IDHUtilTool::GetOrCreateInstance();
     utilTool_ = std::static_pointer_cast<MockDHUtilTool>(utilTool);
-    auto metaInfoManager = IMetaInfoManager::GetOrCtreateInstance();
+    auto metaInfoManager = IMetaInfoManager::GetOrCreateInstance();
     metaInfoManager_ = std::static_pointer_cast<MockMetaInfoManager>(metaInfoManager);
-    auto versionManager = IVersionManager::GetOrCtreateInstance();
+    auto versionManager = IVersionManager::GetOrCreateInstance();
     versionManager_ = std::static_pointer_cast<MockVersionManager>(versionManager);
-    auto deviceManager = IDeviceManager::GetOrCtreateInstance();
+    auto deviceManager = IDeviceManager::GetOrCreateInstance();
     deviceManager_ = std::static_pointer_cast<MockDeviceManager>(deviceManager);
 }
 
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_capability_info_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_capability_info_manager.cpp
index 8096d3b272f749c8b5011968babc572dbea29ef2..1e2b97714e8b64a21b4148a383f5532c507f6bd7 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_capability_info_manager.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_capability_info_manager.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<ICapabilityInfoManager> ICapabilityInfoManager::CapabilityInfoManagerInstance_;
 
-std::shared_ptr<ICapabilityInfoManager> ICapabilityInfoManager::GetOrCtreateInstance()
+std::shared_ptr<ICapabilityInfoManager> ICapabilityInfoManager::GetOrCreateInstance()
 {
     if (!CapabilityInfoManagerInstance_) {
         CapabilityInfoManagerInstance_ = std::make_shared<MockCapabilityInfoManager>();
@@ -36,13 +36,13 @@ void ICapabilityInfoManager::ReleaseInstance()
 int32_t CapabilityInfoManager::GetCapability(const std::string &deviceId, const std::string &dhId,
     std::shared_ptr<CapabilityInfo> &capPtr)
 {
-    return ICapabilityInfoManager::GetOrCtreateInstance()->GetCapability(deviceId, dhId, capPtr);
+    return ICapabilityInfoManager::GetOrCreateInstance()->GetCapability(deviceId, dhId, capPtr);
 }
 
 void CapabilityInfoManager::GetCapabilitiesByDeviceId(const std::string &deviceId,
     std::vector<std::shared_ptr<CapabilityInfo>> &resInfos)
 {
-    ICapabilityInfoManager::GetOrCtreateInstance()->GetCapabilitiesByDeviceId(deviceId, resInfos);
+    ICapabilityInfoManager::GetOrCreateInstance()->GetCapabilitiesByDeviceId(deviceId, resInfos);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_component_loader.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_component_loader.cpp
index b1142a09aa1960190c71c8d54ec138b41f7841fe..da3fb01adf23a61a433b8264854bdfabbaf9cb79 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_component_loader.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_component_loader.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IComponentLoader> IComponentLoader::componentLoaderInstance_;
 
-std::shared_ptr<IComponentLoader> IComponentLoader::GetOrCtreateInstance()
+std::shared_ptr<IComponentLoader> IComponentLoader::GetOrCreateInstance()
 {
     if (!componentLoaderInstance_) {
         componentLoaderInstance_ = std::make_shared<MockComponentLoader>();
@@ -35,52 +35,52 @@ void IComponentLoader::ReleaseInstance()
 
 bool ComponentLoader::IsDHTypeSupport(DHType dhType)
 {
-    return IComponentLoader::GetOrCtreateInstance()->IsDHTypeSupport(dhType);
+    return IComponentLoader::GetOrCreateInstance()->IsDHTypeSupport(dhType);
 }
 
 int32_t ComponentLoader::GetSink(const DHType dhType, IDistributedHardwareSink *&sinkPtr)
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetSink(dhType, sinkPtr);
+    return IComponentLoader::GetOrCreateInstance()->GetSink(dhType, sinkPtr);
 }
 
 int32_t ComponentLoader::GetHardwareHandler(const DHType dhType, IHardwareHandler *&hardwareHandlerPtr)
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetHardwareHandler(dhType, hardwareHandlerPtr);
+    return IComponentLoader::GetOrCreateInstance()->GetHardwareHandler(dhType, hardwareHandlerPtr);
 }
 
 int32_t ComponentLoader::ReleaseSink(const DHType dhType)
 {
-    return IComponentLoader::GetOrCtreateInstance()->ReleaseSink(dhType);
+    return IComponentLoader::GetOrCreateInstance()->ReleaseSink(dhType);
 }
 
 void GetAllCompTypes(std::vector<DHType> &dhTypeVec)
 {
-    IComponentLoader::GetOrCtreateInstance()->GetAllCompTypes(dhTypeVec);
+    IComponentLoader::GetOrCreateInstance()->GetAllCompTypes(dhTypeVec);
 }
 
 int32_t ComponentLoader::GetSource(const DHType dhType, IDistributedHardwareSource *&sourcePtr)
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetSource(dhType, sourcePtr);
+    return IComponentLoader::GetOrCreateInstance()->GetSource(dhType, sourcePtr);
 }
 
 int32_t ComponentLoader::GetSourceSaId(const DHType dhType)
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetSourceSaId(dhType);
+    return IComponentLoader::GetOrCreateInstance()->GetSourceSaId(dhType);
 }
 
 int32_t ComponentLoader::ReleaseSource(const DHType dhType)
 {
-    return IComponentLoader::GetOrCtreateInstance()->ReleaseSource(dhType);
+    return IComponentLoader::GetOrCreateInstance()->ReleaseSource(dhType);
 }
 
 int32_t ComponentLoader::GetLocalDHVersion(DHVersion &dhVersion)
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetLocalDHVersion(dhVersion);
+    return IComponentLoader::GetOrCreateInstance()->GetLocalDHVersion(dhVersion);
 }
 
 std::map<std::string, bool> ComponentLoader::GetCompResourceDesc()
 {
-    return IComponentLoader::GetOrCtreateInstance()->GetCompResourceDesc();
+    return IComponentLoader::GetOrCreateInstance()->GetCompResourceDesc();
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_device_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_device_manager.cpp
index fc425da49fcc131d5707c61c9a50b495c0e981ef..04dec3a0dfada3cc6b5d63ad72b3f300caf906dc 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_device_manager.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_device_manager.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IDeviceManager> IDeviceManager::deviceManagerInstance_;
 
-std::shared_ptr<IDeviceManager> IDeviceManager::GetOrCtreateInstance()
+std::shared_ptr<IDeviceManager> IDeviceManager::GetOrCreateInstance()
 {
     if (!deviceManagerInstance_) {
         deviceManagerInstance_ = std::make_shared<MockDeviceManager>();
@@ -36,7 +36,7 @@ void IDeviceManager::ReleaseInstance()
 int32_t DeviceManager::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra,
     std::vector<DmDeviceInfo> &deviceList)
 {
-    return IDeviceManager::GetOrCtreateInstance()->GetTrustedDeviceList(pkgName, extra, deviceList);
+    return IDeviceManager::GetOrCreateInstance()->GetTrustedDeviceList(pkgName, extra, deviceList);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_context.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_context.cpp
index ad6e312373c4480f5d8807dcde0aedcf34a141a0..fa6bad5d018672b7567c45fa6d0c330d952296cd 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_context.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_context.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IDHContext> IDHContext::dHContextInstance_;
 
-std::shared_ptr<IDHContext> IDHContext::GetOrCtreateInstance()
+std::shared_ptr<IDHContext> IDHContext::GetOrCreateInstance()
 {
     if (!dHContextInstance_) {
         dHContextInstance_ = std::make_shared<MockDHContext>();
@@ -35,17 +35,17 @@ void IDHContext::ReleaseInstance()
 
 const DeviceInfo& DHContext::GetDeviceInfo()
 {
-    return IDHContext::GetOrCtreateInstance()->GetDeviceInfo();
+    return IDHContext::GetOrCreateInstance()->GetDeviceInfo();
 }
 
 std::string DHContext::GetUUIDByNetworkId(const std::string &networkId)
 {
-    return IDHContext::GetOrCtreateInstance()->GetUUIDByNetworkId(networkId);
+    return IDHContext::GetOrCreateInstance()->GetUUIDByNetworkId(networkId);
 }
 
 std::string DHContext::GetUUIDByDeviceId(const std::string &deviceId)
 {
-    return IDHContext::GetOrCtreateInstance()->GetUUIDByDeviceId(deviceId);
+    return IDHContext::GetOrCreateInstance()->GetUUIDByDeviceId(deviceId);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_utils_tool.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_utils_tool.cpp
index db65ddc31abd745cdc6e91a19893e767176a0fe0..1b1b7dfe415d93b5537a7ee3982f0887463c81c3 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_utils_tool.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_utils_tool.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IDHUtilTool> IDHUtilTool::UtilToolInstance_;
 
-std::shared_ptr<IDHUtilTool> IDHUtilTool::GetOrCtreateInstance()
+std::shared_ptr<IDHUtilTool> IDHUtilTool::GetOrCreateInstance()
 {
     if (!UtilToolInstance_) {
         UtilToolInstance_ = std::make_shared<MockDHUtilTool>();
@@ -35,7 +35,7 @@ void IDHUtilTool::ReleaseInstance()
 
 DeviceInfo GetLocalDeviceInfo()
 {
-    return IDHUtilTool::GetOrCtreateInstance()->GetLocalDeviceInfo();
+    return IDHUtilTool::GetOrCreateInstance()->GetLocalDeviceInfo();
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_meta_info_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_meta_info_manager.cpp
index ce33186c34778e68a5315d2922458e8e08f4a659..5cfd2de2dd8a5a90819f66c75c6f98ca7b1d65b3 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_meta_info_manager.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_meta_info_manager.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IMetaInfoManager> IMetaInfoManager::metaInfoManagerInstance_;
 
-std::shared_ptr<IMetaInfoManager> IMetaInfoManager::GetOrCtreateInstance()
+std::shared_ptr<IMetaInfoManager> IMetaInfoManager::GetOrCreateInstance()
 {
     if (!metaInfoManagerInstance_) {
         metaInfoManagerInstance_ = std::make_shared<MockMetaInfoManager>();
@@ -35,13 +35,13 @@ void IMetaInfoManager::ReleaseInstance()
 
 int32_t MetaInfoManager::GetMetaDataByDHType(const DHType dhType, MetaCapInfoMap &metaInfoMap)
 {
-    return IMetaInfoManager::GetOrCtreateInstance()->GetMetaDataByDHType(dhType, metaInfoMap);
+    return IMetaInfoManager::GetOrCreateInstance()->GetMetaDataByDHType(dhType, metaInfoMap);
 }
 
 int32_t MetaInfoManager::GetMetaCapInfo(const std::string &udidHash,
     const std::string &dhId, std::shared_ptr<MetaCapabilityInfo> &metaCapPtr)
 {
-    return IMetaInfoManager::GetOrCtreateInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
+    return IMetaInfoManager::GetOrCreateInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_version_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_version_manager.cpp
index 37e17bd21cad85c2363d95443cda3bf29bf65808..2e2d55012175417d86c3889990b8944c4c1c86b3 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_version_manager.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_version_manager.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IVersionManager> IVersionManager::versionManagerInstance_;
 
-std::shared_ptr<IVersionManager> IVersionManager::GetOrCtreateInstance()
+std::shared_ptr<IVersionManager> IVersionManager::GetOrCreateInstance()
 {
     if (!versionManagerInstance_) {
         versionManagerInstance_ = std::make_shared<MockVersionManager>();
@@ -35,7 +35,7 @@ void IVersionManager::ReleaseInstance()
 
 int32_t VersionManager::GetCompVersion(const std::string &uuid, const DHType dhType, CompVersion &compVersion)
 {
-    return IVersionManager::GetOrCtreateInstance()->GetCompVersion(uuid, dhType, compVersion);
+    return IVersionManager::GetOrCreateInstance()->GetCompVersion(uuid, dhType, compVersion);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/task/BUILD.gn
index dce15408705647bbc195d2304c2da52acf9ac07b..84ccde97ab20186ba165c7f9957ca13b1504930c 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/BUILD.gn
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/BUILD.gn
@@ -46,6 +46,8 @@ ohos_unittest("DHDisableTaskTest") {
     "src/disable_task_test.cpp",
     "src/mock_component_manager.cpp",
     "src/mock_dh_context.cpp",
+    "src/mock_dh_utils_tool.cpp",
+    "${services_path}/distributedhardwarefwkservice/src/task/disable_task.cpp",
   ]
 
   configs = [ ":module_private_config" ]
@@ -71,6 +73,7 @@ ohos_unittest("DHDisableTaskTest") {
     "googletest:gmock",
     "googletest:gmock_main",
     "hilog:libhilog",
+    "hitrace:hitrace_meter",
     "ipc:ipc_single",
     "kv_store:distributeddata_inner",
     "samgr:samgr_proxy",
@@ -91,6 +94,8 @@ ohos_unittest("DHEnableTaskTest") {
     "src/enable_task_test.cpp",
     "src/mock_component_manager.cpp",
     "src/mock_dh_context.cpp",
+    "src/mock_dh_utils_tool.cpp",
+    "${services_path}/distributedhardwarefwkservice/src/task/enable_task.cpp",
   ]
 
   configs = [ ":module_private_config" ]
@@ -116,6 +121,7 @@ ohos_unittest("DHEnableTaskTest") {
     "googletest:gmock",
     "googletest:gmock_main",
     "hilog:libhilog",
+    "hitrace:hitrace_meter",
     "ipc:ipc_single",
     "kv_store:distributeddata_inner",
     "samgr:samgr_proxy",
@@ -133,7 +139,7 @@ ohos_unittest("OnlineTaskTest") {
 
   sources = [
     "src/online_task_test.cpp",
-    "${services_path}/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/mock_dh_utils_tool.cpp",
+    "src/mock_dh_utils_tool.cpp",
     ]
 
   configs = [ ":module_private_config" ]
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/include/disable_task_test.h b/services/distributedhardwarefwkservice/test/unittest/common/task/include/disable_task_test.h
index 8885c9dbc02021b6645a008c99ba9761251e54b9..5403f394979c5290f35826f56df0a346ca87fe3d 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/include/disable_task_test.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/include/disable_task_test.h
@@ -22,6 +22,7 @@
 
 #include "mock_component_manager.h"
 #include "mock_dh_context.h"
+#include "mock_dh_utils_tool.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -34,6 +35,7 @@ public:
 
     std::shared_ptr<MockComponentManager> componentManager_;
     std::shared_ptr<MockDHContext> dhContext_;
+    std::shared_ptr<MockDhUtilTool> utilTool_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/include/enable_task_test.h b/services/distributedhardwarefwkservice/test/unittest/common/task/include/enable_task_test.h
index bd51e76d8614f59b66b3384c15776e2b86448540..c432f19853610c5badc5bb681b71969f11ec1d43 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/include/enable_task_test.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/include/enable_task_test.h
@@ -20,6 +20,7 @@
 #include "enable_task.h"
 
 #include "mock_component_manager.h"
+#include "mock_dh_utils_tool.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -31,6 +32,7 @@ public:
     void TearDown();
 
     std::shared_ptr<MockComponentManager> componentManager_;
+    std::shared_ptr<MockDhUtilTool> utilTool_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_component_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_component_manager.h
index b442757876cde5ccbd5684e6ffb9d3a11adfd410..150a49313936b044e8046de2f2ee49b92b6dcd1a 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_component_manager.h
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_component_manager.h
@@ -36,7 +36,7 @@ public:
         const DHDescriptor &dhDescriptor, int32_t callingUid, int32_t callingPid) = 0;
     virtual int32_t CheckSinkConfigStart(const DHType dhType, bool &enableSink) = 0;
 
-    static std::shared_ptr<IComponentManager> GetOrCtreateInstance();
+    static std::shared_ptr<IComponentManager> GetOrCreateInstance();
     static void ReleaseInstance();
 public:
     static std::shared_ptr<IComponentManager> componentManager_;
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_dh_utils_tool.h b/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_dh_utils_tool.h
new file mode 100644
index 0000000000000000000000000000000000000000..849480a8844e913c799351bb388725fc099c9daf
--- /dev/null
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/include/mock_dh_utils_tool.h
@@ -0,0 +1,44 @@
+/*
+ * 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 OHOS_DISTRIBUTED_HARDWARE_MOCK_DH_UTILS_TOOL_H
+#define OHOS_DISTRIBUTED_HARDWARE_MOCK_DH_UTILS_TOOL_H
+
+#include <gmock/gmock.h>
+
+#include "dh_utils_tool.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class IDhUtilTool {
+public:
+    virtual ~IDhUtilTool() = default;
+
+    virtual std::string GetLocalUdid() = 0;
+    virtual DeviceInfo GetLocalDeviceInfo() = 0;
+    static std::shared_ptr<IDhUtilTool> GetOrCreateInstance();
+    static void ReleaseInstance();
+private:
+    static std::shared_ptr<IDhUtilTool> UtilToolInstance_;
+};
+
+class MockDhUtilTool : public IDhUtilTool {
+public:
+    MOCK_METHOD(std::string, GetLocalUdid, ());
+    MOCK_METHOD(DeviceInfo, GetLocalDeviceInfo, ());
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif // OHOS_DISTRIBUTED_HARDWARE_MOCK_DH_UTILS_TOOL_H
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/src/disable_task_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/task/src/disable_task_test.cpp
index 2e30abb88c11470941c7170c6fdaa18e8237995d..19e7438acef3fc54ddc1b8848fa1e182d2bdc110 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/src/disable_task_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/src/disable_task_test.cpp
@@ -49,10 +49,12 @@ void DisableTaskTest::TearDownTestCase()
 
 void DisableTaskTest::SetUp()
 {
-    auto componentManager = IComponentManager::GetOrCtreateInstance();
+    auto componentManager = IComponentManager::GetOrCreateInstance();
     componentManager_ = std::static_pointer_cast<MockComponentManager>(componentManager);
     auto dhContext = IDHContext::GetOrCreateInstance();
     dhContext_ = std::static_pointer_cast<MockDHContext>(dhContext);
+    auto utilTool = IDhUtilTool::GetOrCreateInstance();
+    utilTool_ = std::static_pointer_cast<MockDhUtilTool>(utilTool);
 }
 
 void DisableTaskTest::TearDown()
@@ -61,148 +63,120 @@ void DisableTaskTest::TearDown()
     componentManager_ = nullptr;
     IDHContext::ReleaseInstance();
     dhContext_ = nullptr;
+    IDhUtilTool::ReleaseInstance();
+    utilTool_ = nullptr;
 }
 
-/**
- * @tc.name: UnRegisterHardware_001
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(DisableTaskTest, UnRegisterHardware_001, TestSize.Level0)
 {
     auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*componentManager_, ForceDisableSource(_, _)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    disableTask->SetCallingUid(1);
+    auto ret = disableTask->UnRegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_002
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(DisableTaskTest, UnRegisterHardware_002, TestSize.Level0)
 {
     auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*componentManager_, ForceDisableSource(_, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), 1);
+    disableTask->SetCallingPid(1);
+    auto ret = disableTask->UnRegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_003
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(DisableTaskTest, UnRegisterHardware_003, TestSize.Level0)
 {
-    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*dhContext_, GetRealTimeOnlineDeviceCount()).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*dhContext_, GetIsomerismConnectCount()).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*componentManager_, ForceDisableSink(_)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    disableTask->SetCallingUid(1);
+    disableTask->SetCallingPid(1);
+    auto ret = disableTask->UnRegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_004
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(DisableTaskTest, UnRegisterHardware_004, TestSize.Level0)
 {
-    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*dhContext_, GetRealTimeOnlineDeviceCount()).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*dhContext_, GetIsomerismConnectCount()).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*componentManager_, ForceDisableSink(_)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), 1);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
+    EXPECT_CALL(*componentManager_, ForceDisableSource(_, _)).Times(1).WillRepeatedly(Return(0));
+    auto ret = disableTask->UnRegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_005
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(DisableTaskTest, UnRegisterHardware_005, TestSize.Level0)
 {
-    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*dhContext_, GetRealTimeOnlineDeviceCount()).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
+    EXPECT_CALL(*componentManager_, ForceDisableSource(_, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = disableTask->UnRegisterHardware();
+    EXPECT_EQ(-1, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_006
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(DisableTaskTest, UnRegisterHardware_006, TestSize.Level0)
+HWTEST_F(DisableTaskTest, DoAutoDisable_001, TestSize.Level0)
 {
-    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
     EXPECT_CALL(*dhContext_, GetRealTimeOnlineDeviceCount()).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*dhContext_, GetIsomerismConnectCount()).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    EXPECT_CALL(*dhContext_, GetIsomerismConnectCount()).Times(1).WillRepeatedly(Return(0));
+    EXPECT_CALL(*componentManager_, ForceDisableSink(_)).Times(1).WillRepeatedly(Return(0));
+    auto ret = disableTask->DoAutoDisable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_007
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(DisableTaskTest, UnRegisterHardware_007, TestSize.Level0)
+HWTEST_F(DisableTaskTest, DoAutoDisable_002, TestSize.Level0)
 {
     auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    disableTask->callingUid_ = 1;
-    disableTask->callingPid_ = 1;
-    disableTask->effectSink_ = true;
-    disableTask->effectSource_ = true;
-    EXPECT_CALL(*componentManager_, DisableSink(_, _, _)).Times(1).WillRepeatedly(Return(1));
-    EXPECT_CALL(*componentManager_, DisableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), 1);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
+    EXPECT_CALL(*dhContext_, GetRealTimeOnlineDeviceCount()).Times(1).WillRepeatedly(Return(0));
+    EXPECT_CALL(*dhContext_, GetIsomerismConnectCount()).Times(1).WillRepeatedly(Return(0));
+    EXPECT_CALL(*componentManager_, ForceDisableSink(_)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = disableTask->DoAutoDisable();
+    EXPECT_EQ(-1, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_008
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(DisableTaskTest, UnRegisterHardware_008, TestSize.Level0)
+HWTEST_F(DisableTaskTest, DoActiveDisable_001, TestSize.Level0)
 {
     auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    disableTask->callingUid_ = 1;
-    disableTask->callingPid_ = 1;
-    disableTask->effectSink_ = true;
-    disableTask->effectSource_ = true;
+    disableTask->SetEffectSink(true);
     EXPECT_CALL(*componentManager_, DisableSink(_, _, _)).Times(1).WillRepeatedly(Return(0));
+    auto ret = disableTask->DoActiveDisable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(DisableTaskTest, DoActiveDisable_002, TestSize.Level0)
+{
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    disableTask->SetEffectSink(true);
+    EXPECT_CALL(*componentManager_, DisableSink(_, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = disableTask->DoActiveDisable();
+    EXPECT_EQ(-1, ret);
+}
+
+HWTEST_F(DisableTaskTest, DoActiveDisable_003, TestSize.Level0)
+{
+    auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    disableTask->SetEffectSource(true);
     EXPECT_CALL(*componentManager_, DisableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    auto ret = disableTask->DoActiveDisable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: UnRegisterHardware_009
- * @tc.desc: Verify the UnRegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(DisableTaskTest, UnRegisterHardware_009, TestSize.Level0)
+HWTEST_F(DisableTaskTest, DoActiveDisable_004, TestSize.Level0)
 {
     auto disableTask = std::make_shared<DisableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    disableTask->callingUid_ = 1;
-    disableTask->callingPid_ = 1;
-    ASSERT_EQ(disableTask->UnRegisterHardware(), DH_FWK_SUCCESS);
+    disableTask->SetEffectSource(true);
+    EXPECT_CALL(*componentManager_, DisableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = disableTask->DoActiveDisable();
+    EXPECT_EQ(-1, ret);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/src/enable_task_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/task/src/enable_task_test.cpp
index b6c71181e3f8bf00fb9b931c8ee487ae19a78de2..d4e864706001aa8026bd98b691f953c683716576 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/src/enable_task_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/src/enable_task_test.cpp
@@ -49,157 +49,176 @@ void EnableTaskTest::TearDownTestCase()
 
 void EnableTaskTest::SetUp()
 {
-    auto componentManager = IComponentManager::GetOrCtreateInstance();
+    auto componentManager = IComponentManager::GetOrCreateInstance();
     componentManager_ = std::static_pointer_cast<MockComponentManager>(componentManager);
+    auto utilTool = IDhUtilTool::GetOrCreateInstance();
+    utilTool_ = std::static_pointer_cast<MockDhUtilTool>(utilTool);
 }
 
 void EnableTaskTest::TearDown()
 {
     IComponentManager::ReleaseInstance();
     componentManager_ = nullptr;
+    IDhUtilTool::ReleaseInstance();
+    utilTool_ = nullptr;
 }
 
-/**
- * @tc.name: RegisterHardware_001
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
 HWTEST_F(EnableTaskTest, RegisterHardware_001, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    enableTask->SetCallingUid(1);
+    auto ret = enableTask->RegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(EnableTaskTest, RegisterHardware_002, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    enableTask->SetCallingPid(1);
+    auto ret = enableTask->RegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(EnableTaskTest, RegisterHardware_003, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    enableTask->SetCallingUid(1);
+    enableTask->SetCallingPid(1);
+    auto ret = enableTask->RegisterHardware();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(EnableTaskTest, RegisterHardware_004, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
+    EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->RegisterHardware();
+    EXPECT_EQ(-1, ret);
+}
+
+HWTEST_F(EnableTaskTest, DoAutoEnable_001, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
     EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
         DoAll(SetArgReferee<2>(false), Return(0)));
-    ASSERT_EQ(enableTask->RegisterHardware(), ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE);
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_002
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_002, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_002, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
     EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
         DoAll(SetArgReferee<2>(true), Return(0)));
-    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(enableTask->RegisterHardware(), DH_FWK_SUCCESS);
+    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(-1, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_003
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_003, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_003, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
     EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
         DoAll(SetArgReferee<2>(true), Return(0)));
-    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(enableTask->RegisterHardware(), 1);
+    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_004
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_004, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_005, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(enableTask->RegisterHardware(), 1);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
+    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(-1, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_005
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_005, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_006, TestSize.Level0)
 {
-    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(enableTask->RegisterHardware(), ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
+    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
+        DoAll(SetArgReferee<1>(false), Return(0)));
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_006
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_006, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_007, TestSize.Level0)
 {
-    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, GetLocalUdid(),
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).WillOnce(DoAll(SetArgReferee<1>(true), Return(0)));
-    EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(enableTask->RegisterHardware(), 1);
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
+    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
+        DoAll(SetArgReferee<1>(true), Return(0)));
+    EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(-1, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_007
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_007, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoAutoEnable_008, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    enableTask->callingUid_ = 1;
-    enableTask->callingPid_ = 1;
-    enableTask->effectSink_ = true;
-    enableTask->effectSource_ = true;
+    EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
+    EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
+        DoAll(SetArgReferee<1>(true), Return(0)));
     EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(0));
-    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
-    ASSERT_EQ(enableTask->RegisterHardware(), 0);
+    auto ret = enableTask->DoAutoEnable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
 }
 
-/**
- * @tc.name: RegisterHardware_008
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_008, TestSize.Level0)
+HWTEST_F(EnableTaskTest, DoActiveEnable_001, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    enableTask->callingUid_ = 1;
-    enableTask->callingPid_ = 1;
-    enableTask->effectSink_ = true;
-    enableTask->effectSource_ = true;
-    EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(1));
-    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(1));
-    ASSERT_EQ(enableTask->RegisterHardware(), 1);
-}
-
-/**
- * @tc.name: RegisterHardware_009
- * @tc.desc: Verify the RegisterHardware function
- * @tc.type: FUNC
- * @tc.require: AR000GHSJM
- */
-HWTEST_F(EnableTaskTest, RegisterHardware_009, TestSize.Level0)
+    enableTask->SetEffectSink(true);
+    EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(0));
+    auto ret = enableTask->DoActiveEnable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(EnableTaskTest, DoActiveEnable_002, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    enableTask->SetEffectSink(true);
+    EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->DoActiveEnable();
+    EXPECT_EQ(-1, ret);
+}
+
+HWTEST_F(EnableTaskTest, DoActiveEnable_003, TestSize.Level0)
+{
+    auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
+        TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
+    enableTask->SetEffectSource(true);
+    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
+    auto ret = enableTask->DoActiveEnable();
+    EXPECT_EQ(DH_FWK_SUCCESS, ret);
+}
+
+HWTEST_F(EnableTaskTest, DoActiveEnable_004, TestSize.Level0)
 {
     auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
         TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
-    enableTask->callingUid_ = 1;
-    enableTask->callingPid_ = 1;
-    ASSERT_EQ(enableTask->RegisterHardware(), DH_FWK_SUCCESS);
+    enableTask->SetEffectSource(true);
+    EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(-1));
+    auto ret = enableTask->DoActiveEnable();
+    EXPECT_EQ(-1, ret);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_component_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_component_manager.cpp
index 98ff5a6492a1606eaed8855f386ccc5d70a69e6c..1591cf6ed10bed912459e8d09a70376498ece81e 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_component_manager.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_component_manager.cpp
@@ -22,7 +22,7 @@ namespace OHOS {
 namespace DistributedHardware {
 std::shared_ptr<IComponentManager> IComponentManager::componentManager_;
 
-std::shared_ptr<IComponentManager> IComponentManager::GetOrCtreateInstance()
+std::shared_ptr<IComponentManager> IComponentManager::GetOrCreateInstance()
 {
     if (!componentManager_) {
         componentManager_ = std::make_shared<MockComponentManager>();
@@ -40,44 +40,44 @@ void IComponentManager::ReleaseInstance()
 int32_t ComponentManager::CheckDemandStart(const std::string &uuid, const DHType dhType, bool &enableSource)
 {
     enableSource = true;
-    return IComponentManager::GetOrCtreateInstance()->CheckDemandStart(uuid, dhType, enableSource);
+    return IComponentManager::GetOrCreateInstance()->CheckDemandStart(uuid, dhType, enableSource);
 }
 
 int32_t ComponentManager::ForceDisableSink(const DHDescriptor &dhDescriptor)
 {
-    return IComponentManager::GetOrCtreateInstance()->ForceDisableSink(dhDescriptor);
+    return IComponentManager::GetOrCreateInstance()->ForceDisableSink(dhDescriptor);
 }
 
 int32_t ComponentManager::ForceDisableSource(const std::string &networkId, const DHDescriptor &dhDescriptor)
 {
-    return IComponentManager::GetOrCtreateInstance()->ForceDisableSource(networkId, dhDescriptor);
+    return IComponentManager::GetOrCreateInstance()->ForceDisableSource(networkId, dhDescriptor);
 }
 
 int32_t ComponentManager::EnableSink(const DHDescriptor &dhDescriptor, int32_t callingUid, int32_t callingPid)
 {
-    return IComponentManager::GetOrCtreateInstance()->EnableSink(dhDescriptor, callingUid, callingPid);
+    return IComponentManager::GetOrCreateInstance()->EnableSink(dhDescriptor, callingUid, callingPid);
 }
 
 int32_t ComponentManager::EnableSource(const std::string &networkId,
     const DHDescriptor &dhDescriptor, int32_t callingUid, int32_t callingPid)
 {
-    return IComponentManager::GetOrCtreateInstance()->EnableSource(networkId, dhDescriptor, callingUid, callingPid);
+    return IComponentManager::GetOrCreateInstance()->EnableSource(networkId, dhDescriptor, callingUid, callingPid);
 }
 
 int32_t ComponentManager::DisableSink(const DHDescriptor &dhDescriptor, int32_t callingUid, int32_t callingPid)
 {
-    return IComponentManager::GetOrCtreateInstance()->DisableSink(dhDescriptor, callingUid, callingPid);
+    return IComponentManager::GetOrCreateInstance()->DisableSink(dhDescriptor, callingUid, callingPid);
 }
 
 int32_t ComponentManager::DisableSource(const std::string &networkId,
     const DHDescriptor &dhDescriptor, int32_t callingUid, int32_t callingPid)
 {
-    return IComponentManager::GetOrCtreateInstance()->DisableSource(networkId, dhDescriptor, callingUid, callingPid);
+    return IComponentManager::GetOrCreateInstance()->DisableSource(networkId, dhDescriptor, callingUid, callingPid);
 }
 
 int32_t ComponentManager::CheckSinkConfigStart(const DHType dhType, bool &enableSink)
 {
-    return IComponentManager::GetOrCtreateInstance()->CheckSinkConfigStart(dhType, enableSink);
+    return IComponentManager::GetOrCreateInstance()->CheckSinkConfigStart(dhType, enableSink);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_dh_utils_tool.cpp b/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_dh_utils_tool.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c089e837ed21c103bb410f5fabf3f7a7797cd1bd
--- /dev/null
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/src/mock_dh_utils_tool.cpp
@@ -0,0 +1,46 @@
+/*
+ * 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 "mock_dh_utils_tool.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+std::shared_ptr<IDhUtilTool> IDhUtilTool::UtilToolInstance_;
+
+std::shared_ptr<IDhUtilTool> IDhUtilTool::GetOrCreateInstance()
+{
+    if (!UtilToolInstance_) {
+        UtilToolInstance_ = std::make_shared<MockDhUtilTool>();
+    }
+    return UtilToolInstance_;
+}
+
+void IDhUtilTool::ReleaseInstance()
+{
+    UtilToolInstance_.reset();
+    UtilToolInstance_ = nullptr;
+}
+
+std::string GetLocalUdid()
+{
+    return IDhUtilTool::GetOrCreateInstance()->GetLocalUdid();
+}
+
+DeviceInfo GetLocalDeviceInfo()
+{
+    return IDhUtilTool::GetOrCreateInstance()->GetLocalDeviceInfo();
+}
+} // namespace DistributedHardware
+} // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/task/src/online_task_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/task/src/online_task_test.cpp
index 21f9e5cd717f2bc05304503e2638e76455310ce5..8954e541851e570cea9798c5b16f9637a77b3362 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/task/src/online_task_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/task/src/online_task_test.cpp
@@ -58,7 +58,7 @@ public:
     void TearDown();
 
 private:
-    std::shared_ptr<MockDHUtilTool> utilTool_;
+    std::shared_ptr<MockDhUtilTool> utilTool_;
 };
 
 void OnlineTaskTest::SetUpTestCase()
@@ -71,13 +71,13 @@ void OnlineTaskTest::TearDownTestCase()
 
 void OnlineTaskTest::SetUp()
 {
-    auto utilTool = IDHUtilTool::GetOrCtreateInstance();
-    utilTool_ = std::static_pointer_cast<MockDHUtilTool>(utilTool);
+    auto utilTool = IDhUtilTool::GetOrCreateInstance();
+    utilTool_ = std::static_pointer_cast<MockDhUtilTool>(utilTool);
 }
 
 void OnlineTaskTest::TearDown()
 {
-    IDHUtilTool::ReleaseInstance();
+    IDhUtilTool::ReleaseInstance();
     utilTool_ = nullptr;
 }