diff --git a/adapter/uhdf2/hdi/test/BUILD.gn b/adapter/uhdf2/hdi/test/BUILD.gn
index 5b4240dc857d97fc8db29183a43030bdf29182d2..fcd96a10100164e21c01a1635bcfb210b3ddfd32 100644
--- a/adapter/uhdf2/hdi/test/BUILD.gn
+++ b/adapter/uhdf2/hdi/test/BUILD.gn
@@ -33,6 +33,7 @@ ohos_unittest("HdiServiceManagerTest") {
   include_dirs = [
     "$hdf_uhdf_path/host/test/unittest/sample_driver",
     "$hdf_uhdf_path/utils/include",
+    "$hdf_framework_path/core/shared/include",
   ]
 
   if (with_sample) {
diff --git a/adapter/uhdf2/hdi/test/object_collector/object_collector_test.cpp b/adapter/uhdf2/hdi/test/object_collector/object_collector_test.cpp
index f95c85567f9b655cf4717abadb4689acabb336d1..a632492e5265a0cb98d6a6fd463331b6f1468cb8 100644
--- a/adapter/uhdf2/hdi/test/object_collector/object_collector_test.cpp
+++ b/adapter/uhdf2/hdi/test/object_collector/object_collector_test.cpp
@@ -38,10 +38,21 @@ public:
     void SetUp() {};
     void TearDown() {};
 };
+static bool TestRemove()
+{
+    return HDI::ObjectCollector::GetInstance().RemoveObject(nullptr);
+}
 
 HWTEST_F(ObjectCollectorTest, ObjectCollectorTest001, TestSize.Level1)
 {
     sptr<IRemoteObject> object = HDI::ObjectCollector::GetInstance().NewObject(nullptr, INTERFACE_NAME);
     ASSERT_EQ(object, nullptr);
+    object = HDI::ObjectCollector::GetInstance().GetOrNewObject(nullptr, INTERFACE_NAME);
+    ASSERT_EQ(object, nullptr);
+    bool remove = false;
+    if (!TestRemove()) {
+        remove = true;
+    }
+    ASSERT_EQ(remove, true);
 }
 } // namespace OHOS
\ No newline at end of file
diff --git a/adapter/uhdf2/hdi/test/servmgr/service_manager_hdi_c_test.cpp b/adapter/uhdf2/hdi/test/servmgr/service_manager_hdi_c_test.cpp
index 291c9ac7f273a08bb25548dd3bf7cf70834e7304..f31fc00d46642d99b3fc52d9a216844eceefddfb 100644
--- a/adapter/uhdf2/hdi/test/servmgr/service_manager_hdi_c_test.cpp
+++ b/adapter/uhdf2/hdi/test/servmgr/service_manager_hdi_c_test.cpp
@@ -21,6 +21,7 @@
 #include <hdf_sbuf.h>
 #include <hdf_service_status.h>
 #include <osal_time.h>
+#include <osal_mem.h>
 #include <servmgr_hdi.h>
 #include <shared_mem.h>
 #include <string>
@@ -28,6 +29,8 @@
 
 #include "sample_hdi.h"
 #include "hdi_support.h"
+#include <hdf_service_status_inner.h>
+#include <hdf_dlist.h>
 
 #define HDF_LOG_TAG service_manager_test
 
@@ -805,4 +808,20 @@ HWTEST_F(HdfServiceMangerHdiCTest, HdiSupportTest, TestSize.Level1)
     ASSERT_EQ(LoadHdiImpl(NULL, NULL), nullptr);
     UnloadHdiImpl(NULL, NULL, NULL);
 }
+
+HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest019, TestSize.Level1)
+{
+    struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
+    HdiServiceStatusListenerFree(nullptr);
+    struct HDIServiceManager *servmgr = HDIServiceManagerGet();
+    int ret = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT);
+    ASSERT_TRUE(ret == HDF_SUCCESS);
+    ret = servmgr->UnregisterServiceStatusListener(servmgr, listener);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
+    struct HdiServiceSet *serviceSet = (struct HdiServiceSet *)OsalMemAlloc(sizeof(struct HdiServiceSet));
+    serviceSet->count = 20;
+    ret = HdiServiceSetRelease(serviceSet);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
+    HdiServiceStatusListenerFree(listener);
+}
 } // namespace OHOS
