diff --git a/common/test/unittest/resource/cfi_blocklist.txt b/common/test/unittest/resource/cfi_blocklist.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3b6e425e7db15ba9a6c13a19bb88af111690d17
--- /dev/null
+++ b/common/test/unittest/resource/cfi_blocklist.txt
@@ -0,0 +1,16 @@
+# 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.
+
+[cfi]
+type:*testing::UnitTest*
+src:*third_party/googletest/*
diff --git a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyregresult_fuzzer/callbackonnotifyregresult_fuzzer.cpp b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyregresult_fuzzer/callbackonnotifyregresult_fuzzer.cpp
index e311bb5c6991d868cfbb2db48eb21ad7e2c3a64a..42c64c9df2b156a4680b720536dd9f7ce858da76 100644
--- a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyregresult_fuzzer/callbackonnotifyregresult_fuzzer.cpp
+++ b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyregresult_fuzzer/callbackonnotifyregresult_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -41,6 +41,9 @@ void OnNotifyRegResultFuzzTest(const uint8_t *data, size_t size)
     std::shared_ptr<RegisterCallback> callback = std::make_shared<MockComponentEnable>();
 
     sptr<DScreenSourceCallback> dScreenSourceCallback(new (std::nothrow) DScreenSourceCallback());
+    if (dScreenSourceCallback == nullptr) {
+        return;
+    }
     dScreenSourceCallback->PushRegRegisterCallback(reqId, callback);
     dScreenSourceCallback->OnNotifyRegResult(devId, dhId, reqId, status, dataStr);
 }
diff --git a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyunregresult_fuzzer/callbackonnotifyunregresult_fuzzer.cpp b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyunregresult_fuzzer/callbackonnotifyunregresult_fuzzer.cpp
index 64a317bddc5186b932a72145a158121f69fa3e7b..a4fee149b91bc9b2943e0637a15c3bd327ff1760 100644
--- a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyunregresult_fuzzer/callbackonnotifyunregresult_fuzzer.cpp
+++ b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonnotifyunregresult_fuzzer/callbackonnotifyunregresult_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -41,7 +41,9 @@ void OnNotifyUnregResultFuzzTest(const uint8_t *data, size_t size)
     std::shared_ptr<UnregisterCallback> uncallback = std::make_shared<MockComponentDisable>();
 
     sptr<DScreenSourceCallback> dScreenSourceCallback(new (std::nothrow) DScreenSourceCallback());
-
+    if (dScreenSourceCallback == nullptr) {
+        return;
+    }
     dScreenSourceCallback->PushUnregisterCallback(reqId, uncallback);
     dScreenSourceCallback->OnNotifyUnregResult(devId, dhId, reqId, status, dataStr);
 }
diff --git a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonremoterequest_fuzzer/callbackonremoterequest_fuzzer.cpp b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonremoterequest_fuzzer/callbackonremoterequest_fuzzer.cpp
index b9f0c37c2f7ecb3c550fc03191b6c3361662c834..4ec2ef6614d15853ec9c6170bd4314274f6ba063 100644
--- a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonremoterequest_fuzzer/callbackonremoterequest_fuzzer.cpp
+++ b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_callback/callbackonremoterequest_fuzzer/callbackonremoterequest_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -53,6 +53,9 @@ void CallbackOnRemoteRequestFuzzTest(const uint8_t *data, size_t size)
     pdata.WriteString(dataStr);
 
     sptr<DScreenSourceCallback> dScreenSourceCallback(new (std::nothrow) DScreenSourceCallback());
+    if (dScreenSourceCallback == nullptr) {
+        return;
+    }
     dScreenSourceCallback->OnRemoteRequest(code, pdata, reply, option);
 }
 } // namespace DistributedHardware
diff --git a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyinitsource_fuzzer/initsource_fuzzer.cpp b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyinitsource_fuzzer/initsource_fuzzer.cpp
index 2030a24f8286d2bac3fc07e86fc5f1043adae1b5..da9cdb74eb9413059e85034a48160adafd71390c 100644
--- a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyinitsource_fuzzer/initsource_fuzzer.cpp
+++ b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyinitsource_fuzzer/initsource_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -35,7 +35,7 @@ void InitSourceFuzzTest(const uint8_t *data, size_t size)
     FuzzedDataProvider dataProvider(data, size);
     std::string params(dataProvider.ConsumeRandomLengthString());
 
-    sptr<IDScreenSourceCallback> callback(new DScreenSourceCallback());
+    sptr<IDScreenSourceCallback> callback(new (std::nothrow) DScreenSourceCallback());
     if (callback == nullptr) {
         return;
     }
diff --git a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyregisterdistributedhardware_fuzzer/registerdistributedhardware_fuzzer.cpp b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyregisterdistributedhardware_fuzzer/registerdistributedhardware_fuzzer.cpp
index e8d986f62ad3d456a2e1dc25f38fc187322d5771..a2beb09745e7df97e19eb36073030c5f39962450 100644
--- a/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyregisterdistributedhardware_fuzzer/registerdistributedhardware_fuzzer.cpp
+++ b/interfaces/innerkits/native_cpp/test/fuzztest/dscreen_source_proxy/proxyregisterdistributedhardware_fuzzer/registerdistributedhardware_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -73,7 +73,10 @@ void RegisterDistributedHardwareFuzzTest(const uint8_t *data, size_t size)
     param.sinkVersion = version;
     param.sinkAttrs = attrs;
 
-    sptr<IRemoteObject> remoteObject(new DScreenSourceStubFuzzTest());
+    sptr<IRemoteObject> remoteObject(new (std::nothrow) DScreenSourceStubFuzzTest());
+    if (remoteObject == nullptr) {
+        return;
+    }
     std::shared_ptr<IDScreenSource> dscreenSourceProxy = std::make_shared<DScreenSourceProxy>(remoteObject);
     dscreenSourceProxy->RegisterDistributedHardware(devId, dhId, param, reqId);
 }
diff --git a/interfaces/innerkits/native_cpp/test/unittest/screensinktest/src/dscreen_sink_handler_test.cpp b/interfaces/innerkits/native_cpp/test/unittest/screensinktest/src/dscreen_sink_handler_test.cpp
index d2bc2f2a8de0646bd762301057498fbb014899f6..42f8476f704c4cabdab419b4797e80bb87c32f6a 100644
--- a/interfaces/innerkits/native_cpp/test/unittest/screensinktest/src/dscreen_sink_handler_test.cpp
+++ b/interfaces/innerkits/native_cpp/test/unittest/screensinktest/src/dscreen_sink_handler_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -122,6 +122,25 @@ HWTEST_F(DScreenSinkHandlerTest, SubscribeLocalHardware_001, TestSize.Level1)
     EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
 }
 
+/**
+ * @tc.name: SubscribeLocalHardware_002
+ * @tc.desc: Verify the SubscribeLocalHardware function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSinkHandlerTest, SubscribeLocalHardware_002, TestSize.Level1)
+{
+    const std::string dhId = "";
+    const std::string param = "DScreenSinkHandlerTest";
+    DScreenSinkHandler::GetInstance().dScreenSinkProxy_ = nullptr;
+    sptr<IRemoteObject> remoteObject = nullptr;
+    DScreenSinkHandler::GetInstance().OnRemoteSinkSvrDied(remoteObject);
+    ASSERT_NE(nullptr, DScreenSinkHandler::GetInstance().sinkSvrRecipient_);
+    DScreenSinkHandler::GetInstance().sinkSvrRecipient_->OnRemoteDied(remoteObject);
+    int32_t ret = DScreenSinkHandler::GetInstance().SubscribeLocalHardware(dhId, param);
+    EXPECT_EQ(ERR_DH_SCREEN_SA_SINKPROXY_NOT_INIT, ret);
+}
+
 /**
  * @tc.name: OnRemoteSinkSvrDied_001
  * @tc.desc: Verify the OnRemoteSinkSvrDied function.
@@ -138,6 +157,7 @@ HWTEST_F(DScreenSinkHandlerTest, OnRemoteSinkSvrDied_001, TestSize.Level1)
 
     wptr<IRemoteObject> remote(remoteObject);
 
+    ASSERT_NE(DScreenSinkHandler::GetInstance().sinkSvrRecipient_, nullptr);
     DScreenSinkHandler::GetInstance().sinkSvrRecipient_->OnRemoteDied(remote);
     EXPECT_EQ(nullptr, DScreenSinkHandler::GetInstance().dScreenSinkProxy_);
 }
diff --git a/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp b/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp
index 468eb24bc419d43454e03ecefd65fb7e9b5554bc..ec669ff67bd8d2d0f8dafa16d9bbbfca95d8a4b4 100644
--- a/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp
+++ b/interfaces/innerkits/native_cpp/test/unittest/screensourcetest/src/dscreen_source_handler_test.cpp
@@ -30,6 +30,9 @@ void DScreenSourceHandlerTest::TearDownTestCase(void) {}
 
 void DScreenSourceHandlerTest::SetUp(void)
 {
+    if (DScreenSourceHandler::GetInstance().sourceSvrRecipient_ == nullptr) {
+        DScreenSourceHandler::GetInstance().sourceSvrRecipient_ = new DScreenSourceHandler::DScreenSourceSvrRecipient();
+    }
     DScreenSourceHandler::GetInstance().InitSource("2.0");
 }
 
@@ -67,7 +70,6 @@ HWTEST_F(DScreenSourceHandlerTest, InitSource_002, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, ret);
 }
 
-
 /**
  * @tc.name: FinishStartSA_001
  * @tc.desc: Verify the FinishStartSA function.
@@ -83,6 +85,23 @@ HWTEST_F(DScreenSourceHandlerTest, FinishStartSA_001, TestSize.Level1)
     EXPECT_EQ(DScreenSourceHandler::GetInstance().dScreenSourceProxy_, nullptr);
 }
 
+/**
+ * @tc.name: FinishStartSA_002
+ * @tc.desc: Verify the FinishStartSA function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSourceHandlerTest, FinishStartSA_002, TestSize.Level1)
+{
+    const std::string param = "";
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
+    DScreenSourceHandler::GetInstance().sourceSvrRecipient_ = nullptr;
+    DScreenSourceHandler::GetInstance().FinishStartSA(param, remoteObject);
+    EXPECT_EQ(DScreenSourceHandler::GetInstance().dScreenSourceProxy_, nullptr);
+}
+
 /**
  * @tc.name: RegisterDistributedHardware_001
  * @tc.desc: Verify the RegisterDistributedHardware function.
@@ -99,8 +118,15 @@ HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_001, TestSize.Lev
     std::string callbackParam = "callbackParam";
     sptr<DScreenSourceLoadCallback> loadCallback(new DScreenSourceLoadCallback(callbackParam));
     loadCallback->OnLoadSystemAbilitySuccess(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, nullptr);
-    std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
-    int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
+    std::shared_ptr<RegisterCallback> registerCallback = std::make_shared<RegisterCallbackTest>();
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
+    int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, registerCallback);
+    EXPECT_EQ(DH_SUCCESS, ret);
+
+    std::shared_ptr<UnregisterCallbackTest> unregisterCallback = std::make_shared<UnregisterCallbackTest>();
+    ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, unregisterCallback);
     EXPECT_EQ(DH_SUCCESS, ret);
 }
 
@@ -141,6 +167,9 @@ HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_003, TestSize.Lev
     param.sinkAttrs = "attrs";
     std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
     DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = nullptr;
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
     int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
     EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPCALLBACK_NOT_INIT, ret);
 }
@@ -205,6 +234,10 @@ HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_006, TestSize.Lev
     if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
         DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
     }
+    ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
     int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
     EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
 }
@@ -223,6 +256,10 @@ HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_001, TestSize.L
     if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
         DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
     }
+    ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
     int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
     EXPECT_EQ(DH_SUCCESS, ret);
 }
@@ -274,6 +311,9 @@ HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_004, TestSize.L
     DScreenSourceHandler::GetInstance().InitSource("DScreenSourceHandlerTest");
     std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
     DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = nullptr;
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
 
     int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
     EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPCALLBACK_NOT_INIT, ret);
@@ -313,6 +353,11 @@ HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_006, TestSize.L
     if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
         DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
     }
+    ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
+
     int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
     EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
 }
@@ -355,14 +400,14 @@ HWTEST_F(DScreenSourceHandlerTest, ReleaseSource_001, TestSize.Level1)
  */
 HWTEST_F(DScreenSourceHandlerTest, OnRemoteDied_001, TestSize.Level1)
 {
-    sptr<ISystemAbilityManager> samgr =
-            SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     sptr<IRemoteObject> remoteObject1 = nullptr;
     wptr<IRemoteObject> remote1(remoteObject1);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
     DScreenSourceHandler::GetInstance().sourceSvrRecipient_->OnRemoteDied(remote1);
-
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     sptr<IRemoteObject> remoteObject2 = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
     wptr<IRemoteObject> remote2(remoteObject2);
+    DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject2);
     DScreenSourceHandler::GetInstance().sourceSvrRecipient_->OnRemoteDied(remote2);
     EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_);
 }
