diff --git a/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp b/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
index 72a772a073002e0a8799d71f1be948329759f2ad..f1600e1fdda03275c8f087eb9ad277852d62b0da 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
@@ -1246,7 +1246,16 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenMaxRefreshRate, TestSize
  */
 HWTEST_F(ScreenSessionManagerProxyTest, IsScreenRotationLocked, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     bool isLocked = true;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
+            screenSessionManagerProxy->IsScreenRotationLocked(isLocked));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
                 screenSessionManagerProxy->IsScreenRotationLocked(isLocked));
@@ -1263,10 +1272,25 @@ HWTEST_F(ScreenSessionManagerProxyTest, IsScreenRotationLocked, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetCutoutInfo, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     sptr<CutoutInfo> expectation = nullptr;
     DisplayId displayId = 0;
+
     MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto res = screenSessionManagerProxy->GetCutoutInfo(displayId);
+    EXPECT_TRUE(logMsg.find("failed") != std::string::nops);
+    ASSERT_EQ(res, expectation);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    res = screenSessionManagerProxy->GetCutoutInfo(displayId);
+    EXPECT_TRUE(logMsg.find("write displayId failed") != std::string::npos);
+    ASSERT_EQ(res, expectation);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    res = screenSessionManagerProxy->GetCutoutInfo(displayId);
     ASSERT_EQ(res, expectation);
 }
 