\ No newline at end of file
diff --git a/adapter/uhdf2/hdi/test/smq_test/smq_test.cpp b/adapter/uhdf2/hdi/test/smq_test/smq_test.cpp
index f2584fc9fcdb51fc0f1eece3bdbef91ca64984e4..1fed1af9b5699882185d284c1af41f934544e83e 100644
--- a/adapter/uhdf2/hdi/test/smq_test/smq_test.cpp
+++ b/adapter/uhdf2/hdi/test/smq_test/smq_test.cpp
@@ -14,6 +14,10 @@
  */
 
 #include <base/hdi_smq.h>
+#include <base/hdi_smq_meta.h>
+#include <base/hdi_smq_syncer.h>
+#include "osal_mem.h"
+#include <sys/mman.h>
 #include <gtest/gtest.h>
 #include <idevmgr_hdi.h>
 #include <iservmgr_hdi.h>
@@ -38,6 +42,7 @@ using OHOS::HDI::Base::SmqType;
 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
 
+static constexpr const uint32_t TEST_NUM = 300;
 #ifdef SAMPLE_DRIVER
 static constexpr const char *TEST_SERVICE_HOST_NAME = "sample_host";
 static constexpr const char *SERVICE_NAME = "sample_driver_service";
@@ -306,4 +311,41 @@ HWTEST_F(SmqTest, SmqTest002, TestSize.Level1)
         PrintFds("sample_host unclosed fds:", servHostUnclosedFds);
     }
 }
-#endif
\ No newline at end of file
+#endif
+
+static uintptr_t MapMemZone(uint32_t zoneType)
+{
+    std::shared_ptr<SharedMemQueueMeta<uint8_t>> meta_ =
+        std::make_shared<SharedMemQueueMeta<uint8_t>>(TEST_NUM, SmqType::SYNCED_SMQ);
+    auto memzone = meta_->GetMemZone(zoneType);
+    if (memzone == nullptr) {
+        HDF_LOGE("invalid smq mem zone type %{public}u", zoneType);
+        return reinterpret_cast<uintptr_t>(nullptr);
+    }
+
+    int offset = (static_cast<int>(memzone->offset) / PAGE_SIZE) * PAGE_SIZE;
+    int length = static_cast<int>(memzone->offset) - offset + static_cast<int>(memzone->size);
+
+    void *ptr = mmap(0, length, PROT_READ | PROT_WRITE, MAP_SHARED, meta_->GetFd(), offset);
+    if (ptr == MAP_FAILED) {
+        HDF_LOGE(
+            "failed to map memzone %{public}u, size %{public}u, offset %{public}u , fd %{public}d, errnor=%{public}d",
+            zoneType, length, offset, meta_->GetFd(), errno);
+        unsigned int num = 20;
+        unsigned int *uptr = &num;
+        return reinterpret_cast<uintptr_t>(uptr);
+    }
+    return (reinterpret_cast<uintptr_t>(ptr) + (static_cast<int>(memzone->offset) - offset));
+}
+
+HWTEST_F(SmqTest, SmqTest003, TestSize.Level1)
+{
+    std::atomic<uint32_t> *syncerPtr_ =
+        reinterpret_cast<std::atomic<uint32_t> *>(MapMemZone(SharedMemQueueMeta<uint8_t>::MEMZONE_SYNCER));
+    std::unique_ptr<OHOS::HDI::Base::SharedMemQueueSyncer> syncer_ =
+        std::make_unique<OHOS::HDI::Base::SharedMemQueueSyncer>(syncerPtr_);
+    syncer_->Wake(OHOS::HDI::Base::SharedMemQueueSyncer::SYNC_WORD_WRITE);
+    syncer_->Wait(OHOS::HDI::Base::SharedMemQueueSyncer::SYNC_WORD_WRITE, 0);
+    syncer_->Wake(OHOS::HDI::Base::SharedMemQueueSyncer::SYNC_WORD_WRITE);
+    syncer_->Wait(OHOS::HDI::Base::SharedMemQueueSyncer::SYNC_WORD_WRITE, 5);
+}
\ No newline at end of file
diff --git a/adapter/uhdf2/host/test/unittest/devhost_test.cpp b/adapter/uhdf2/host/test/unittest/devhost_test.cpp
index 69d1286f14a978cf69ae0dd0bc67d97a42f857aa..cf51c647b55d452c432671b807015be9123ae306 100644
--- a/adapter/uhdf2/host/test/unittest/devhost_test.cpp
+++ b/adapter/uhdf2/host/test/unittest/devhost_test.cpp
@@ -32,6 +32,8 @@
 #include "hdf_log.h"
 #include "hdf_sbuf.h"
 #include "osal_mem.h"