@@ -375,8 +420,7 @@ HWTEST_F(DScreenSourceHandlerTest, OnRemoteDied_001, TestSize.Level1)
  */
 HWTEST_F(DScreenSourceHandlerTest, OnRemoteSourceSvrDied_001, TestSize.Level1)
 {
-    sptr<ISystemAbilityManager> samgr =
-            SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
     wptr<IRemoteObject> remote(remoteObject);
     DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote);
diff --git a/services/common/test/unittest/utils/video_param_test.cpp b/services/common/test/unittest/utils/video_param_test.cpp
index 746259541ea5daadc885aee8166cba894f49ef32..64fc1207474ca6acd0bd7f4812d4fb9395670e14 100644
--- a/services/common/test/unittest/utils/video_param_test.cpp
+++ b/services/common/test/unittest/utils/video_param_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -239,5 +239,46 @@ HWTEST_F(VideoParamTest, from_json_002, TestSize.Level1)
     from_json(j, jsonVideoParam);
     EXPECT_EQ(false, jsonVideoParam.isPartialRefresh_);
 }
+
+/**
+ * @tc.name: from_json_003
+ * @tc.desc: Verify the from_json function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(VideoParamTest, from_json_003, TestSize.Level1)
+{
+    json j;
+    uint32_t screenWidth = DSCREEN_MAX_SCREEN_DATA_WIDTH;
+    uint32_t screenHeight = DSCREEN_MAX_SCREEN_DATA_HEIGHT;
+    uint32_t videoWidth = DSCREEN_MAX_VIDEO_DATA_WIDTH;
+    uint32_t videoHeight = DSCREEN_MAX_VIDEO_DATA_HEIGHT + 1;
+    double fps = 30.0;
+    uint8_t codecType = DEFAULT_CODECTYPE;
+    uint8_t videoFormat = DEFAULT_VIDEO_FORMAT;
+    VideoParam jsonVideoParam;
+    jsonVideoParam.isPartialRefresh_ = true;
+    j[KEY_SCREEN_WIDTH] = screenWidth;
+    j[KEY_SCREEN_HEIGHT] = screenHeight;
+    j[KEY_VIDEO_WIDTH] = videoWidth;
+    j[KEY_VIDEO_HEIGHT] = videoHeight;
+    j[KEY_FPS] = fps;
+    j[KEY_CODECTYPE] = codecType;
+    j[KEY_COLOR_FORMAT] = videoFormat;
+    from_json(j, jsonVideoParam);
+    EXPECT_TRUE(jsonVideoParam.isPartialRefresh_);
+
+    j[KEY_VIDEO_WIDTH] = DSCREEN_MAX_VIDEO_DATA_WIDTH + 1;
+    from_json(j, jsonVideoParam);
+    EXPECT_TRUE(jsonVideoParam.isPartialRefresh_);
+
+    j[KEY_SCREEN_HEIGHT] = DSCREEN_MAX_SCREEN_DATA_HEIGHT + 1;
+    from_json(j, jsonVideoParam);
+    EXPECT_TRUE(jsonVideoParam.isPartialRefresh_);
+
+    j[KEY_SCREEN_WIDTH] = DSCREEN_MAX_SCREEN_DATA_WIDTH + 1;
+    from_json(j, jsonVideoParam);
+    EXPECT_TRUE(jsonVideoParam.isPartialRefresh_);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/screenservice/test/fuzztest/sinkservice/dscreenservice/dscreensinkstub_fuzzer/dscreensinkstub_fuzzer.cpp b/services/screenservice/test/fuzztest/sinkservice/dscreenservice/dscreensinkstub_fuzzer/dscreensinkstub_fuzzer.cpp
index dc22a92d392272b25c9eb035990796a869484e4f..1cbbd6ab14f8afecdf60a593e3c7bb66f8ede93b 100644
--- a/services/screenservice/test/fuzztest/sinkservice/dscreenservice/dscreensinkstub_fuzzer/dscreensinkstub_fuzzer.cpp
+++ b/services/screenservice/test/fuzztest/sinkservice/dscreenservice/dscreensinkstub_fuzzer/dscreensinkstub_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -65,7 +65,10 @@ void DscreenSinkStubFuzzTest(const uint8_t *data, size_t size)
     pdata.WriteString(reqId);
     pdata.WriteString(dataStr);
 
-    sptr<DScreenSinkStubFuzzTest> sourceStubPtr(new DScreenSinkStubFuzzTest());
+    sptr<DScreenSinkStubFuzzTest> sourceStubPtr(new (std::nothrow) DScreenSinkStubFuzzTest());
+    if (sourceStubPtr == nullptr) {
+        return;
+    }
     sourceStubPtr->OnRemoteRequest(code, pdata, reply, option);
     sourceStubPtr->InitSinkInner(pdata, reply, option);
     sourceStubPtr->ReleaseSinkInner(pdata, reply, option);
diff --git a/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourcecallbackproxy_fuzzer/dscreensourcecallbackproxy_fuzzer.cpp b/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourcecallbackproxy_fuzzer/dscreensourcecallbackproxy_fuzzer.cpp
index d022fcd74fa8a2454149c6a30a84353f1f84cf7c..c98f0bc559bb1613ec0f4dbe6dc38bcda71bdd77 100644
--- a/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourcecallbackproxy_fuzzer/dscreensourcecallbackproxy_fuzzer.cpp
+++ b/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourcecallbackproxy_fuzzer/dscreensourcecallbackproxy_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -53,7 +53,6 @@ public:
     };
 };
 
-
 void DscreenSourceCallbackProxyFuzzTest(const uint8_t* data, size_t size)
 {
     if ((data == nullptr) || (size == 0)) {
@@ -67,8 +66,15 @@ void DscreenSourceCallbackProxyFuzzTest(const uint8_t* data, size_t size)
     std::string reqId(dataProvider.ConsumeRandomLengthString());
     std::string resultData(dataProvider.ConsumeRandomLengthString());
 
-    sptr<IRemoteObject> dscreenSourceStubPtr(new DScreenSourceStubFuzzTest());
-    sptr<DScreenSourceCallbackProxy> sourceCbkProxy(new DScreenSourceCallbackProxy(dscreenSourceStubPtr));
+    sptr<IRemoteObject> dscreenSourceStubPtr(new (std::nothrow) DScreenSourceStubFuzzTest());
+    if (dscreenSourceStubPtr == nullptr) {
+        return;
+    }
+    sptr<DScreenSourceCallbackProxy> sourceCbkProxy(
+        new (std::nothrow) DScreenSourceCallbackProxy(dscreenSourceStubPtr));
+    if (sourceCbkProxy == nullptr) {
+        return;
+    }
     sourceCbkProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData);
     sourceCbkProxy->OnNotifyUnregResult(devId, dhId, reqId, status, resultData);
     sourceCbkProxy->CheckParams(devId, dhId, reqId, resultData);
diff --git a/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourceservice_fuzzer/dscreensourceservice_fuzzer.cpp b/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourceservice_fuzzer/dscreensourceservice_fuzzer.cpp
index 36873648941f285b680be841a771cae350cd6943..2b7ae7af0917027b523c61bfeb16fd13f4d6e6c4 100644
--- a/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourceservice_fuzzer/dscreensourceservice_fuzzer.cpp
+++ b/services/screenservice/test/fuzztest/sourceservice/dscreenservice/dscreensourceservice_fuzzer/dscreensourceservice_fuzzer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -41,7 +41,10 @@ void DscreenSourceServiceFuzzTest(const uint8_t *data, size_t size)
     param.sinkAttrs = "";
     uint32_t eventCode = 1;
     std::shared_ptr<DScreenSourceService> sourceServicePtr = std::make_shared<DScreenSourceService>(0, false);
-    sptr<IDScreenSourceCallback> callback(new DScreenSourceCallback());
+    sptr<IDScreenSourceCallback> callback(new (std::nothrow) DScreenSourceCallback());
+    if (callback == nullptr) {
+        return;
+    }
     sourceServicePtr->registerToService_ = true;
     sourceServicePtr->Init();
     sourceServicePtr->InitSource(params, callback);
diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn b/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn
index 4085f75dabbb5b76d7a32067eb3e2ac3f0ca4f99..1fa55267c226bfe337e362a1fa9554ed7d51dc03 100644
--- a/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn
+++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+# Copyright (c) 2022-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
@@ -21,10 +21,16 @@ config("module_private_config") {
   visibility = [ ":*" ]
   include_dirs = [
     "./include",
+    "${common_path}/include",
     "${interfaces_path}/innerkits/native_cpp/screen_sink/include",
     "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback",
-    "${common_path}/include",
+    "${interfaces_path}/innerkits/native_cpp/screen_source/include",
+    "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback",
+    "${services_path}/common/utils/include",
+    "${services_path}/screenclient/include",
     "${services_path}/screenservice/sinkservice/dscreenservice/include",
+    "${services_path}/screenservice/sinkservice/screenregionmgr",
+    "${services_path}/screentransport/screensinktrans/include",
   ]
 }
 
@@ -37,7 +43,10 @@ ohos_unittest("DScreenSinkStubTest") {
   }
   module_out_path = module_out_path
 
-  sources = [ "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp" ]
+  sources = [
+    "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp",
+    "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp",
+  ]
 
   configs = [
     ":module_private_config",
@@ -51,10 +60,19 @@ ohos_unittest("DScreenSinkStubTest") {
 
   external_deps = [
     "access_token:libaccesstoken_sdk",
+    "cJSON:cjson",
     "c_utils:utils",
+    "distributed_hardware_fwk:distributed_av_receiver",
+    "distributed_hardware_fwk:distributedhardwareutils",
+    "distributed_hardware_fwk:libdhfwk_sdk",
     "googletest:gmock",
     "googletest:gtest_main",
+    "graphic_2d:librender_service_client",
+    "graphic_surface:surface",
     "ipc:ipc_core",
+    "json:nlohmann_json_static",
+    "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
+    "window_manager:libdm",
   ]
 }
diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..c63d715ba70b9fbe58e8891cf2bf486f739ef35b
--- /dev/null
+++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h
@@ -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.
+ */
+
+#ifndef OHOS_DSCREEN_SINK_SERVICE_TEST_H
+#define OHOS_DSCREEN_SINK_SERVICE_TEST_H
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace OHOS {
+namespace DistributedHardware {
+class DScreenSinkServiceTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+} // namespace DistributedHardware
+} // namespace OHOS
+#endif
diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..97ffa6d66b2776f3c7337ad17c3f45a521d3e325
--- /dev/null
+++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp
@@ -0,0 +1,104 @@
+/*
+ * 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 "dscreen_sink_service_test.h"
+#include "1.0/include/screenregionmgr.h"
+#include "2.0/include/screenregionmgr.h"
+#include "dscreen_constants.h"
+#include "dscreen_errcode.h"
+#include "dscreen_sink_service.h"
+#include "idscreen_sink.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+static int32_t g_mockInitializeV2ReturnInt32Value = -1;
+static int32_t g_mockReleaseV2ReturnInt32Value = -1;
+
+namespace OHOS {
+namespace DistributedHardware {
+int32_t V2_0::ScreenRegionManager::Initialize()
+{
+    return g_mockInitializeV2ReturnInt32Value;
+}
+
+int32_t V2_0::ScreenRegionManager::Release()
+{
+    return g_mockReleaseV2ReturnInt32Value;
+}
+
+void DScreenSinkServiceTest::SetUpTestCase(void) {}
+
+void DScreenSinkServiceTest::TearDownTestCase(void) {}
+
+void DScreenSinkServiceTest::SetUp(void)
+{
+    g_mockInitializeV2ReturnInt32Value = -1;
+    g_mockReleaseV2ReturnInt32Value = -1;
+}
+
+void DScreenSinkServiceTest::TearDown(void) {}
+
+/* *
+ * @tc.name: OnStart_001
+ * @tc.desc: Verify the OnStart function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSinkServiceTest, OnStart_001, TestSize.Level1)
+{
+    std::shared_ptr<DScreenSinkService> sinkService =
+        std::make_shared<DScreenSinkService>(DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID, false);
+    sinkService->registerToService_ = true;
+    sinkService->OnStart();
+    sinkService->OnStop();
+    EXPECT_FALSE(sinkService->registerToService_);
+}
+
+/* *
+ * @tc.name: InitSink_001
+ * @tc.desc: Verify the InitSink function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSinkServiceTest, InitSink_001, TestSize.Level1)
+{
+    std::shared_ptr<DScreenSinkService> sinkService =
+        std::make_shared<DScreenSinkService>(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false);
+    std::string params;
+    int32_t ret = sinkService->InitSink(params);
+    EXPECT_EQ(ret, DH_SUCCESS);
+    sinkService->ReleaseSink();
+}
+
+/* *
+ * @tc.name: InitSink_002
+ * @tc.desc: Verify the InitSink function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSinkServiceTest, InitSink_002, TestSize.Level1)
+{
+    std::shared_ptr<DScreenSinkService> sinkService =
+        std::make_shared<DScreenSinkService>(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, false);
+    std::string params;
+    g_mockInitializeV2ReturnInt32Value = 0;
+    g_mockReleaseV2ReturnInt32Value = 0;
+    int32_t ret = sinkService->InitSink(params);
+    EXPECT_EQ(ret, DH_SUCCESS);
+    sinkService->ReleaseSink();
+}
+} // namespace DistributedHardware
+} // namespace OHOS
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/include/screenregion_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/include/screenregion_test.h
index 36998dd20c890539973aad28627b8c74a8c33ded..70e7f48da5a941846fbe7e157f4b35a76530ec1e 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/include/screenregion_test.h
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/include/screenregion_test.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -34,6 +34,15 @@ public:
     void TearDown();
     std::shared_ptr<ScreenRegion> screenRegion_ = nullptr;
 };
+
+class MockAVReceiverAdapterCallback : public AVReceiverAdapterCallback {
+public:
+    explicit MockAVReceiverAdapterCallback() {}
+    ~MockAVReceiverAdapterCallback() {}
+    void OnEngineEvent(DScreenEventType event, const std::string &content) override {}
+    void OnEngineMessage(const std::shared_ptr<AVTransMessage> &message) override {}
+    void OnEngineDataDone(const std::shared_ptr<AVTransBuffer> &buffer) override {}
+};
 } // namespace V2_0
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adapter_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adapter_test.cpp
index cd82bd6db2d1a73e1ee1ccfe62bd86424041dff8..0d1b11a566a4c02e14e36a609014a2da9a34f6f5 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adapter_test.cpp
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adapter_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-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
@@ -21,6 +21,7 @@
 #include "engine_test_utils.h"
 #include "2.0/include/dscreen.h"
 
+using namespace testing;
 using namespace testing::ext;
 
 namespace OHOS {
@@ -63,12 +64,33 @@ HWTEST_F(AVReceiverEngineAdapterTest, Initialize_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, Initialize_002, TestSize.Level1)
 {
     std::string peerDevId = "peerDevId";
-    receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Start()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Start());
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Stop());
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Release());
 }
 
+/**
+ * @tc.name: Release_001
+ * @tc.desc: Verify the Release function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(AVReceiverEngineAdapterTest, Release_001, TestSize.Level1)
+{
+    std::string peerDevId = "peerDevId";
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(0));
+    int32_t ret = receiverAdapter_->Release();
+    EXPECT_EQ(receiverAdapter_->receiverEngine_, nullptr);
+    EXPECT_EQ(ret, DH_SUCCESS);
+}
+
 /**
  * @tc.name: Start_001
  * @tc.desc: Verify the Start and Stop function.
@@ -81,6 +103,38 @@ HWTEST_F(AVReceiverEngineAdapterTest, Start_001, TestSize.Level1)
     EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->Stop());
 }
 
+/**
+ * @tc.name: Start_002
+ * @tc.desc: Verify the Start and Stop function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(AVReceiverEngineAdapterTest, Start_002, TestSize.Level1)
+{
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Start()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Start());
+    EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Stop());
+}
+
+/**
+ * @tc.name: Start_003
+ * @tc.desc: Verify the Start and Stop function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(AVReceiverEngineAdapterTest, Start_003, TestSize.Level1)
+{
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Start()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(-1));
+    EXPECT_EQ(DH_SUCCESS, receiverAdapter_->Start());
+    EXPECT_EQ(ERR_DH_AV_TRANS_STOP_FAILED, receiverAdapter_->Stop());
+}
+
 /**
  * @tc.name: SetParameter_001
  * @tc.desc: Verify the Start and SetParameter function.
@@ -90,6 +144,7 @@ HWTEST_F(AVReceiverEngineAdapterTest, Start_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_001, TestSize.Level1)
 {
     std::string param = "param";
+    receiverAdapter_->receiverEngine_ = nullptr;
     EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, param));
 }
 
@@ -102,7 +157,9 @@ HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_001, TestSize.Level1)
 HWTEST_F(AVReceiverEngineAdapterTest, SetParameter_002, TestSize.Level1)
 {
     std::string param = "param";
-    receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, SetParameter(_, _)).Times(1).WillOnce(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, param));
 }
 
@@ -119,7 +176,9 @@ HWTEST_F(AVReceiverEngineAdapterTest, SendMessageToRemote_001, TestSize.Level1)
     std::string dstDevId = "dstDevId";
     auto message = std::make_shared<AVTransMessage>(type, content, dstDevId);
     EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->SendMessageToRemote(message));
-    receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, SendMessage(_)).Times(1).WillOnce(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->SendMessageToRemote(message));
 }
 
@@ -152,7 +211,9 @@ HWTEST_F(AVReceiverEngineAdapterTest, OnReceiverEvent_001, TestSize.Level1)
     std::shared_ptr<AVTransBuffer> buffer = nullptr;
     EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, receiverAdapter_->OnDataAvailable(buffer));
     receiverAdapter_->adapterCallback_ = std::make_shared<MockAVReceiverAdapterCallback>();
-    receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnReceiverEvent(event));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnMessageReceived(message));
     EXPECT_EQ(DH_SUCCESS, receiverAdapter_->OnDataAvailable(buffer));
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregion_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregion_test.cpp
index 97701531255491121a7bb0b2599dfa9e63a37da9..2885f100e2a66bb1ec73a463105147866f34a336 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregion_test.cpp
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregion_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -110,7 +110,7 @@ HWTEST_F(ScreenRegionTestV2, Release_001, TestSize.Level1)
 
 /**
  * @tc.name: Release_002
- * @tc.desc: Verify the Release function failed.
+ * @tc.desc: Verify the Release function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
@@ -118,7 +118,28 @@ HWTEST_F(ScreenRegionTestV2, Release_002, TestSize.Level1)
 {
     screenRegion_->isRunning = true;
     screenRegion_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
-    screenRegion_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    screenRegion_->receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_EQ(DH_SUCCESS, screenRegion_->Release());
+    EXPECT_EQ(false, screenRegion_->isRunning);
+}
+
+/**
+ * @tc.name: Release_003
+ * @tc.desc: Verify the Release function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(ScreenRegionTestV2, Release_003, TestSize.Level1)
+{
+    screenRegion_->isRunning = true;
+    screenRegion_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    screenRegion_->receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(-1));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(-1));
     EXPECT_EQ(DH_SUCCESS, screenRegion_->Release());
     EXPECT_EQ(false, screenRegion_->isRunning);
 }
@@ -275,7 +296,11 @@ HWTEST_F(ScreenRegionTestV2, StartReceiverEngine_004, TestSize.Level1)
         \"screenRect\":{\"height\":1280, \"startX\":0, \"startY\":0, \"width\":720}}, \"screenId\":2, \
         \"videoParam\":{\"codecType\":2, \"colorFormat\":3, \"fps\":30, \"screenHeight\":1280, \
         \"screenWidth\":720, \"videoHeight\":1280, \"videoWidth\":720}}";
-    screenRegion_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    screenRegion_->receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, SetParameter(_, _)).WillRepeatedly(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Start()).WillRepeatedly(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Release()).WillRepeatedly(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, screenRegion_->StartReceiverEngine(content));
     EXPECT_EQ(true, screenRegion_->isRunning);
 }
@@ -303,7 +328,11 @@ HWTEST_F(ScreenRegionTestV2, StopReceiverEngine_002, TestSize.Level1)
     screenRegion_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
     screenRegion_->receiverAdapter_->receiverEngine_ = nullptr;
     EXPECT_EQ(ERR_DH_AV_TRANS_NULL_VALUE, screenRegion_->StopReceiverEngine());
-    screenRegion_->receiverAdapter_->receiverEngine_ = std::make_shared<MockIAVReceiverEngine>();
+
+    std::shared_ptr<MockAVReceiverEngine> mockInstance = std::make_shared<MockAVReceiverEngine>();
+    screenRegion_->receiverAdapter_->receiverEngine_ = mockInstance;
+    EXPECT_CALL(*mockInstance, Release()).Times(1).WillOnce(testing::Return(0));
+    EXPECT_CALL(*mockInstance, Stop()).Times(1).WillOnce(testing::Return(0));
     EXPECT_EQ(DH_SUCCESS, screenRegion_->StopReceiverEngine());
 }
 
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregionmgr_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregionmgr_test.cpp
index 3194376494853e88b4aff382b076982e227227fd..86cafe148b8c1c4d6904cd8abda50aae1ef48045 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregionmgr_test.cpp
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/2.0/src/screenregionmgr_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -34,8 +34,7 @@ void ScreenRegionManagerTestV2::TearDown(void)
 
 /**
  * @tc.name: Initialize_001
- * @tc.desc: Verify the Initialize function failed.
- * @tc.type: FUNC
+ * @tc.desc: Verify the Initialize function
  * @tc.require: Issue Number
  */
 HWTEST_F(ScreenRegionManagerTestV2, Initialize_001, TestSize.Level1)
