diff --git a/interfaces/innerkits/datatransmitmgr/BUILD.gn b/interfaces/innerkits/datatransmitmgr/BUILD.gn
index c6f21d4f84ff64afe02cf148f5ed3fd14ecbc6ec..f9e75debc5cc329d93ac6fdbd8bfa1054f970d66 100644
--- a/interfaces/innerkits/datatransmitmgr/BUILD.gn
+++ b/interfaces/innerkits/datatransmitmgr/BUILD.gn
@@ -40,9 +40,5 @@ ohos_shared_library("data_transit_mgr") {
     "hiviewdfx_hilog_native:libhilog",
   ]
 
-  cflags = [
-    "-Wall",
-    "--coverage",
-  ]
-  ldflags = [ "--coverage" ]
+  cflags = [ "-Wall" ]
 }
diff --git a/test/unittest/datatransmitmgr/BUILD.gn b/test/unittest/datatransmitmgr/BUILD.gn
index 058c60ccde6b9b80ead16ce88eafc86b27933a9a..58eef5043fc345e8f9c0dee3f0285c08db042f2c 100644
--- a/test/unittest/datatransmitmgr/BUILD.gn
+++ b/test/unittest/datatransmitmgr/BUILD.gn
@@ -45,6 +45,4 @@ ohos_unittest("DevSLMgrTest") {
     "dsoftbus:softbus_client",
     "hiviewdfx_hilog_native:libhilog",
   ]
-  cflags_cc = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 }
diff --git a/test/unittest/datatransmitmgr/DevSLMgrTest.cpp b/test/unittest/datatransmitmgr/DevSLMgrTest.cpp
index 2d08ad297cfd6bceb9591fdb2507012a6de3ce36..14d2a84d89bab7e115ffe897f60c43b61e054a26 100644
--- a/test/unittest/datatransmitmgr/DevSLMgrTest.cpp
+++ b/test/unittest/datatransmitmgr/DevSLMgrTest.cpp
@@ -14,19 +14,21 @@
  */
 
 #include <iostream>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
 #include "gtest/gtest.h"
 #include "file_ex.h"
-#include "dev_slinfo_mgr.h"
 #include "securec.h"
 #include "softbus_bus_center.h"
 #include "dev_slinfo_adpt.h"
 #include "DevSLMgrTest.h"
+#include "DevslinfoListTest.h"
 #include "nativetoken_kit.h"
 #include "token_setproc.h"
 #include "accesstoken_kit.h"
 
 using namespace testing::ext;
-
 class DevSLMgrTest : public testing::Test {
 protected:
     DevSLMgrTest();
@@ -38,6 +40,18 @@ protected:
 private:
 };
 
+static const int32_t DEV_SEC_LEVEL_ERR = 100;
+
+struct DeviceSecurityInfo {
+    uint32_t magicNum {0};
+    uint32_t result {0};
+    uint32_t level {0};
+};
+
+extern "C" {
+    extern void OnApiDeviceSecInfoCallback(const DeviceIdentify *identify, struct DeviceSecurityInfo *info);
+}
+
 static void NativeTokenGet()
 {
     uint64_t tokenId;
@@ -81,6 +95,13 @@ static void DATASL_GetUdidByOpp(DEVSLQueryParams *queryParams)
     queryParams->udidLen = MAX_UDID_LENGTH;
 }
 
+static void DATASL_GetUdidByExcept(DEVSLQueryParams *queryParams)
+{
+    char udid[65] = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
+    (void)memcpy_s(queryParams->udid, MAX_UDID_LENGTH, udid, MAX_UDID_LENGTH);
+    queryParams->udidLen = MAX_UDID_LENGTH + 1;
+}
+
 static int32_t GetLocalUdid(DEVSLQueryParams *queryParams)
 {
     const char *pkgName = "ohos.dslm";
@@ -213,8 +234,13 @@ static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync003, TestSize.Level1)
     DATASL_OnStop();
 }
 