+#include "hdf_device_object.h"
+
 
 #define HDF_LOG_TAG   host_test
 
@@ -74,6 +76,9 @@ HWTEST_F(DevHostTest, DevHostDevMgrServiceProxyTest, TestSize.Level1)
     ASSERT_TRUE(ret != HDF_SUCCESS);
     ret = instance->LoadDevice(instance, nullptr);
     ASSERT_TRUE(ret != HDF_SUCCESS);
+    const char *name = "test_svcName";
+    ret = instance->LoadDevice(instance, name);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
 
     struct DevmgrServiceProxy *proxy = reinterpret_cast<struct DevmgrServiceProxy *>(object);
     HdfRemoteServiceRecycle(proxy->remote);
@@ -140,6 +145,7 @@ HWTEST_F(DevHostTest, DevHostDevSvcMgrProxyTest, TestSize.Level1)
     instance->RemoveService(instance, "test", nullptr);
     DevSvcManagerProxyRelease(object);
     DevSvcManagerProxyRelease(nullptr);
+    HdfDeviceObjectCheckInterfaceDesc(nullptr, nullptr);
 }
 
 HWTEST_F(DevHostTest, DevHostServiceTest, TestSize.Level1)
@@ -275,27 +281,33 @@ HWTEST_F(DevHostTest, DevHostDeviceNodeTest2, TestSize.Level1)
     struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
     ASSERT_TRUE(devNode != nullptr);
     HdfDeviceNodeConstruct(devNode);
+    devNode->hostService = nullptr;
     struct IDeviceNode *nodeIf = &devNode->super;
     int32_t ret = nodeIf->LaunchNode(devNode);
+    devNode->devStatus = DEVNODE_NONE;
+    nodeIf->UnlaunchNode(devNode);
 
     entry.Bind = HdfTestFailBind;
     entry.Init = HdfTestInit;
     devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
     ASSERT_TRUE(devNode != nullptr);
     HdfDeviceNodeConstruct(devNode);
-    nodeIf = &devNode->super;
+    nodeIf = &devNode->super;\
+    devNode->hostService = nullptr;
     ret = nodeIf->LaunchNode(devNode);
 
     entry.Init = nullptr;
     devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
     ASSERT_TRUE(devNode != nullptr);
     HdfDeviceNodeConstruct(devNode);
+    devNode->hostService = nullptr;
     nodeIf = &devNode->super;
     ret = nodeIf->LaunchNode(devNode);
     ASSERT_TRUE(ret != HDF_SUCCESS);
 
     devNode->devStatus = DEVNODE_NONE;
     nodeIf->UnlaunchNode(devNode);
+    DevmgrServiceClntDetachDevice(devNode->devId);
 }
 
 HWTEST_F(DevHostTest, DevHostDeviceNodeTest3, TestSize.Level1)
@@ -321,6 +333,8 @@ HWTEST_F(DevHostTest, DevHostDeviceNodeTest3, TestSize.Level1)
     HdfDeviceNodeRemovePowerStateListener(nullptr, nullptr);
     HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
     HdfDeviceNodeRemovePowerStateListener(devNode, nullptr);