@@ -44,6 +43,23 @@ HWTEST_F(ScreenRegionManagerTestV2, Initialize_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, ScreenRegionManager::GetInstance().Release());
 }
 
+/**
+ * @tc.name: Release_001
+ * @tc.desc: Verify the Release function
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(ScreenRegionManagerTestV2, Release_001, TestSize.Level1)
+{
+    ScreenRegionManager::GetInstance().screenRegions_.clear();
+    std::shared_ptr<ScreenRegion> screenRegionOne = nullptr;
+    ScreenRegionManager::GetInstance().screenRegions_.push_back(screenRegionOne);
+    std::string peerDevId = "test";
+    std::shared_ptr<ScreenRegion> screenRegionTwo = std::make_shared<ScreenRegion>(peerDevId);
+    ScreenRegionManager::GetInstance().screenRegions_.push_back(screenRegionTwo);
+    EXPECT_EQ(DH_SUCCESS, ScreenRegionManager::GetInstance().Release());
+}
+
 /**
  * @tc.name: CreateDScreenRegion_001
  * @tc.desc: Verify the CreateDScreenRegion function failed.
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn
index 4c6e80946cc7c6d50f42b9f298953af73857af84..b0713c678190c61e6cdfbf4e7a73f5fc6dcba54a 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+# Copyright (c) 2022-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
@@ -43,6 +43,7 @@ config("module_private_config") {
 ## UnitTest DscreenRegionMgrTest
 ohos_unittest("DscreenRegionMgrTest") {
   sanitize = {
+    blocklist = "${common_path}/test/unittest/resource/cfi_blocklist.txt"
     cfi = true
     cfi_cross_dso = true
     debug = false
diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/engineutils/include/engine_test_utils.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/engineutils/include/engine_test_utils.h
index 798d6637c395fbccd934dc02a971250eb977848b..4ddb06c64a9e65c4a471adc09300231465bfcf36 100644
--- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/engineutils/include/engine_test_utils.h
+++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/engineutils/include/engine_test_utils.h
@@ -17,9 +17,7 @@
 #define OHOS_ENGINE_TEST_UTILS_H
 
 #include "i_av_receiver_engine.h"
-#include "i_av_sender_engine.h"
 #include "2.0/include/av_receiver_engine_adapter.h"
-#include "2.0/include/av_sender_engine_adapter.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -32,56 +30,18 @@ public:
     void OnEngineDataDone(const std::shared_ptr<AVTransBuffer> &buffer) override {}
 };
 
-class MockIAVReceiverEngine : public IAVReceiverEngine {
+class MockAVReceiverEngine : public IAVReceiverEngine {
 public:
-    explicit MockIAVReceiverEngine() {}
-    ~MockIAVReceiverEngine() {}
-
-    int32_t Initialize() override
-    {
-        return 0;
-    }
-
-    int32_t Start() override
-    {
-        return 0;
-    }
-
-    int32_t Stop() override
-    {
-        return 0;
-    }
-
-    int32_t Release() override
-    {
-        return 0;
-    }
-
-    int32_t SetParameter(AVTransTag tag, const std::string &value) override
-    {
-        (void) tag;
-        (void) value;
-        return 0;
-    }
-
-    int32_t SendMessage(const std::shared_ptr<AVTransMessage> &message) override
-    {
-        return 0;
-    }
-
-    int32_t CreateControlChannel(const std::vector<std::string> &dstDevIds,
-        const ChannelAttribute &attribution) override
-    {
-        (void) dstDevIds;
-        (void) attribution;
-        return 0;
-    }
-
-    int32_t RegisterReceiverCallback(const std::shared_ptr<IAVReceiverEngineCallback> &callback) override
-    {
-        (void) callback;
-        return 0;
-    }
+    MOCK_METHOD(int32_t, Initialize, (), (override));
+    MOCK_METHOD(int32_t, Release, (), (override));
+    MOCK_METHOD(int32_t, Start, (), (override));
+    MOCK_METHOD(int32_t, Stop, (), (override));
+    MOCK_METHOD(int32_t, SetParameter, (AVTransTag tag, const std::string &value), (override));
+    MOCK_METHOD(int32_t, SendMessage, (const std::shared_ptr<AVTransMessage> &message), (override));
+    MOCK_METHOD(int32_t, CreateControlChannel,
+        (const std::vector<std::string> &dstDevIds, const ChannelAttribute &attribution), (override));
+    MOCK_METHOD(int32_t, RegisterReceiverCallback, (const std::shared_ptr<IAVReceiverEngineCallback> &callback),
+        (override));
 
     bool StartDumpMediaData() override
     {
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/include/dscreen_manager_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/include/dscreen_manager_test.h
index 2b2f057ecdecf1fcfcf2fe72aeaeee4be2af78d2..4a12965c5052ecc750a5a656fda4fc8cdcc9c889 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/include/dscreen_manager_test.h
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/include/dscreen_manager_test.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -32,6 +32,22 @@ public:
     void SetUp();
     void TearDown();
 };
+
+class MockDScreenSourceCallback : public IDScreenSourceCallback {
+public:
+    ~MockDScreenSourceCallback() {}
+    MOCK_METHOD(int32_t, OnNotifyRegResult,
+        (const std::string &devId, const std::string &dhId, const std::string &reqId, int32_t status,
+        const std::string &data), (override));
+    MOCK_METHOD(int32_t, OnNotifyUnregResult,
+        (const std::string &devId, const std::string &dhId, const std::string &reqId, int32_t status,
+        const std::string &data), (override));
+
+    sptr<IRemoteObject> AsObject()
+    {
+        return nullptr;
+    }
+};
 } // namespace V1_0
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_manager_test.cpp
index b0d72b397cef559ef0497acaae33cade7a7a41cd..db422d59d327462689a7107225cef60829e6d3d1 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_manager_test.cpp
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_manager_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -122,18 +122,27 @@ HWTEST_F(DScreenManagerTestV1, RemoveFromGroup_001, TestSize.Level1)
 
 /**
  * @tc.name: OnRegResult_001
- * @tc.desc: Verify the OnRegResult function failed.
+ * @tc.desc: Verify the OnRegResult function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
 HWTEST_F(DScreenManagerTestV1, OnRegResult_001, TestSize.Level1)
 {
+    std::string devId = "devId";
+    std::string dhId = "dhId";
     std::shared_ptr<IDScreenCallback> dScreenCallback = std::make_shared<DScreenCallback>();
-    std::shared_ptr<DScreen> changedScreen = std::make_shared<DScreen>("devId000", "dhId000", dScreenCallback);
-    DScreenManager::GetInstance().OnRegResult(changedScreen, "taskId000", DH_SUCCESS, "dscreen enable success.");
-
-    int32_t ret = DScreenManager::GetInstance().Init();
-    EXPECT_EQ(DH_SUCCESS, ret);
+    std::shared_ptr<DScreen> dScreen = std::make_shared<DScreen>(devId, dhId, dScreenCallback);
+    std::string reqId;
+    int32_t status = 0;
+    std::string data;
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
+    DScreenManager::GetInstance().OnRegResult(dScreen, reqId, status, data);
+
+    sptr<MockDScreenSourceCallback> mockInstance(new MockDScreenSourceCallback());
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = mockInstance;
+    EXPECT_CALL(*mockInstance, OnNotifyRegResult(_, _, _, _, _)).Times(1);
+    DScreenManager::GetInstance().OnRegResult(dScreen, reqId, status, data);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
 }
 
 /**
@@ -144,12 +153,21 @@ HWTEST_F(DScreenManagerTestV1, OnRegResult_001, TestSize.Level1)
  */
 HWTEST_F(DScreenManagerTestV1, OnUnregResult_001, TestSize.Level1)
 {
+    std::string devId = "devId";
+    std::string dhId = "dhId";
     std::shared_ptr<IDScreenCallback> dScreenCallback = std::make_shared<DScreenCallback>();
-    std::shared_ptr<DScreen> changedScreen = std::make_shared<DScreen>("devId000", "dhId000", dScreenCallback);
-    DScreenManager::GetInstance().OnUnregResult(changedScreen, "taskId000", DH_SUCCESS, "dscreen disable success.");
-
-    int32_t ret = DScreenManager::GetInstance().Init();
-    EXPECT_EQ(DH_SUCCESS, ret);
+    std::shared_ptr<DScreen> dScreen = std::make_shared<DScreen>(devId, dhId, dScreenCallback);
+    std::string reqId;
+    int32_t status = 0;
+    std::string data;
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
+    DScreenManager::GetInstance().OnUnregResult(dScreen, reqId, status, data);
+
+    sptr<MockDScreenSourceCallback> mockInstance(new MockDScreenSourceCallback());
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = mockInstance;
+    EXPECT_CALL(*mockInstance, OnNotifyUnregResult(_, _, _, _, _)).Times(1);
+    DScreenManager::GetInstance().OnUnregResult(dScreen, reqId, status, data);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
 }
 
 /**
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp
index 8b8921faf06e9c9f6a6cd255c7fa85f1c9a3f694..8e8f630f5f05efe530220c9d16d600f263e241fc 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-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
@@ -302,9 +302,9 @@ HWTEST_F(DScreenTestV1, CheckJsonData_003, TestSize.Level1)
     json attrJson;
     uint32_t width = 100;
     uint32_t heigth = 100;
-    attrJson["screenWidth"] = width;
-    attrJson["screenHeight"] = heigth;
-    attrJson["codecType"] = 0;
+    attrJson[KEY_SCREEN_WIDTH] = width;
+    attrJson[KEY_SCREEN_HEIGHT] = heigth;
+    attrJson[KEY_CODECTYPE] = 0;
 
     std::string devId = "devId";
     std::string dhId = "dhId";
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_manager_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_manager_test.h
index 1683c190933acaa96e39c5458ce7b630c7db8a0f..445e4788411d4fd2ab6e0931574d7d7d0619b480 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_manager_test.h
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/include/dscreen_manager_test.h
@@ -1,10 +1,10 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
+ * 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,
@@ -33,6 +33,22 @@ public:
     void TearDown();
 };
 } // namespace V2_0
+
+class MockDScreenSourceCallback : public IDScreenSourceCallback {
+public:
+    ~MockDScreenSourceCallback() {}
+    MOCK_METHOD(int32_t, OnNotifyRegResult,
+        (const std::string &devId, const std::string &dhId, const std::string &reqId, int32_t status,
+        const std::string &data), (override));
+    MOCK_METHOD(int32_t, OnNotifyUnregResult,
+        (const std::string &devId, const std::string &dhId, const std::string &reqId, int32_t status,
+        const std::string &data), (override));
+
+    sptr<IRemoteObject> AsObject()
+    {
+        return nullptr;
+    }
+};
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif
\ No newline at end of file
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp
index 42d9fe386562886f1388db53aebb9bc6d404d531..6fd1aba708c2a237d2d5f6eeb1932a15cb68cc89 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_manager_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -42,7 +42,6 @@ void DScreenManagerTestV2::TearDown()
  */
 HWTEST_F(DScreenManagerTestV2, Initialize_001, TestSize.Level1)
 {
-    sptr<DScreenGroupListener> dScreenGroupListener_(new (std::nothrow) DScreenGroupListener());
     int32_t ret = DScreenManager::GetInstance().Initialize();
     EXPECT_EQ(DH_SUCCESS, ret);
 }
