diff --git a/test/softbusunittest/UTTest_softbus_connector.cpp b/test/softbusunittest/UTTest_softbus_connector.cpp
index 7d97ecee6ed72975ee1f41599c66f7caf37ac763..42012b69391a3123db64a70478033a670ae7e19d 100644
--- a/test/softbusunittest/UTTest_softbus_connector.cpp
+++ b/test/softbusunittest/UTTest_softbus_connector.cpp
@@ -47,6 +47,14 @@ public:
     void DeleteOffLineTimer(std::string udidHash) override {}
 };
 
+class ServiceDiscoveryCallbackTest : public IServiceDiscoveryCallback {
+public:
+    ServiceDiscoveryCallbackTest() {}
+    virtual ~ServiceDiscoveryCallbackTest() {}
+    void OnServiceFound(int64_t localServiceId, const ServiceInfo& softbusService) override {}
+    void OnServiceLost(int64_t localServiceId, int64_t serviceId) override {}
+};
+
 void SoftbusConnectorTest::SetUp()
 {
 }
@@ -845,6 +853,96 @@ HWTEST_F(SoftbusConnectorTest, GetDeviceUdidHashByUdid_002, testing::ext::TestSi
     bool isForceJoin = false;
     softbusConnector->JoinLnn(deviceId, isForceJoin);
 }