@@ -1277,12 +1301,24 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetCutoutInfo, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, HasImmersiveWindow, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     bool immersive = true;
+
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
     } else {
         EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
     }
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
 }
 
 /**
@@ -1292,9 +1328,24 @@ HWTEST_F(ScreenSessionManagerProxyTest, HasImmersiveWindow, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, ConvertScreenIdToRsScreenId, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ScreenId screenId = 1001;
     ScreenId rsScreenId = 1002;
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(ret, false);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
+    EXPECT_EQ(ret, false);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
     EXPECT_EQ(ret, false);
 }
 
@@ -1305,8 +1356,23 @@ HWTEST_F(ScreenSessionManagerProxyTest, ConvertScreenIdToRsScreenId, TestSize.Le
  */
 HWTEST_F(ScreenSessionManagerProxyTest, HasPrivateWindow, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     bool hasPrivateWindow = true;
     DisplayId displayId = 0;
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
+            screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
+            screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
+
+    MockMessageParcel::ClearErrorFlag();
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
                 screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
@@ -1323,7 +1389,16 @@ HWTEST_F(ScreenSessionManagerProxyTest, HasPrivateWindow, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, DumpAllScreensInfo, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     std::string dumpInfo;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->DumpAllScreensInfo(dumpInfo);
+    EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
+    EXPECT_EQ(dumpInfo, "");
+
     MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->DumpAllScreensInfo(dumpInfo);
     EXPECT_EQ(dumpInfo, "");
@@ -1336,8 +1411,23 @@ HWTEST_F(ScreenSessionManagerProxyTest, DumpAllScreensInfo, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, DumpSpecialScreenInfo, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ScreenId id = 1001;
     std::string dumpInfo;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
+    EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
+    EXPECT_EQ(dumpInfo, "");
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
+    EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
+    EXPECT_EQ(dumpInfo, "");
+
     MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
     EXPECT_EQ(dumpInfo, "");
@@ -1350,7 +1440,21 @@ HWTEST_F(ScreenSessionManagerProxyTest, DumpSpecialScreenInfo, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayMode, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
+    EXPECT_TRUE(logMsg.find("Write displayMode failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
     if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
         EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
@@ -1366,7 +1470,21 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayMode, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayModeFromJs, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
+    EXPECT_TRUE(logMsg.find("Write displayMode failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
     } else {
@@ -1381,7 +1499,21 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayModeFromJs, TestSize.Level
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusLocked, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     bool locked = true;
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->SetFoldStatusLocked(locked);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    screenSessionManagerProxy->SetFoldStatusLocked(locked);
+    EXPECT_TRUE(logMsg.find("Write lock fold display status failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->SetFoldStatusLocked(locked);
     if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
         EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
@@ -1397,6 +1529,15 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusLocked, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetFoldDisplayMode, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerProxy->GetFoldDisplayMode());
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
     EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerProxy->GetFoldDisplayMode());
 }
 
@@ -1407,6 +1548,15 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetFoldDisplayMode, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, IsFoldable, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->IsFoldable();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearErrorFlag();
     screenSessionManagerProxy->IsFoldable();
     auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
     EXPECT_EQ(screenSession, nullptr);
@@ -1419,7 +1569,17 @@ HWTEST_F(ScreenSessionManagerProxyTest, IsFoldable, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, IsCaptured, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto ret = screenSessionManagerProxy->IsCaptured();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(ret, false);
+
+    MockMessageParcel::ClearErrorFlag();
+    ret = screenSessionManagerProxy->IsCaptured();
     EXPECT_EQ(ret, false);
 }
 
@@ -1430,7 +1590,17 @@ HWTEST_F(ScreenSessionManagerProxyTest, IsCaptured, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetFoldStatus, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto foldStatus = screenSessionManagerProxy->GetFoldStatus();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(foldStatus, FoldStatus::UNKNOWN);
+
+    MockMessageParcel::ClearErrorFlag();
+    foldStatus = screenSessionManagerProxy->GetFoldStatus();
     EXPECT_EQ(foldStatus, FoldStatus::UNKNOWN);
 }
 
@@ -1441,7 +1611,17 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetFoldStatus, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetSuperFoldStatus, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto superFoldStatus = screenSessionManagerProxy->GetSuperFoldStatus();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
+
+    MockMessageParcel::ClearErrorFlag();
+    superFoldStatus = screenSessionManagerProxy->GetSuperFoldStatus();
     EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
 }
 
@@ -1452,6 +1632,14 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetSuperFoldStatus, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetSuperRotation, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_FLOAT_EQ(screenSessionManagerProxy->GetSuperRotation(), -1.f);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
     MockMessageParcel::ClearAllErrorFlag();
     EXPECT_FLOAT_EQ(screenSessionManagerProxy->GetSuperRotation(), 0);
 }
@@ -1463,7 +1651,23 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetSuperRotation, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetLandscapeLockStatus, Function | SmallTest | Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     bool isLocked = false;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(isLocked, false);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteBoolErrorFlag(true);
+    screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
+    EXPECT_TRUE(logMsg.find("Write isLocked failed") != std::string::npos);
+    EXPECT_EQ(isLocked, false);
+
+    MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
     EXPECT_EQ(isLocked, false);
 }
@@ -1475,7 +1679,17 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetLandscapeLockStatus, Function | Small
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetCurrentFoldCreaseRegion, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     auto foldCreaseRegion = screenSessionManagerProxy->GetCurrentFoldCreaseRegion();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(foldCreaseRegion, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    foldCreaseRegion = screenSessionManagerProxy->GetCurrentFoldCreaseRegion();
     EXPECT_EQ(foldCreaseRegion, nullptr);
 }
 
@@ -1486,9 +1700,23 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetCurrentFoldCreaseRegion, TestSize.Lev
  */
 HWTEST_F(ScreenSessionManagerProxyTest, MakeUniqueScreen, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     const std::vector<ScreenId> screenIds {1001, 1002, 1003};
     std::vector<DisplayId> displayIds;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     EXPECT_EQ(DMError::DM_ERROR_NULLPTR, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
+    EXPECT_TRUE(logMsg.find("write screenIds size failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
 }
 
 /**
@@ -1498,8 +1726,19 @@ HWTEST_F(ScreenSessionManagerProxyTest, MakeUniqueScreen, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetClient, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     const sptr<IScreenSessionManagerClient> client = nullptr;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     screenSessionManagerProxy->SetClient(client);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(client, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    screenSessionManagerProxy->SetClient(client);
+    EXPECT_TRUE(logMsg.find("WriteRemoteObject failed") != std::string::npos);
     EXPECT_EQ(client, nullptr);
 }
 
@@ -1510,8 +1749,19 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetClient, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SwitchUser, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
     screenSessionManagerProxy->SwitchUser();
     auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(screenSession, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    screenSessionManagerProxy->SwitchUser();
+    screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
     EXPECT_EQ(screenSession, nullptr);
 }
 
@@ -1522,7 +1772,21 @@ HWTEST_F(ScreenSessionManagerProxyTest, SwitchUser, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenProperty, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ScreenId screenId = 1001;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->GetScreenProperty(screenId);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    screenSessionManagerProxy->GetScreenProperty(screenId);
+    EXPECT_TRUE(logMsg.find("Write screenId failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->GetScreenProperty(screenId);
     auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
     EXPECT_EQ(screenSession, nullptr);
@@ -1535,8 +1799,16 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetScreenProperty, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayHookInfo, Function | SmallTest | Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     int32_t uid = 0;
     DMHookInfo hookInfo;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->GetDisplayHookInfo(uid, hookInfo);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
     MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->GetDisplayHookInfo(uid, hookInfo);
     EXPECT_EQ(hookInfo.height_, 0);
@@ -1550,25 +1822,35 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayHookInfo, Function | SmallTest
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenCapture, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ASSERT_TRUE(screenSessionManagerProxy != nullptr);
 
-    std::shared_ptr<Media::PixelMap> res = nullptr;
     CaptureOption option;
     option.displayId_ = 0;
     DmErrorCode errorCode = DmErrorCode::DM_OK;
-    std::function<void()> func = [&]() {
-        res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
-    };
-    func();
-    if (SceneBoardJudgement::IsSceneBoardEnabled()) {
-        if (errorCode == DmErrorCode::DM_OK) {
-            ASSERT_NE(res, nullptr);
-        } else {
-            ASSERT_EQ(res, nullptr);
-        }
-    } else {
-        ASSERT_EQ(res, nullptr);
-    }
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    auto res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    ASSERT_EQ(res, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint64ErrorFlag(true);
+    res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
+    EXPECT_TRUE(logMsg.find("Write displayId or isNeedNotify or isNeedPointer failed") != std::string::npos);
+    ASSERT_EQ(res, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteBoolErrorFlag(true);
+    res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
+    EXPECT_TRUE(logMsg.find("Write displayId or isNeedNotify or isNeedPointer failed") != std::string::npos);
+    ASSERT_EQ(res, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
+    ASSERT_EQ(res, nullptr);
 }
 
 /**
@@ -1578,18 +1860,19 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetScreenCapture, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetPrimaryDisplayInfo, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ASSERT_TRUE(screenSessionManagerProxy != nullptr);
 
-    sptr<DisplayInfo> res = nullptr;
-    std::function<void()> func = [&]() {
-        res = screenSessionManagerProxy->GetPrimaryDisplayInfo();
-    };
-    func();
-    if (SceneBoardJudgement::IsSceneBoardEnabled()) {
-        ASSERT_NE(res, nullptr);
-    } else {
-        ASSERT_EQ(res, nullptr);
-    }
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    auto res = screenSessionManagerProxy->GetPrimaryDisplayInfo();
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    ASSERT_EQ(res, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    res = screenSessionManagerProxy->GetPrimaryDisplayInfo();
+    ASSERT_EQ(res, nullptr);
 }
 
 /**
@@ -1599,17 +1882,28 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetPrimaryDisplayInfo, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenSkipProtectedWindow, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ASSERT_TRUE(screenSessionManagerProxy != nullptr);
 
     const std::vector<ScreenId> screenIds = {1001, 1002};
     bool isEnable = true;
-    int resultValue = 0;
-    std::function<void()> func = [&]() {
-        screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
-        resultValue = 1;
-    };
-    func();
-    ASSERT_EQ(resultValue, 1);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    auto res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    ASSERT_EQ(res, DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteBoolErrorFlag(true);
+    auto res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
+    EXPECT_TRUE(logMsg.find("Write isEnable failed") != std::string::npos);
+    ASSERT_EQ(res, DMError::DM_ERROR_WRITE_DATA_FAILED);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    auto res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
+    ASSERT_EQ(res, DMError::DM_OK);
 }
 
 /**
@@ -1619,8 +1913,18 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetScreenSkipProtectedWindow, TestSize.L
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayCapability, TestSize.Level1)
 {
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     ASSERT_TRUE(screenSessionManagerProxy != nullptr);
     std::string capabilitInfo;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    EXPECT_NE(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
+            screenSessionManagerProxy->GetDisplayCapability(capabilitInfo));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
                 screenSessionManagerProxy->GetDisplayCapability(capabilitInfo));
@@ -1637,13 +1941,52 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayCapability, TestSize.Level1)
  */
 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusExpandAndLocked, Function | SmallTest | Level1)
 {
-    SingletonContainer::Get<ScreenManagerAdapter>().InitDMSProxy();
-    sptr<IRemoteObject> impl = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
-    sptr<ScreenSessionManagerProxy> screenSessionManagerProxy = new ScreenSessionManagerProxy(impl);
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
+    EXPECT_TRUE(logMsg.find("Write lock fold display status failed") != std::string::npos);
+
+    MockMessageParcel::ClearAllErrorFlag();
     screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
     EXPECT_EQ(ScreenSessionManager::GetInstance().GetIsFoldStatusLocked(), false);
 }
 
+/**
+ * @tc.name: SetPrimaryDisplaySystemDpi
+ * @tc.desc: SetPrimaryDisplaySystemDpi
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerProxyTest, SetPrimaryDisplaySystemDpi, Function | SmallTest | Level1)
+{
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
+    float dpi = 2.2f;
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    auto ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteFloatErrorFlag(true);
+    ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
+    EXPECT_TRUE(logMsg.find("write dpi failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    auto ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
+    EXPECT_EQ(DMError::DM_OK, ret);
+}
+
 /**
  * @tc.name: GetScreenAreaOfDisplayArea
  * @tc.desc: GetScreenAreaOfDisplayArea
@@ -1651,14 +1994,38 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusExpandAndLocked, Function |
  */
 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenAreaOfDisplayArea, Function | SmallTest | Level1)
 {
-    SingletonContainer::Get<ScreenManagerAdapter>().InitDMSProxy();
-    sptr<IRemoteObject> impl = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
-    sptr<ScreenSessionManagerProxy> screenSessionManagerProxy = new ScreenSessionManagerProxy(impl);
-    ASSERT_TRUE(screenSessionManagerProxy != nullptr);
+    logMsg.clear();
+    LOG_SetCallback(MyLogCallback);
     DisplayId displayId = 0;
     DMRect displayArea = DMRect::NONE();
     ScreenId screenId = 0;
     DMRect screenArea = DMRect::NONE();
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    auto ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
+    EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteU64ErrorFlag(true);
+    ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
+    EXPECT_TRUE(logMsg.find("Write displayId failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInt32ErrorFlag(true);
+    ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
+    EXPECT_TRUE(logMsg.find("Write displayArea failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteUint32ErrorFlag(true);
+    ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
+    EXPECT_TRUE(logMsg.find("Write displayArea failed") != std::string::npos);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
+
+    MockMessageParcel::ClearAllErrorFlag();
     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
         EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
                 screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
@@ -1668,22 +2035,6 @@ HWTEST_F(ScreenSessionManagerProxyTest, GetScreenAreaOfDisplayArea, Function | S
     }
 }
 
-/**
- * @tc.name: SetPrimaryDisplaySystemDpi
- * @tc.desc: SetPrimaryDisplaySystemDpi
- * @tc.type: FUNC
- */
-HWTEST_F(ScreenSessionManagerProxyTest, SetPrimaryDisplaySystemDpi, Function | SmallTest | Level1)
-{
-    DisplayId displayId = 0;
-    DMRect displayArea = DMRect::NONE();
-    ScreenId screenId = 0;
-    DMRect screenArea = DMRect::NONE();
-    float dpi = 2.2f;
-    auto ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
-    EXPECT_EQ(DMError::DM_OK, ret);
-}
-
 /**
  * @tc.name: GetPhysicalScreenIds
  * @tc.desc: GetPhysicalScreenIds