@@ -111,7 +110,7 @@ HWTEST_F(DScreenManagerTestV2, StartDScreenMirror_001, TestSize.Level1)
 
 /**
  * @tc.name: StopDScreenMirror_001
- * @tc.desc: Verify the StopDScreenMirror function failed.
+ * @tc.desc: Verify the StopDScreenMirror function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
@@ -129,38 +128,66 @@ HWTEST_F(DScreenManagerTestV2, StopDScreenMirror_001, TestSize.Level1)
     changedScreen->SetState(CONNECTING);
     ret = DScreenManager::GetInstance().StopDScreenMirror(changedScreen);
     EXPECT_EQ(DH_SUCCESS, ret);
+
+    changedScreen->SetState(DISCONNECTING);
+    ret = DScreenManager::GetInstance().StopDScreenMirror(changedScreen);
+    EXPECT_EQ(DH_SUCCESS, ret);
 }
 
 /**
  * @tc.name: OnRegResult_001
- * @tc.desc: Verify the OnRegResult function failed.
+ * @tc.desc: Verify the OnRegResult function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
 HWTEST_F(DScreenManagerTestV2, OnRegResult_001, TestSize.Level1)
 {
     std::shared_ptr<IDScreenCallback> dScreenCallback = std::make_shared<DScreenCallback>();
-    std::shared_ptr<DScreen> changedScreen = std::make_shared<DScreen>("devId000", "dhId000", dScreenCallback);
-    DScreenManager::GetInstance().OnRegResult(changedScreen, "taskId000", DH_SUCCESS, "dscreen enable success.");
-
-    int32_t ret = DScreenManager::GetInstance().Release();
-    EXPECT_EQ(DH_SUCCESS, ret);
+    std::shared_ptr<DScreen> dScreen = nullptr;
+    std::string reqId;
+    int32_t status = 0;
+    std::string data;
+    dScreenCallback->OnRegResult(dScreen, reqId, status, data);
+
+    std::string devId;
+    std::string dhId;
+    dScreen = std::make_shared<DScreen>(devId, dhId, dScreenCallback);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
+    dScreenCallback->OnRegResult(dScreen, reqId, status, data);
+
+    sptr<MockDScreenSourceCallback> mockInstance(new MockDScreenSourceCallback());
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = mockInstance;
+    EXPECT_CALL(*mockInstance, OnNotifyRegResult(_, _, _, _, _)).Times(1);
+    dScreenCallback->OnRegResult(dScreen, reqId, status, data);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
 }
 
 /**
  * @tc.name: OnUnregResult_001
- * @tc.desc: Verify the OnUnregResult function failed.
+ * @tc.desc: Verify the OnUnregResult function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
 HWTEST_F(DScreenManagerTestV2, OnUnregResult_001, TestSize.Level1)
 {
     std::shared_ptr<IDScreenCallback> dScreenCallback = std::make_shared<DScreenCallback>();
-    std::shared_ptr<DScreen> changedScreen = std::make_shared<DScreen>("devId000", "dhId000", dScreenCallback);
-    DScreenManager::GetInstance().OnUnregResult(changedScreen, "taskId000", DH_SUCCESS, "dscreen disable success.");
-
-    int32_t ret = DScreenManager::GetInstance().Release();
-    EXPECT_EQ(DH_SUCCESS, ret);
+    std::shared_ptr<DScreen> dScreen = nullptr;
+    std::string reqId;
+    int32_t status = 0;
+    std::string data;
+    dScreenCallback->OnUnregResult(dScreen, reqId, status, data);
+
+    std::string devId;
+    std::string dhId;
+    dScreen = std::make_shared<DScreen>(devId, dhId, dScreenCallback);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
+    dScreenCallback->OnUnregResult(dScreen, reqId, status, data);
+
+    sptr<MockDScreenSourceCallback> mockInstance(new MockDScreenSourceCallback());
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = mockInstance;
+    EXPECT_CALL(*mockInstance, OnNotifyUnregResult(_, _, _, _, _)).Times(1);
+    dScreenCallback->OnUnregResult(dScreen, reqId, status, data);
+    DScreenManager::GetInstance().dScreenSourceCallbackProxy_ = nullptr;
 }
 
 /**
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp
index 19a7f02dddcf5fc5ba4cb268ed3744cf6dbfd4c5..111f10977d5c4968e97eca2680cfc6d4c2cc1a43 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/2.0/src/dscreen_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-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
@@ -102,21 +102,87 @@ HWTEST_F(DScreenTestV2, HandleTask_001, TestSize.Level1)
 
 /**
  * @tc.name: HandleEnable_001
- * @tc.desc: Verify the HandleEnable function failed.
+ * @tc.desc: Verify the HandleEnable function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
 HWTEST_F(DScreenTestV2, HandleEnable_001, TestSize.Level1)
 {
     dScreen_->dscreenCallback_ = nullptr;
-    std::string param = "param";
+    std::string param = "Invalid parameter";
     std::string taskId = "taskId";
     dScreen_->HandleEnable(param, taskId);
     dScreen_->dscreenCallback_ = std::make_shared<DScreenCallback>();
-    DScreenState state = ENABLING;
+    DScreenState state = ENABLED;
+    dScreen_->SetState(state);
+    dScreen_->HandleEnable(param, taskId);
+    EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_);
+
+    state = ENABLING;
     dScreen_->SetState(state);
     dScreen_->HandleEnable(param, taskId);
     EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_);
+
+    state = CONNECTING;
+    dScreen_->SetState(state);
+    dScreen_->HandleEnable(param, taskId);
+    EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_);
+
+    state = CONNECTED;
+    dScreen_->SetState(state);
+    dScreen_->HandleEnable(param, taskId);
+    EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_);
+
+    state = DISABLED;
+    dScreen_->SetState(state);
+    dScreen_->HandleEnable(param, taskId);
+    EXPECT_NE(SCREEN_ID_INVALID, dScreen_->screenId_);
+}
+
+/**
+* @tc.name: ParseInputScreenParam_001
+* @tc.desc: Verify the ParseInputScreenParam function.
+* @tc.type: FUNC
+* @tc.require: Issue Number
+*/
+HWTEST_F(DScreenTestV2, ParseInputScreenParam_001, TestSize.Level1)
+{
+    json attrJson;
+    uint32_t width = 100;
+    uint32_t heigth = 100;
+    attrJson[KEY_SCREEN_WIDTH] = width;
+    attrJson[KEY_SCREEN_HEIGHT] = heigth;
+    attrJson[KEY_CODECTYPE] = 0;
+    attrJson[KEY_HISTREAMER_VIDEO_DECODER] = "remoteCodecInfoStr";
+    std::string param = attrJson.dump();
+    std::string taskId = "taskId";
+
+    dScreen_->videoParam_ = nullptr;
+    dScreen_->ParseInputScreenParam(param, taskId);
+    EXPECT_EQ(dScreen_->videoParam_->GetScreenWidth(), 0);
+}
+
+/**
+* @tc.name: ParseInputScreenParam_002
+* @tc.desc: Verify the ParseInputScreenParam function.
+* @tc.type: FUNC
+* @tc.require: Issue Number
+*/
+HWTEST_F(DScreenTestV2, ParseInputScreenParam_002, TestSize.Level1)
+{
+    json attrJson;
+    uint32_t width = 100;
+    uint32_t heigth = 100;
+    attrJson[KEY_SCREEN_WIDTH] = width;
+    attrJson[KEY_SCREEN_HEIGHT] = heigth;
+    attrJson[KEY_CODECTYPE] = 0;
+    attrJson[KEY_HISTREAMER_VIDEO_DECODER] = "remoteCodecInfoStr";
+    std::string param = attrJson.dump();
+    std::string taskId = "taskId";
+
+    dScreen_->videoParam_ = std::make_shared<VideoParam>();
+    dScreen_->ParseInputScreenParam(param, taskId);
+    EXPECT_EQ(dScreen_->videoParam_->GetScreenWidth(), 0);
 }
 
 /**
@@ -270,6 +336,40 @@ HWTEST_F(DScreenTestV2, StopSenderEngine_001, TestSize.Level1)
     EXPECT_EQ(ERR_DH_AV_TRANS_STOP_FAILED, ret);
 }
 
+/**
+ * @tc.name: ChooseParameter_001
+ * @tc.desc: Verify the ChooseParameter function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenTestV2, ChooseParameter_001, TestSize.Level1)
+{
+    std::string codecType = "";
+    std::string pixelFormat = "";
+    dScreen_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
+    dScreen_->videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H265);
+    dScreen_->videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_YUVI420);
+    dScreen_->ChooseParameter(codecType, pixelFormat);
+    EXPECT_EQ(codecType, MIME_VIDEO_H265);
+    EXPECT_EQ(pixelFormat, VIDEO_FORMAT_YUVI420);
+
+    dScreen_->videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264);
+    dScreen_->videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_NV12);
+    dScreen_->ChooseParameter(codecType, pixelFormat);
+    EXPECT_EQ(codecType, MIME_VIDEO_H264);
+    EXPECT_EQ(pixelFormat, VIDEO_FORMAT_NV12);
+
+    dScreen_->videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_MPEG4);
+    dScreen_->videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_NV21);
+    dScreen_->ChooseParameter(codecType, pixelFormat);
+    EXPECT_EQ(codecType, MIME_VIDEO_RAW);
+    EXPECT_EQ(pixelFormat, VIDEO_FORMAT_NV21);
+
+    dScreen_->videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_RGBA8888);
+    dScreen_->ChooseParameter(codecType, pixelFormat);
+    EXPECT_EQ(pixelFormat, VIDEO_FORMAT_RGBA8888);
+}
+
 /**
  * @tc.name: SetUp_001
  * @tc.desc: Verify the SetUp function failed.
@@ -388,39 +488,33 @@ HWTEST_F(DScreenTestV2, NegotiateCodecType_002, TestSize.Level1)
 HWTEST_F(DScreenTestV2, CheckJsonData_001, TestSize.Level1)
 {
     json attrJson;
-    uint32_t width = 100;
-    uint32_t heigth = 100;
-    attrJson["screenWidth"] = width;
-    attrJson["screenHeight"] = heigth;
-    attrJson["codecType"] = 0;
-    EXPECT_EQ(true, dScreen_->CheckJsonData(attrJson));
+    EXPECT_FALSE(dScreen_->CheckJsonData(attrJson));
 }
 
 /**
  * @tc.name: CheckJsonData_002
- * @tc.desc: Verify the CheckJsonData function failed.
+ * @tc.desc: Verify the CheckJsonData function.
  * @tc.type: FUNC
  * @tc.require: Issue Number
  */
 HWTEST_F(DScreenTestV2, CheckJsonData_002, TestSize.Level1)
 {
     json attrJson;
-    std::string taskId = "taskId";
-    EXPECT_EQ(false, dScreen_->CheckJsonData(attrJson));
-}
+    uint32_t unsignedValue = 100;
+    int32_t signedValue = 100;
+    attrJson[KEY_SCREEN_WIDTH] = unsignedValue;
+    attrJson[KEY_SCREEN_HEIGHT] = unsignedValue;
+    attrJson[KEY_CODECTYPE] = 0;
+    EXPECT_TRUE(dScreen_->CheckJsonData(attrJson));
 