+    ret = HdfDeviceNodePublishPublicService(devNode);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
     devNode->deviceObject.service = nullptr;
     ret = HdfDeviceNodePublishPublicService(devNode);
     ASSERT_TRUE(ret != HDF_SUCCESS);
@@ -340,10 +354,30 @@ HWTEST_F(DevHostTest, DevHostDeviceNodeTest3, TestSize.Level1)
 
 HWTEST_F(DevHostTest, DevHostDeviceTest, TestSize.Level1)
 {
+    struct HdfDriverEntry entry;
+    entry.Bind = nullptr;
+    struct HdfDriver driver;
+    driver.entry = &entry;
+    struct HdfDeviceInfo deviceInfo;
+    deviceInfo.deviceId = 0;
+    deviceInfo.permission = 0;
+    deviceInfo.preload = 0;
+    deviceInfo.deviceType = 0;
+    deviceInfo.svcName = "driver_service";
+    deviceInfo.deviceName = "driver_module";
+
+    deviceInfo.policy = SERVICE_POLICY_PUBLIC;
+    entry.Bind = HdfTestSuccBind;
+    entry.Init = HdfTestInit;
+    struct HdfDeviceNode *devNode = HdfDeviceNodeNewInstance(&deviceInfo, &driver);
+    ASSERT_TRUE(devNode != nullptr);
+    HdfDeviceNodeConstruct(devNode);
     struct HdfObject *object = HdfDeviceCreate();
     ASSERT_TRUE(object != nullptr);
 
     struct IHdfDevice *device = reinterpret_cast<struct IHdfDevice *>(object);
+    devNode->devId = 0;
+    device->Attach(device, devNode);
     int32_t ret = device->Attach(device, nullptr);
     ASSERT_TRUE(ret != HDF_SUCCESS);
     ret = device->Attach(nullptr, nullptr);
@@ -356,6 +390,9 @@ HWTEST_F(DevHostTest, DevHostDeviceTest, TestSize.Level1)
     ASSERT_TRUE(ret != HDF_SUCCESS);
     ret = HdfDeviceDetach(device, nullptr);
     ASSERT_TRUE(ret != HDF_SUCCESS);
+    devNode->servStatus = true;
+    struct IDeviceNode *deviceIf = reinterpret_cast<struct IDeviceNode *>(object);
+    ret = deviceIf->RemoveService(devNode);
     HdfDeviceRelease(nullptr);
     HdfDeviceFreeInstance(nullptr);
 }
diff --git a/adapter/uhdf2/host/test/unittest/devmgr_test.cpp b/adapter/uhdf2/host/test/unittest/devmgr_test.cpp
index 45ea7f5c17748935393aab0dc2a1c28eed5ee5ea..7678e47bceacbb49d8758f4722c2f13b1545591a 100644
--- a/adapter/uhdf2/host/test/unittest/devmgr_test.cpp
+++ b/adapter/uhdf2/host/test/unittest/devmgr_test.cpp
@@ -21,6 +21,8 @@
 #include <servmgr_hdi.h>
 #include "hdf_dump.h"
 #include "hdf_dump_reg.h"
+#include "hcs_tree_if.h"
+#include "hcs_dm_parser.h"
 
 #define HDF_LOG_TAG   driver_manager
 
@@ -148,15 +150,45 @@ HWTEST_F(DevMgrTest, DriverTest, TestSize.Level1)
 }
 #endif
 
+static int TestDump(struct HdfSBuf *, struct HdfSBuf *)
+{
+    return HDF_SUCCESS;
+}
+
 HWTEST_F(DevMgrTest, DevMgrDumpErrorTest, TestSize.Level1)
 {
     ASSERT_TRUE(servmgr != nullptr);
     ASSERT_TRUE(devmgr != nullptr);
     HdfRegisterDumpFunc(nullptr);
+    int32_t fd = 0;
+    HdfRegisterDumpFunc(TestDump);
+    const std::vector<std::u16string> vcr = {u"123", u"456"};
+    const std::vector<std::u16string> vcr1 = {
+        u"1", u"2", u"3", u"4", u"5", u"6", u"7", u"8", u"9", u"10",
+        u"11", u"12", u"13", u"14", u"15", u"16", u"17", u"18", u"19", u"20",
+        u"21", u"22", u"23", u"24"
+    };
+    int ret = HdfDump(fd, vcr);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
+    fd = 1;
+    ret = HdfDump(fd, vcr1);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
 
     int32_t illegalFd = -1;
     std::vector<std::u16string> illegalArgs = {};
-    int ret = HdfDump(illegalFd, illegalArgs);
+    ret = HdfDump(illegalFd, illegalArgs);
     ASSERT_TRUE(ret != HDF_SUCCESS);
 }