+
+HWTEST_F(SoftbusConnectorTest, StartServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    ServiceInfo& serviceInfo = serviceInfoProfile.serviceRegInfo.serviceInfo;
+    serviceInfo.serviceId = 12345;
+    serviceInfo.serviceType = "testServiceType";
+    serviceInfo.serviceName = "testServiceName";
+    serviceInfo.serviceDisplayName = "testServiceDisplayName";
+    serviceInfo.customData = "testCustomData";
+    serviceInfo.dataLen = serviceInfo.customData.length();
+
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, StopServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    ServiceInfo& serviceInfo = serviceInfoProfile.serviceRegInfo.serviceInfo;
+    serviceInfo.serviceId = 12345;
+    serviceInfo.serviceType = "testServiceType";
+    serviceInfo.serviceName = "testServiceName";
+    serviceInfo.serviceDisplayName = "testServiceDisplayName";
+    serviceInfo.customData = "testCustomData";
+    serviceInfo.dataLen = serviceInfo.customData.length();
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->StopServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, RegisterServiceDiscoveryCallback_001, testing::ext::TestSize.Level1)
+{
+    int64_t serviceId = 12345;
+    auto callback = std::make_shared<ServiceDiscoveryCallbackTest>();
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    int32_t ret = softbusConnector->RegisterServiceDiscoveryCallback(serviceId, callback);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, UnRegisterServiceDiscoveryCallback_001, testing::ext::TestSize.Level1)
+{
+    int64_t serviceId = 12345;
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    auto callback = std::make_shared<ServiceDiscoveryCallbackTest>();
+    softbusConnector->RegisterServiceDiscoveryCallback(serviceId, callback);
+
+    int32_t ret = softbusConnector->UnRegisterServiceDiscoveryCallback(serviceId);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(SoftbusConnectorTest, OnSoftbusOnServiceFound_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    softbusConnector->OnSoftbusOnServiceFound(nullptr);
+}
+
+HWTEST_F(SoftbusConnectorTest, OnSoftbusOnServiceFound_002, testing::ext::TestSize.Level1)
+{
+    ServiceInfo service;
+    service.serviceId = 12345;
+    service.serviceType = "testServiceType";
+    service.serviceName = "testServiceName";
+    service.serviceDisplayName = "testServiceDisplayName";
+    service.customData = "testCustomData";
+    service.dataLen = service.customData.length();
+
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    softbusConnector->OnSoftbusOnServiceFound(&service);
+    EXPECT_TRUE(softbusConnector->serviceDiscoveryCallbackMap_.empty());
+}
+
+HWTEST_F(SoftbusConnectorTest, OnSoftbusOnServiceLost_001, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    softbusConnector->OnSoftbusOnServiceLost(nullptr);
+}
+
+HWTEST_F(SoftbusConnectorTest, OnSoftbusOnServiceLost_002, testing::ext::TestSize.Level1)
+{
+    std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
+    const char* serviceIdStr = "12345";
+
+    softbusConnector->OnSoftbusOnServiceLost(serviceIdStr);
+    EXPECT_TRUE(softbusConnector->serviceDiscoveryCallbackMap_.empty());
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS-
\ No newline at end of file
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 03fde27c619e7f57c492d4ff5f60a0fb6d29d879..2ea5b20e31934e1cd886aa8d67219e66316c8014 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -66,6 +66,7 @@ group("unittest") {
     ":UTTest_dm_radar_helper_test",
     ":UTTest_dm_screen_common_event",
     ":UTTest_dm_service_load",
+    ":UTTest_dm_service_discovery_manager",
     ":UTTest_dm_softbus_cache",
     ":UTTest_dm_timer",
     ":UTTest_dm_transport",
@@ -1870,6 +1871,37 @@ ohos_unittest("UTTest_dm_screen_common_event") {
 
 ## UnitTest UTTest_dm_screen_common_event }}}
 
+## UnitTest UTTest_dm_service_discovery_manager {{{
+ohos_unittest("UTTest_dm_service_discovery_manager") {
+  module_out_path = module_out_path
+
+  include_dirs = [
+    "${devicemanager_path}/commondependency/include",
+    "${devicemanager_path}/test/unittest",
+  ]
+
+  sources = [
+    "${devicemanager_path}/test/unittest/UTTest_dm_service_discovery_manager.cpp",
+    "${devicemanager_path}/test/unittest/mock/softbus_connector_mock.cpp",
+    "${devicemanager_path}/test/unittest/mock/dm_service_discovery_manager_mock.cpp",
+  ]
+
+  deps = [ ":device_manager_test_common" ]
+
+  external_deps = [
+    "device_info_manager:distributed_device_profile_common",
+    "device_info_manager:distributed_device_profile_sdk",
+    "device_auth:deviceauth_sdk",
+    "dsoftbus:softbus_client",
+    "ffrt:libffrt",
+    "googletest:gmock",
+    "googletest:gmock_main",
+    "hilog:libhilog",
+  ]
+}
+
+## UnitTest UTTest_dm_service_discovery_manager }}}
+
 ## UnitTest UTTest_relationship_sync_mgr {{{
 ohos_unittest("UTTest_relationship_sync_mgr") {
   module_out_path = module_out_path
diff --git a/test/unittest/UTTest_device_manager_service_impl_first.cpp b/test/unittest/UTTest_device_manager_service_impl_first.cpp
index dab94b6c117912b10f5a05939f0e327e233fe307..2ed2edec774e2b95cf868a20e76cf5ed95c721d3 100644
--- a/test/unittest/UTTest_device_manager_service_impl_first.cpp
+++ b/test/unittest/UTTest_device_manager_service_impl_first.cpp
@@ -786,6 +786,24 @@ HWTEST_F(DeviceManagerServiceImplFirstTest, DeleteAclByTokenId_002, testing::ext
     EXPECT_TRUE(delACLInfoVec.empty());
     EXPECT_TRUE(userIdVec.empty());
 }
+
+HWTEST_F(DeviceManagerServiceImplFirstTest, StartServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    deviceManagerServiceImpl_->softbusConnector_ = nullptr;
+
+    ServiceInfoProfile serviceInfoProfile;
+    int32_t ret = deviceManagerServiceImpl_->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceImplFirstTest, StopServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    deviceManagerServiceImpl_->softbusConnector_ = nullptr;
+
+    ServiceInfoProfile serviceInfoProfile;
+    int32_t ret = deviceManagerServiceImpl_->StopServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/unittest/UTTest_device_manager_service_listener.cpp b/test/unittest/UTTest_device_manager_service_listener.cpp
index ff761bb5399e6cb47271deaaf5f4f7e0d605c6eb..1c096b102282055098a89162e9d55e9c694bea54 100644
--- a/test/unittest/UTTest_device_manager_service_listener.cpp
+++ b/test/unittest/UTTest_device_manager_service_listener.cpp
@@ -49,6 +49,7 @@ void DeviceManagerServiceListenerTest::SetUpTestCase()
     DmIpcServerListener::dmIpcServerListener = ipcServerListenerMock_;
     DmKVAdapterManager::dmKVAdapterManager = kVAdapterManagerMock_;
     DmAppManager::dmAppManager = appManagerMock_;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxyMock_;
 }
 
 void DeviceManagerServiceListenerTest::TearDownTestCase()
@@ -63,6 +64,8 @@ void DeviceManagerServiceListenerTest::TearDownTestCase()
     kVAdapterManagerMock_ = nullptr;
     DmAppManager::dmAppManager = nullptr;
     appManagerMock_ = nullptr;
+    DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr;
+    ipcClientProxyMock_ = nullptr;
 }
 
 namespace {
@@ -1103,6 +1106,35 @@ HWTEST_F(DeviceManagerServiceListenerTest, OpenAuthSessionWithPara_001, testing:
     int32_t ret = listener_->OpenAuthSessionWithPara(deviceId, actionId, isEnable160m);
     EXPECT_NE(ret, DM_OK);
 }
+
+HWTEST_F(DeviceManagerServiceListenerTest, OnServiceFound_001, testing::ext::TestSize.Level1)
+{
+    int64_t localServiceId = 12345;
+    ServiceInfo softbusService;
+    softbusService.serviceId = 67890;
+    softbusService.serviceType = "testServiceType";
+    softbusService.serviceName = "testServiceName";
+    softbusService.serviceDisplayName = "testServiceDisplayName";
+    softbusService.customData = "testCustomData";
+    softbusService.dataLen = softbusService.customData.length();
+
+    std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
+    EXPECT_CALL(*ipcClientProxyMock_, SendRequest(NOTIFY_SERVICE_FOUND, testing::_, testing::_))
+        .Times(1);
+    listener->OnServiceFound(localServiceId, softbusService);
+}
+
+HWTEST_F(DeviceManagerServiceListenerTest, OnServiceLost_Success, testing::ext::TestSize.Level1)
+{
+    int64_t localServiceId = 12345;
+    int64_t serviceId = 67890;
+
+    std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
+    EXPECT_CALL(*ipcClientProxyMock_, SendRequest(NOTIFY_SERVICE_LOST, testing::_, testing::_))
+        .Times(1);
+
+    listener->OnServiceLost(localServiceId, serviceId);
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/unittest/UTTest_device_manager_service_listener.h b/test/unittest/UTTest_device_manager_service_listener.h
index 771c197222f711ddf2b22a877a7a5de19be62730..ba8b75a9f39672eb255e9c0be60551c80f6cff58 100644
--- a/test/unittest/UTTest_device_manager_service_listener.h
+++ b/test/unittest/UTTest_device_manager_service_listener.h
@@ -21,12 +21,14 @@
 
 #include "device_manager_service_listener.h"
 #include "dm_device_info.h"
+#include "device_manager_impl.h"
 #include "ipc_server_listener.h"
 #include "dm_softbus_cache_mock.h"
 #include "dm_crypto_mock.h"
 #include "ipc_server_listener_mock.h"
 #include "kv_adapter_manager_mock.h"
 #include "app_manager_mock.h"
+#include "mock/mock_ipc_client_proxy.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -44,6 +46,7 @@ public:
     static inline  std::shared_ptr<KVAdapterManagerMock> kVAdapterManagerMock_ =
         std::make_shared<KVAdapterManagerMock>();
     static inline  std::shared_ptr<AppManagerMock> appManagerMock_ = std::make_shared<AppManagerMock>();
+    static inline std::shared_ptr<MockIpcClientProxy> ipcClientProxyMock_ = std::make_shared<MockIpcClientProxy>();
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/unittest/UTTest_device_manager_service_three.cpp b/test/unittest/UTTest_device_manager_service_three.cpp
index 89d07048aeee702027343640fa59dc00fab0103a..edbd920e804f95caab44c6bf8582046030c95253 100644
--- a/test/unittest/UTTest_device_manager_service_three.cpp
+++ b/test/unittest/UTTest_device_manager_service_three.cpp
@@ -64,6 +64,7 @@ void DeviceManagerServiceThreeTest::TearDown()
     Mock::VerifyAndClearExpectations(permissionManagerMock_.get());
     Mock::VerifyAndClearExpectations(softbusListenerMock_.get());
     Mock::VerifyAndClearExpectations(deviceManagerServiceImplMock_.get());
+    Mock::VerifyAndClearExpectations(multipleUserConnectorMock_.get());
 }
 
 void DeviceManagerServiceThreeTest::SetUpTestCase()
@@ -72,6 +73,7 @@ void DeviceManagerServiceThreeTest::SetUpTestCase()
     DmPermissionManager::dmPermissionManager = permissionManagerMock_;
     DmSoftbusListener::dmSoftbusListener = softbusListenerMock_;
     DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_;
+    DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_;
 }
 
 void DeviceManagerServiceThreeTest::TearDownTestCase()
@@ -84,6 +86,8 @@ void DeviceManagerServiceThreeTest::TearDownTestCase()
     softbusListenerMock_ = nullptr;
     DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = nullptr;
     deviceManagerServiceImplMock_ = nullptr;
+    DmMultipleUserConnector::dmMultipleUserConnector = nullptr;
+    multipleUserConnectorMock_ = nullptr;
 }
 
 namespace {
@@ -896,6 +900,138 @@ HWTEST_F(DeviceManagerServiceThreeTest, ProcessReceiveRspAppUnbind_302, testing:
     DeviceManagerService::GetInstance().ProcessReceiveRspAppUnbind(remoteUdid);
     EXPECT_EQ(DeviceManagerService::GetInstance().timer_, nullptr);
 }
+
+HWTEST_F(DeviceManagerServiceThreeTest, StartServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    std::string localServiceId = "12345";
+    std::map<std::string, std::string> discParam = {
+        {"pkgName", "testPkgName"},
+        {"serviceType", "testServiceType"},
+        {"serviceName", "testServiceName"},
+        {"serviceDisplayName", "testServiceDisplayName"},
+        {"customData", "testCustomData"}
+    };
+
+    EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(testing::_)).WillOnce(SetArgReferee<0>(-1));
+    int32_t ret = DeviceManagerService::GetInstance().StartServiceDiscovery(localServiceId, discParam);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StartServiceDiscovery_002, testing::ext::TestSize.Level1)
+{
+    std::string localServiceId = "12345";
+    std::map<std::string, std::string> discParam = {
+        {"pkgName", "testPkgName"},
+        {"serviceType", "testServiceType"},
+        {"serviceName", "testServiceName"},
+        {"serviceDisplayName", "testServiceDisplayName"},
+        {"customData", "testCustomData"}
+    };
+
+    EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(testing::_)).WillOnce(Return(ERR_DM_FAILED));
+    int32_t ret = DeviceManagerService::GetInstance().StartServiceDiscovery(localServiceId, discParam);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StartServiceDiscovery_003, testing::ext::TestSize.Level1)
+{
+    std::string localServiceId = "12345";
+    std::map<std::string, std::string> discParam = {
+        {"pkgName", "testPkgName"},
+        {"serviceType", "testServiceType"},
+        {"serviceName", "testServiceName"},
+        {"serviceDisplayName", "testServiceDisplayName"},
+        {"customData", "testCustomData"}
+    };
+
+    EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(testing::_)).WillOnce(SetArgReferee<0>(1));
+    EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(testing::_))
+        .WillOnce(DoAll(SetArgReferee<0>(std::vector<int32_t>{2, 3}), Return(DM_OK)));
+
+    int32_t ret = DeviceManagerService::GetInstance().StartServiceDiscovery(localServiceId, discParam);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StartServiceDiscovery_004, testing::ext::TestSize.Level1)
+{
+    std::string localServiceId = "12345";
+    std::map<std::string, std::string> discParam = {
+        {"pkgName", "testPkgName"},
+        {"serviceType", "testServiceType"},
+        {"serviceName", "testServiceName"},
+        {"serviceDisplayName", "testServiceDisplayName"},
+        {"customData", "testCustomData"}
+    };
+
+    EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
+    int32_t ret = DeviceManagerService::GetInstance().StartServiceDiscovery(localServiceId, discParam);
+    EXPECT_EQ(ret, ERR_DM_INIT_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StartServiceDiscovery_005, testing::ext::TestSize.Level1)
+{
+    std::string localServiceId = "12345";
+    std::map<std::string, std::string> discParam = {
+        {"pkgName", "testPkgName"},
+        {"serviceType", "testServiceType"},
+        {"serviceName", "testServiceName"},
+        {"serviceDisplayName", "testServiceDisplayName"},
+        {"customData", "testCustomData"}
+    };
+
+    EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(testing::_)).WillOnce(SetArgReferee<0>(1));
+    EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(testing::_))
+        .WillOnce(DoAll(SetArgReferee<0>(std::vector<int32_t>{1}), Return(DM_OK)));
+    EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(true));
+    EXPECT_CALL(*deviceManagerServiceImplMock_, StartServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+
+    int32_t ret = DeviceManagerService::GetInstance().StartServiceDiscovery(localServiceId, discParam);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StopServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    ServiceFilter serviceFilter;
+    serviceFilter.serviceId = 12345;
+    serviceFilter.serviceType = "testServiceType";
+    serviceFilter.serviceName = "testServiceName";
+    serviceFilter.serviceDisplayName = "testServiceDisplayName";
+    serviceFilter.customData = "testCustomData";
+
+    EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(true));
+    int32_t ret = DeviceManagerService::GetInstance().StopServiceDiscovery(serviceFilter);
+    EXPECT_EQ(ret, ERR_DM_INIT_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StopServiceDiscovery_002, testing::ext::TestSize.Level1)
+{
+    ServiceFilter serviceFilter;
+    serviceFilter.serviceId = 12345;
+    serviceFilter.serviceType = "testServiceType";
+    serviceFilter.serviceName = "testServiceName";
+    serviceFilter.serviceDisplayName = "testServiceDisplayName";
+    serviceFilter.customData = "testCustomData";
+
+    EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
+    EXPECT_CALL(*deviceManagerServiceImplMock_, StopServiceDiscovery(testing::_)).WillOnce(Return(ERR_DM_FAILED));
+    int32_t ret = DeviceManagerService::GetInstance().StopServiceDiscovery(serviceFilter);
+    EXPECT_EQ(ret, ERR_DM_FAILED);
+}
+
+HWTEST_F(DeviceManagerServiceThreeTest, StopServiceDiscovery_003, testing::ext::TestSize.Level1)
+{
+    ServiceFilter serviceFilter;
+    serviceFilter.serviceId = 12345;
+    serviceFilter.serviceType = "testServiceType";
+    serviceFilter.serviceName = "testServiceName";
+    serviceFilter.serviceDisplayName = "testServiceDisplayName";
+    serviceFilter.customData = "testCustomData";
+
+    EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
+    EXPECT_CALL(*deviceManagerServiceImplMock_, StopServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+    int32_t ret = DeviceManagerService::GetInstance().StopServiceDiscovery(serviceFilter);
+    EXPECT_EQ(ret, DM_OK);
+}
 } // namespace
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/unittest/UTTest_device_manager_service_three.h b/test/unittest/UTTest_device_manager_service_three.h
index 4f7c7666b6e5a05ef8999c06b4083109734670a1..3f03c34ccac86f17a0f9e2d95a3c2e4630b15634 100644
--- a/test/unittest/UTTest_device_manager_service_three.h
+++ b/test/unittest/UTTest_device_manager_service_three.h
@@ -31,6 +31,7 @@
 #include "softbus_listener_mock.h"
 #include "device_manager_service_mock.h"
 #include "device_manager_service_impl_mock.h"