-/**
- * @tc.name: CheckJsonData_003
- * @tc.desc: Verify the CheckJsonData function failed.
- * @tc.type: FUNC
- * @tc.require: Issue Number
- */
-HWTEST_F(DScreenTestV2, CheckJsonData_003, TestSize.Level1)
-{
-    json attrJson;
-    attrJson["dhid"] = "dhid";
-    std::string taskId = "taskId";
-    EXPECT_EQ(false, dScreen_->CheckJsonData(attrJson));
+    attrJson.erase(KEY_CODECTYPE);
+    EXPECT_FALSE(dScreen_->CheckJsonData(attrJson));
+
+    attrJson[KEY_SCREEN_HEIGHT] = signedValue;
+    EXPECT_FALSE(dScreen_->CheckJsonData(attrJson));
+
+    attrJson[KEY_SCREEN_WIDTH] = signedValue;
+    EXPECT_FALSE(dScreen_->CheckJsonData(attrJson));
 }
 
 /**
@@ -440,6 +534,35 @@ HWTEST_F(DScreenTestV2, OnEngineEvent_001, TestSize.Level1)
     EXPECT_EQ(SCREEN_ID_INVALID, dScreen_->screenId_);
 }
 
+/**
+ * @tc.name: OnEngineMessage_001
+ * @tc.desc: Verify the OnEngineMessage function.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenTestV2, OnEngineMessage_001, TestSize.Level1)
+{
+    uint32_t type = 0;
+    std::string content = "content";
+    std::string dstDevId = "dstDevId";
+    std::shared_ptr<AVTransMessage> message = nullptr;
+    dScreen_->OnEngineMessage(message);
+    EXPECT_FALSE(dScreen_->sinkStartSuccess_);
+
+    message = std::make_shared<AVTransMessage>(type, content, dstDevId);
+    message->type_ = DScreenMsgType::START_MIRROR_SUCCESS;
+    dScreen_->OnEngineMessage(message);
+    EXPECT_TRUE(dScreen_->sinkStartSuccess_);
+
+    message->type_ = DScreenMsgType::START_MIRROR_FAIL;
+    dScreen_->OnEngineMessage(message);
+    EXPECT_FALSE(dScreen_->sinkStartSuccess_);
+
+    message->type_ = DScreenMsgType::START_MIRROR;
+    dScreen_->OnEngineMessage(message);
+    EXPECT_FALSE(dScreen_->sinkStartSuccess_);
+}
+
 /**
  * @tc.name: ChooseCodecType_001
  * @tc.desc: Verify the ChooseCodecType function.
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn
index 3724e5b53c59b871976fa58a73156b51a891aba8..5ef211a7a901213f322b6c95cfc4f494422a207f 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn
+++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn
@@ -43,6 +43,12 @@ config("module_private_config") {
 ## UnitTest DscreenMgrTest
 ohos_unittest("DscreenMgrTest") {
   module_out_path = module_out_path
+  sanitize = {
+    blocklist = "${common_path}/test/unittest/resource/cfi_blocklist.txt"
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
 
   sources = [
     "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/1.0/src/dscreen_manager_test.cpp",
diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp
index b4324de338af54272c09866c1f1eb3f89ad92079..d5e600b1dc3ed6ceecb4f7093c860b3ebe5b7884 100644
--- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp
+++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/callback/dscreen_source_callback_stub_test.cpp
@@ -162,5 +162,60 @@ HWTEST_F(DScreenSourceCallbackStubTest, OnRemoteRequest_001, TestSize.Level1)
     int32_t result = callback->OnRemoteRequest(requestCode, data, reply, option);
     EXPECT_NE(0, result);
 }
+
+/**
+ * @tc.name: CheckParams_001
+ * @tc.desc: Invoke the CheckParams ipc interface.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSourceCallbackStubTest, CheckParams_001, TestSize.Level1)
+{
+    std::string devId = "devId";
+    std::string dhId = "dhId";
+    std::string reqId = "reqId";
+    std::string resultData = "resultData";
+    std::shared_ptr<DScreenSourceCallbackStub> callback = std::make_shared<TestDScreenSourceCallbackStub>();
+    EXPECT_TRUE(callback->CheckParams(devId, dhId, reqId, resultData));
+}
+
+/**
+ * @tc.name: CheckParams_002
+ * @tc.desc: Invoke the CheckParams ipc interface.
+ * @tc.type: FUNC
+ * @tc.require: Issue Number
+ */
+HWTEST_F(DScreenSourceCallbackStubTest, CheckParams_002, TestSize.Level1)
+{
+    std::string exceedDidMaxSizeStr(DID_MAX_SIZE + 1, 'a');
+    std::string exceedParamMaxSizeStr(PARAM_MAX_SIZE + 1, 'a');
+    std::string devId = "devId";
+    std::string dhId = "dhId";
+    std::string reqId = "reqId";
+    std::string resultData = exceedParamMaxSizeStr;
+    std::shared_ptr<DScreenSourceCallbackStub> callback = std::make_shared<TestDScreenSourceCallbackStub>();
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    resultData.clear();
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    reqId = exceedDidMaxSizeStr;
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    reqId.clear();
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    dhId = exceedDidMaxSizeStr;
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    dhId.clear();
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    devId = exceedDidMaxSizeStr;
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+
+    devId.clear();
+    EXPECT_FALSE(callback->CheckParams(devId, dhId, reqId, resultData));
+}
 }  // namespace DistributedHardware
 }  // namespace OHOS