+
+HWTEST_F(DevMgrTest, HdfUtilsTest, TestSize.Level1)
+{
+    std::string CONFIGPATH = "/system/etc/hdfconfig/default";
+    std::string CONFIGPATH1 = "/system/etc/hdfconfig/default.hcb";
+    SetHcsBlobPath(CONFIGPATH.c_str());
+    const struct DeviceResourceNode *node = HcsGetRootNode();
+    ASSERT_TRUE(node == nullptr);
+    SetHcsBlobPath(CONFIGPATH1.c_str());
+    const struct DeviceResourceNode *node1 = HcsGetRootNode();
+    ASSERT_TRUE(node1 == nullptr);
+}
 } // namespace OHOS
diff --git a/framework/core/manager/test/unittest/common/hdf_remote_adapter_test.cpp b/framework/core/manager/test/unittest/common/hdf_remote_adapter_test.cpp
index f744bdc60d64489ee10b7be23852e2ea611a5568..04754bffc08fdb97fa6d88fa2d9010d2a3a90f2d 100644
--- a/framework/core/manager/test/unittest/common/hdf_remote_adapter_test.cpp
+++ b/framework/core/manager/test/unittest/common/hdf_remote_adapter_test.cpp
@@ -21,6 +21,7 @@
 #include "hdf_remote_adapter.h"
 #include "hdf_remote_adapter_if.h"
 #include "hdf_sbuf_ipc.h"
+#include "hdf_dump.h"
 
 namespace OHOS {
 using namespace testing::ext;
@@ -61,6 +62,13 @@ HWTEST_F(HdfRemoteAdapterTest, HdfRemoteAdapterTest002, TestSize.Level1)
     ret = HdfRemoteAdapterAddService(name, NULL);
     ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
 
+    const char *serviceName = "test_service";
+    HdfRemoteService *remoteService = HdfRemoteAdapterObtain();
+    ret = HdfRemoteAdapterAddService(serviceName, remoteService);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
+    ret = HdfRemoteAdapterAddSa(-1, remoteService);
+    ASSERT_TRUE(ret != HDF_SUCCESS);
+
     HdfRemoteService *remote = HdfRemoteAdapterGetService(NULL);
     ASSERT_EQ(remote, nullptr);
     remote = HdfRemoteAdapterGetService(name);
diff --git a/framework/core/shared/test/unittest/common/hdf_core_shared_test.cpp b/framework/core/shared/test/unittest/common/hdf_core_shared_test.cpp
index 7589bf87b4f33f27306bb9b0174b1ecd7fcc8114..3380d3ec2876e4f6ed7b2757b8a126e6c07933ef 100644
--- a/framework/core/shared/test/unittest/common/hdf_core_shared_test.cpp
+++ b/framework/core/shared/test/unittest/common/hdf_core_shared_test.cpp
@@ -70,7 +70,13 @@ HWTEST_F(HdfCoreSharedTest, ServiceStatusMarshallingTest, TestSize.Level1)
     ASSERT_NE(status, nullptr);
     ret = ServiceStatusMarshalling(status, nullptr);
     ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
+    HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
+    const char *serviceName = "testServiceName";
+    HdfSbufWriteString(sBuf, serviceName);
+    ret = ServiceStatusMarshalling(status, sBuf);
+    ASSERT_TRUE(ret !=HDF_FAILURE);
     OsalMemFree(status);
+    HdfSbufRecycle(sBuf);
 }
 
 HWTEST_F(HdfCoreSharedTest, ServiceStatusUnMarshallingTest, TestSize.Level1)