+static int32_t g_cnt = 0;
+static std::mutex g_mtx;
+static std::condition_variable g_cv;
+
 static void tmpCallbackLocal(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
 {
+    g_cnt++;
     EXPECT_EQ(DEVSL_SUCCESS, result);
 }
 
@@ -230,5 +256,136 @@ static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync004, TestSize.Level1)
     EXPECT_EQ(DEVSL_SUCCESS, ret);
     ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallbackLocal);
     EXPECT_EQ(DEVSL_SUCCESS, ret);
+
+    std::unique_lock<std::mutex> lck(g_mtx);
+    g_cv.wait_for(lck, std::chrono::milliseconds(2000), []() { return (g_cnt == 1); });
+    EXPECT_EQ(g_cnt, 1);
+
+    DATASL_OnStop();
+}
+
+static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept001, TestSize.Level1)
+{
+    OnApiDeviceSecInfoCallback(nullptr, nullptr);
+    GetDeviceSecLevelByUdidAsync(nullptr, 0);
+    int32_t ret;
+    uint32_t levelInfo = 0;
+    int32_t devLevel = 0;
+    DEVSLQueryParams queryParams;
+    (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
+    DATASL_GetUdidByExcept(&queryParams);
+    ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParams.udid), queryParams.udidLen, &devLevel);
+    EXPECT_EQ(DEVSL_ERROR, ret);
+    ret = DATASL_OnStart();
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+    ret = StartDevslEnv();
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+
+    ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
+    EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
+
+    DeviceIdentify devId;
+    (void)memset_s(&devId, sizeof(devId), 0, sizeof(devId));
+    (void)memcpy_s(devId.identity, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
+    devId.length = queryParams.udidLen;
+    DeviceSecurityInfo devInfo;
+
+    OnApiDeviceSecInfoCallback(&devId, nullptr);
+    OnApiDeviceSecInfoCallback(&devId, &devInfo);
+
     DATASL_OnStop();
+}
+
+static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept002, TestSize.Level1)
+{
+    int32_t ret;
+    int32_t devLevel = 0;
+    ret = DATASL_OnStart();
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+
+    DEVSLQueryParams queryParamsLocal;
+    (void)memset_s(&queryParamsLocal, sizeof(queryParamsLocal), 0, sizeof(queryParamsLocal));
+    ret = GetLocalUdid(&queryParamsLocal);
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+
+    DeviceSecurityInfo devInfo;
+    DeviceIdentify devIdLocal;
+    (void)memset_s(&devIdLocal, sizeof(devIdLocal), 0, sizeof(devIdLocal));
+    (void)memcpy_s(devIdLocal.identity, MAX_UDID_LENGTH, queryParamsLocal.udid, queryParamsLocal.udidLen);
+    devIdLocal.length = queryParamsLocal.udidLen;
+    OnApiDeviceSecInfoCallback(&devIdLocal, &devInfo);
+
+    DEVSLQueryParams queryParams;
+    (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
+    DATASL_GetUdidByExcept(&queryParams);
+    DEVSLQueryParams queryParamsOpp;
+    (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
+    DATASL_GetUdidByOpp(&queryParamsOpp);
+    ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParamsOpp.udid), queryParamsOpp.udidLen, &devLevel);
+    EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
+
+    DeviceIdentify devIdOpp;
+    OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
+
+    ret = CompareUdid(&queryParamsLocal, &queryParams);
+    EXPECT_EQ(DEVSL_ERROR, ret);
+
+    ret = CompareUdid(&queryParamsLocal, &queryParamsOpp);
+    EXPECT_EQ(DEVSL_ERROR, ret);
+
+    ret = CompareUdid(&queryParamsLocal, &queryParamsLocal);
+
+    uint32_t result = GetDataSecLevelByDevSecLevel(DEV_SEC_LEVEL_ERR);
+    EXPECT_EQ(DATA_SEC_LEVEL0, result);
+
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+    DATASL_OnStop();
+}
+
+static struct DATASLListParams *g_tmpList = nullptr;
+
+static void ListCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
+{
+    EXPECT_EQ(DEVSL_SUCCESS, DEVSL_SUCCESS);
+}
+
+static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept003, TestSize.Level1)
+{
+    int32_t ret = InitPthreadMutex();
+    EXPECT_EQ(DEVSL_SUCCESS, ret);
+
+    ClearList(g_tmpList);
+    DEVSLQueryParams queryParamsOpp;
+    (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
+    DATASL_GetUdidByOpp(&queryParamsOpp);
+
+    DeviceIdentify devIdOpp;
+    (void)memset_s(&devIdOpp, sizeof(devIdOpp), 0, sizeof(devIdOpp));
+    (void)memcpy_s(devIdOpp.identity, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
+    devIdOpp.length = queryParamsOpp.udidLen;
+    DeviceSecurityInfo devInfo;
+
+    OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
+
+    g_tmpList = InitList();
+    if (g_tmpList != nullptr) {
+        EXPECT_EQ(DEVSL_SUCCESS, DEVSL_SUCCESS);
+    } else {
+        EXPECT_EQ(DEVSL_SUCCESS, DEVSL_ERROR);
+    }
+
+    struct DATASLCallbackParams *newListNode =
+        (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
+    if (newListNode == nullptr) {
+        EXPECT_EQ(DEVSL_SUCCESS, DEVSL_SUCCESS);
+    }
+    (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
+    newListNode->queryParams.udidLen = queryParamsOpp.udidLen;
+    newListNode->callback = &ListCallback;
+
+    PushListNode(g_tmpList, newListNode);
+    RemoveListNode(g_tmpList, newListNode);
+    ClearList(g_tmpList);
+    g_tmpList = nullptr;
+    DestroyPthreadMutex();
 }
\ No newline at end of file
diff --git a/test/unittest/datatransmitmgr/DevSLMgrTest.h b/test/unittest/datatransmitmgr/DevSLMgrTest.h
index dce8740192f3203b0919c23fea3a2b8f583b7931..7bea2a84c968c5ba4ea157f96314c7b18c1cd589 100644
--- a/test/unittest/datatransmitmgr/DevSLMgrTest.h
+++ b/test/unittest/datatransmitmgr/DevSLMgrTest.h
@@ -27,4 +27,7 @@ int TestGetHighestSecLevelAsync002(void);
 int TestGetHighestSecLevelAsync003(void);
 int TestGetHighestSecLevelAsync004(void);
 
+int TestGetHighestSecLevelExcept001(void);
+int TestGetHighestSecLevelExcept002(void);
+
 #endif
\ No newline at end of file
diff --git a/test/unittest/datatransmitmgr/DevslinfoListTest.h b/test/unittest/datatransmitmgr/DevslinfoListTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..757a06efbb9a2d1a67000b1ff448387c2b362df1
--- /dev/null
+++ b/test/unittest/datatransmitmgr/DevslinfoListTest.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2022 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 DEV_SLINFO_LIST_TEST_H
+#define DEV_SLINFO_LIST_TEST_H
+
+#include <cstdlib>
+#include "dev_slinfo_mgr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct DATASLCallbackParams {
+    DEVSLQueryParams queryParams;
+    HigestSecInfoCallback *callback;
+};
+
+struct DATASLListParams {
+    struct DATASLCallbackParams *callbackParams;
+    struct DATASLListParams *prev;
+    struct DATASLListParams *next;
+};
+
+
+int32_t PushListNode(struct DATASLListParams *list, struct DATASLCallbackParams *callbackParams);
+
+void RemoveListNode(struct DATASLListParams *list, struct DATASLCallbackParams *callbackParams);
+
+void ClearList(struct DATASLListParams *list);
+
+int32_t GetListLength(struct DATASLListParams *list);
+
+int32_t InitPthreadMutex(void);
+
+void DestroyPthreadMutex(void);
+
+void LookupCallback(struct DATASLListParams *list, DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo);
+
+struct DATASLListParams* InitList(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
\ No newline at end of file