+#include "multiple_user_connector_mock.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -49,6 +50,8 @@ public:
         std::make_shared<SoftbusListenerMock>();
     static inline  std::shared_ptr<DeviceManagerServiceImplMock> deviceManagerServiceImplMock_ =
         std::make_shared<DeviceManagerServiceImplMock>();
+    static inline  std::shared_ptr<MultipleUserConnectorMock> multipleUserConnectorMock_ =
+        std::make_shared<MultipleUserConnectorMock>();
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/test/unittest/UTTest_dm_service_discovery_manager.cpp b/test/unittest/UTTest_dm_service_discovery_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0f9f7fce144a7b0b704dc163ca96f7a114002362
--- /dev/null
+++ b/test/unittest/UTTest_dm_service_discovery_manager.cpp
@@ -0,0 +1,248 @@
+/*
+ * 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 "UTTest_dm_service_discovery_manager.h"
+
+#include <iostream>
+
+//#include "dm_log.h"
+#include "dm_constants.h"
+// #include "dm_adapter_manager.h"
+// #include "ipc_notify_device_state_req.h"
+// #include "ipc_notify_auth_result_req.h"
+// #include "ipc_notify_device_found_req.h"
+// #include "ipc_notify_discover_result_req.h"
+// #include "hichain_connector.h"
+// #include "device_manager_service_listener.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+namespace OHOS {
+namespace DistributedHardware {
+void DmServiceDiscoveryManagerTest::SetUp()
+{
+    if (discoveryManager_ == nullptr) {
+        discoveryManager_ = std::make_shared<DmServiceDiscoveryManager>(softbusConnector_, listener_);
+    }
+}
+
+void DmServiceDiscoveryManagerTest::TearDown()
+{
+    Mock::VerifyAndClearExpectations(softbusConnectorMock_.get());
+    Mock::VerifyAndClearExpectations(dmServiceDiscoveryManagerMock_.get());
+}
+
+void DmServiceDiscoveryManagerTest::SetUpTestCase()
+{
+    softbusConnectorMock_ = std::make_shared<SoftbusConnectorMock>();
+    DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock_;
+    dmServiceDiscoveryManagerMock_ = std::make_shared<DmServiceDiscoveryManagerMock>();
+    DmDmServiceDiscoveryManager::dmServiceDiscoveryManager = dmServiceDiscoveryManagerMock_;
+}
+
+void DmServiceDiscoveryManagerTest::TearDownTestCase()
+{
+    DmSoftbusConnector::dmSoftbusConnector = nullptr;
+    softbusConnectorMock_ = nullptr;
+    DmDmServiceDiscoveryManager::dmServiceDiscoveryManager = nullptr;
+    dmServiceDiscoveryManagerMock_ = nullptr;
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, ServiceDiscoveryTimer_001, testing::ext::TestSize.Level1)
+{
+    int64_t serviceId = 12345;
+
+    discoveryManager_->timer_ = nullptr;
+    discoveryManager_->ServiceDiscoveryTimer(serviceId);
+    EXPECT_NE(discoveryManager_->timer_, nullptr);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, ServiceDiscoveryTimer_002, testing::ext::TestSize.Level1)
+{
+    int64_t serviceId = 12345;
+
+    discoveryManager_->timer_ = std::make_shared<DmTimer>();
+    discoveryManager_->ServiceDiscoveryTimer(serviceId);
+    EXPECT_NE(discoveryManager_->timer_, nullptr);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, CheckDiscoveryMap_001, testing::ext::TestSize.Level1)
+{
+    discoveryManager_->discoveryMap_.clear();
+    ServiceInfoProfile serviceInfoProfile;
+    int32_t ret = discoveryManager_->CheckDiscoveryMap(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+    EXPECT_TRUE(discoveryManager_->discoveryMap_.empty());
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, CheckDiscoveryMap_002, testing::ext::TestSize.Level1)
+{
+    discoveryManager_->discoveryMap_.clear();
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+    discoveryManager_->discoveryMap_.emplace(67890, serviceInfoProfile);
+    int32_t ret = discoveryManager_->CheckDiscoveryMap(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, CheckDiscoveryMap_003, testing::ext::TestSize.Level1)
+{
+    discoveryManager_->discoveryMap_.clear();
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+    discoveryManager_->discoveryMap_.emplace(12345, serviceInfoProfile);
+    int32_t ret = discoveryManager_->CheckDiscoveryMap(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, CheckDiscoveryMap_004, testing::ext::TestSize.Level1)
+{
+    discoveryManager_->discoveryMap_.clear();
+    std::size_t DM_MAX_SERVICE_ID_NUM = 900000;
+    for (std::size_t i = 0; i < DM_MAX_SERVICE_ID_NUM; ++i) {
+        ServiceInfoProfile serviceInfoProfile;
+        serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = i;
+        discoveryManager_->discoveryMap_.emplace(i, serviceInfoProfile);
+    }
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = DM_MAX_SERVICE_ID_NUM + 1;
+    int32_t ret = discoveryManager_->CheckDiscoveryMap(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, CheckDiscoveryMap_005, testing::ext::TestSize.Level1)
+{
+    discoveryManager_->discoveryMap_.clear();
+    std::size_t DM_MAX_SERVICE_ID_NUM = 900000;
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.tokenId = "testTokenId";
+    for (std::size_t i = 0; i < DM_MAX_SERVICE_ID_NUM; ++i) {
+        ServiceInfoProfile historyServiceInfo;
+        historyServiceInfo.tokenId = "testTokenId";
+        discoveryManager_->discoveryMap_.emplace(i, historyServiceInfo);
+    }
+    int32_t ret = discoveryManager_->CheckDiscoveryMap(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StartServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, CheckDiscoveryMap(testing::_)).WillOnce(Return(ERR_DM_DISCOVERY_REPEATED));
+    int32_t ret = discoveryManager_->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StartServiceDiscovery_002, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, CheckDiscoveryMap(testing::_)).WillOnce(Return(DM_OK));
+    EXPECT_CALL(*softbusConnectorMock_, RegisterServiceDiscoveryCallback(12345, testing::_)).Times(1);
+    EXPECT_CALL(*softbusConnectorMock_, StartServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+
+    int32_t ret = discoveryManager_->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StartServiceDiscovery_003, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 67890;
+
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, CheckDiscoveryMap(testing::_)).WillOnce(Return(DM_OK));
+    EXPECT_CALL(*softbusConnectorMock_, RegisterServiceDiscoveryCallback(67890, testing::_)).Times(1);
+    EXPECT_CALL(*softbusConnectorMock_, StartServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+
+    int32_t ret = discoveryManager_->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StartServiceDiscovery_004, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, CheckDiscoveryMap(testing::_)).WillOnce(Return(DM_OK));
+    EXPECT_CALL(*softbusConnectorMock_, RegisterServiceDiscoveryCallback(12345, testing::_)).Times(1);
+    EXPECT_CALL(*softbusConnectorMock_, StartServiceDiscovery(testing::_)).WillOnce(Return(ERR_DM_DISCOVERY_FAILED));
+
+    int32_t ret = discoveryManager_->StartServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StopServiceDiscovery_001, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+
+    discoveryManager_->discoveryMap_.clear();
+    int32_t ret = discoveryManager_->StopServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StopServiceDiscovery_002, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+
+    discoveryManager_->timer_ = std::make_shared<DmTimer>();
+    discoveryManager_->discoveryMap_.emplace(12345, serviceInfoProfile);
+
+    EXPECT_CALL(*softbusConnectorMock_, UnRegisterServiceDiscoveryCallback(12345)).Times(1);
+    EXPECT_CALL(*softbusConnectorMock_, StopServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+
+    int32_t ret = discoveryManager_->StopServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, StopServiceDiscovery_003, testing::ext::TestSize.Level1)
+{
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+
+    discoveryManager_->timer_ = nullptr;
+    discoveryManager_->discoveryMap_.emplace(12345, serviceInfoProfile);
+
+    EXPECT_CALL(*softbusConnectorMock_, UnRegisterServiceDiscoveryCallback(12345)).Times(0);
+    EXPECT_CALL(*softbusConnectorMock_, StopServiceDiscovery(testing::_)).WillOnce(Return(DM_OK));
+
+    int32_t ret = discoveryManager_->StopServiceDiscovery(serviceInfoProfile);
+    EXPECT_EQ(ret, DM_OK);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, HandleDiscoveryTimeout_001, testing::ext::TestSize.Level1)
+{
+    std::string timeoutTaskName = std::string("deviceManagerTiner:discoveryservice") + "12345";
+    discoveryManager_->discoveryMap_.clear();
+
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, StopServiceDiscovery(testing::_)).Times(0);
+    discoveryManager_->HandleDiscoveryTimeout(timeoutTaskName);
+}
+
+HWTEST_F(DmServiceDiscoveryManagerTest, HandleDiscoveryTimeout_002, testing::ext::TestSize.Level1)
+{
+    std::string timeoutTaskName = std::string("deviceManagerTiner:discoveryservice") + "12345";
+    ServiceInfoProfile serviceInfoProfile;
+    serviceInfoProfile.serviceRegInfo.serviceInfo.serviceId = 12345;
+    discoveryManager_->discoveryMap_.emplace(12345, serviceInfoProfile);
+
+    EXPECT_CALL(*dmServiceDiscoveryManagerMock_, StopServiceDiscovery(testing::_)).Times(1);
+    discoveryManager_->HandleDiscoveryTimeout(timeoutTaskName);
+}
+}
+}
\ No newline at end of file
diff --git a/test/unittest/UTTest_dm_service_discovery_manager.h b/test/unittest/UTTest_dm_service_discovery_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..033f11446a8ce10d3fbd54fb9b82e83035e6744b
--- /dev/null
+++ b/test/unittest/UTTest_dm_service_discovery_manager.h
@@ -0,0 +1,47 @@
+/*
+ * 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_UTTEST_DM_DEVICE_DISCOVERY_MANAGER_H
+#define OHOS_UTTEST_DM_DEVICE_DISCOVERY_MANAGER_H
+
+#include <gtest/gtest.h>
+#include <refbase.h>
+
+#include "dm_service_discovery_manager.h"
+#include "device_manager_service_listener.h"
+#include "softbus_connector.h"
+#include "dm_service_discovery_manager_mock.h"
+#include "softbus_connector_mock.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class DmServiceDiscoveryManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+
+    std::shared_ptr<SoftbusConnector> softbusConnector_ = std::make_shared<SoftbusConnector>();
+    std::shared_ptr<IDeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
+    std::shared_ptr<DmServiceDiscoveryManager> discoveryManager_ =
+        std::make_shared<DmServiceDiscoveryManager>(softbusConnector_, listener_);
+    static inline std::shared_ptr<SoftbusConnectorMock> softbusConnectorMock_ =
+        std::make_shared<SoftbusConnectorMock>();
+    static inline std::shared_ptr<DmServiceDiscoveryManagerMock> dmServiceDiscoveryManagerMock_ =
+        std::make_shared<DmServiceDiscoveryManagerMock>();
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif
diff --git a/test/unittest/mock/device_manager_service_impl_mock.cpp b/test/unittest/mock/device_manager_service_impl_mock.cpp
index e939ec1b3e08ab634dcc34ea904100a01e8b474c..6748de57b0f5dc96fa60852b521e6c4849385476 100644
--- a/test/unittest/mock/device_manager_service_impl_mock.cpp
+++ b/test/unittest/mock/device_manager_service_impl_mock.cpp
@@ -116,5 +116,15 @@ bool DeviceManagerServiceImpl::CheckIsSameAccount(const DmAccessCaller &caller,
     return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->CheckIsSameAccount(caller, srcUdid, callee,
         sinkUdid);
 }
+
+int32_t DeviceManagerServiceImpl::StartServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->StartServiceDiscovery(serviceInfoProfile);
+}
+
+int32_t DeviceManagerServiceImpl::StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl->StopServiceDiscovery(serviceInfoProfile);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/mock/device_manager_service_impl_mock.h b/test/unittest/mock/device_manager_service_impl_mock.h
index a8d9e45a899c4865e799be0c5b46ea15c1cd4e13..152b245d4889773011d22b6f80308d36abed5108 100644
--- a/test/unittest/mock/device_manager_service_impl_mock.h
+++ b/test/unittest/mock/device_manager_service_impl_mock.h
@@ -50,6 +50,8 @@ public:
         const DmAccessCallee &callee, const std::string &sinkUdid) = 0;
     virtual bool CheckIsSameAccount(const DmAccessCaller &caller, const std::string &srcUdid,
         const DmAccessCallee &callee, const std::string &sinkUdid) = 0;
+    virtual int32_t StartServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile) = 0;
+    virtual int32_t StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile) = 0;
 public:
     static inline std::shared_ptr<DmDeviceManagerServiceImpl> dmDeviceManagerServiceImpl = nullptr;
 };
@@ -77,6 +79,8 @@ public:
         const DmAccessCallee &callee, const std::string &sinkUdid));
     MOCK_METHOD(bool, CheckIsSameAccount, (const DmAccessCaller &caller, const std::string &srcUdid,
         const DmAccessCallee &callee, const std::string &sinkUdid));
+    MOCK_METHOD(int32_t, StartServiceDiscovery, (const ServiceInfoProfile& serviceInfoProfile));
+    MOCK_METHOD(int32_t, StopServiceDiscovery, (const ServiceInfoProfile& serviceInfoProfile));
 };
 }
 }
diff --git a/test/unittest/mock/dm_service_discovery_manager_mock.cpp b/test/unittest/mock/dm_service_discovery_manager_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8deb02daf25255aae7e3505a61ddb28cdbb5f665
--- /dev/null
+++ b/test/unittest/mock/dm_service_discovery_manager_mock.cpp
@@ -0,0 +1,33 @@
+/*
+ * 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 "dm_service_discovery_manager_mock.h"
+
+#include "gtest/gtest.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+
+int32_t DmServiceDiscoveryManager::CheckDiscoveryMap(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmDmServiceDiscoveryManager::dmServiceDiscoveryManager->CheckDiscoveryMap(serviceInfoProfile);
+}
+
+int32_t DmServiceDiscoveryManager::StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmDmServiceDiscoveryManager::dmServiceDiscoveryManager->StopServiceDiscovery(serviceInfoProfile);
+}
+} // namespace DistributedHardware
+} // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/mock/dm_service_discovery_manager_mock.h b/test/unittest/mock/dm_service_discovery_manager_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0d0f6cfef8cd1c1cbe1e80a71f54429cd6708f9
--- /dev/null
+++ b/test/unittest/mock/dm_service_discovery_manager_mock.h
@@ -0,0 +1,43 @@
+/*
+ * 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_DM_SERVICE_DISCOVERY_MANAGER_MOCK_H
+#define OHOS_DM_SERVICE_DISCOVERY_MANAGER_MOCK_H
+
+#include <string>
+#include <gmock/gmock.h>
+
+#include "dm_service_discovery_manager.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class DmDmServiceDiscoveryManager {
+public:
+    virtual ~DmDmServiceDiscoveryManager() = default;
+public:
+    virtual int32_t CheckDiscoveryMap(const ServiceInfoProfile& serviceInfoProfile) = 0;
+    virtual int32_t StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile) = 0;
+    
+public:
+    static inline std::shared_ptr<DmDmServiceDiscoveryManager> dmServiceDiscoveryManager = nullptr;
+};
+
+class DmServiceDiscoveryManagerMock : public DmDmServiceDiscoveryManager {
+public:
+    MOCK_METHOD(int32_t, CheckDiscoveryMap, (const ServiceInfoProfile& serviceInfoProfile));
+    MOCK_METHOD(int32_t, StopServiceDiscovery, (const ServiceInfoProfile& serviceInfoProfile));
+};
+}
+}
+#endif
diff --git a/test/unittest/mock/softbus_connector_mock.cpp b/test/unittest/mock/softbus_connector_mock.cpp
index d49c8c253cca5c3fd2e4fd1dad7a6cb08dee23bc..27d42e889836cfc924291cedc60e32302b7dcbc3 100644
--- a/test/unittest/mock/softbus_connector_mock.cpp
+++ b/test/unittest/mock/softbus_connector_mock.cpp
@@ -59,5 +59,26 @@ int32_t SoftbusConnector::SyncLocalAclListProcess(const DevUserInfo &localDevUse
     return DmSoftbusConnector::dmSoftbusConnector->SyncLocalAclListProcess(localDevUserInfo, remoteDevUserInfo,
                                                                            remoteAclList);
 }
+
+int32_t SoftbusConnector::RegisterServiceDiscoveryCallback(int64_t serviceId,
+    const std::shared_ptr<IServiceDiscoveryCallback> callback)
+{
+    return DmSoftbusConnector::dmSoftbusConnector->RegisterServiceDiscoveryCallback(serviceId, callback);
+}
+
+int32_t SoftbusConnector::StartServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmSoftbusConnector::dmSoftbusConnector->StartServiceDiscovery(serviceInfoProfile);
+}
+
+int32_t SoftbusConnector::StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile)
+{
+    return DmSoftbusConnector::dmSoftbusConnector->StopServiceDiscovery(serviceInfoProfile);
+}
+
+int32_t SoftbusConnector::UnRegisterServiceDiscoveryCallback(int64_t serviceId)
+{
+    return DmSoftbusConnector::dmSoftbusConnector->UnRegisterServiceDiscoveryCallback(serviceId);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/mock/softbus_connector_mock.h b/test/unittest/mock/softbus_connector_mock.h
index e71d229f659cdbd9e6264fc0ec65ddbd797c72c8..cc4eb410fba68498b3bc20d2a98f07256ad27f56 100644
--- a/test/unittest/mock/softbus_connector_mock.h
+++ b/test/unittest/mock/softbus_connector_mock.h
@@ -35,7 +35,11 @@ public:
     virtual void SetProcessInfoVec(std::vector<ProcessInfo> processInfoVec) = 0;
     virtual int32_t SyncLocalAclListProcess(const DevUserInfo &localDevUserInfo, const DevUserInfo &remoteDevUserInfo,
                                             std::string remoteAclList) = 0;
-
+    virtual int32_t RegisterServiceDiscoveryCallback(int64_t serviceId,
+        const std::shared_ptr<IServiceDiscoveryCallback> callback) = 0;
+    virtual int32_t StartServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile) = 0;
+    virtual int32_t StopServiceDiscovery(const ServiceInfoProfile& serviceInfoProfile) = 0;
+    virtual int32_t UnRegisterServiceDiscoveryCallback(int64_t serviceId) = 0;
 public:
     static inline std::shared_ptr<DmSoftbusConnector> dmSoftbusConnector = nullptr;
 };
@@ -50,6 +54,11 @@ public:
     MOCK_METHOD(void, SetProcessInfo, (ProcessInfo processInfo));
     MOCK_METHOD(void, SetProcessInfoVec, (std::vector<ProcessInfo> processInfoVec));
     MOCK_METHOD(int32_t, SyncLocalAclListProcess, (const DevUserInfo &, const DevUserInfo &, std::string));
+    MOCK_METHOD(int32_t, RegisterServiceDiscoveryCallback, (int64_t serviceId,
+        const std::shared_ptr<IServiceDiscoveryCallback> callback));
+    MOCK_METHOD(int32_t, StartServiceDiscovery, (const ServiceInfoProfile& serviceInfoProfile));
+    MOCK_METHOD(int32_t, StopServiceDiscovery, (const ServiceInfoProfile& serviceInfoProfile));
+    MOCK_METHOD(int32_t, UnRegisterServiceDiscoveryCallback, (int64_t serviceId));
 };
 }
 }