From 3ea441e06f85400fd831373cb580345a539eb4c7 Mon Sep 17 00:00:00 2001
From: zhangqirui <zhangqirui4@huawei.com>
Date: Mon, 8 Sep 2025 16:41:28 +0800
Subject: [PATCH 1/2] clean code and fix log

Signed-off-by: zhangqirui <zhangqirui4@huawei.com>
---
 interfaces/innerkits/wm/window_manager.h      |  1 -
 .../session_manager/include/session_manager.h |  2 +-
 .../session_manager/src/session_manager.cpp   |  8 +-----
 .../src/session_manager_lite.cpp              |  3 +--
 wm/src/window_adapter.cpp                     | 27 +++++++++++++------
 wm/src/window_adapter_lite.cpp                | 18 ++++++-------
 6 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/interfaces/innerkits/wm/window_manager.h b/interfaces/innerkits/wm/window_manager.h
index bbdc7aec17..ab2484ec00 100644
--- a/interfaces/innerkits/wm/window_manager.h
+++ b/interfaces/innerkits/wm/window_manager.h
@@ -33,7 +33,6 @@
 #include "wm_common.h"
 #include "wm_single_instance.h"
 
-
 namespace OHOS {
 namespace Rosen {
 struct SystemBarRegionTint {
diff --git a/window_scene/session_manager/include/session_manager.h b/window_scene/session_manager/include/session_manager.h
index 8259913332..6f5d94170e 100644
--- a/window_scene/session_manager/include/session_manager.h
+++ b/window_scene/session_manager/include/session_manager.h
@@ -45,7 +45,7 @@ private:
 };
 
 class SessionManager : public RefBase {
-WM_DECLARE_SINGLE_INSTANCE_BASE(SessionManager);
+    WM_DECLARE_SINGLE_INSTANCE_BASE(SessionManager);
 
 public:
     static sptr<SessionManager> GetInstance(const int32_t userId);
diff --git a/window_scene/session_manager/src/session_manager.cpp b/window_scene/session_manager/src/session_manager.cpp
index 0ea138bcb9..b985af976c 100644
--- a/window_scene/session_manager/src/session_manager.cpp
+++ b/window_scene/session_manager/src/session_manager.cpp
@@ -125,7 +125,6 @@ SessionManager& SessionManager::GetInstance()
 sptr<SessionManager> SessionManager::GetInstance(const int32_t userId)
 {
     sptr<SessionManager> instance = nullptr;
-
     if (userId <= INVALID_USER_ID) {
         instance = &SessionManager::GetInstance();
         return instance;
@@ -329,13 +328,8 @@ void SessionManager::RegisterSMSRecoverListener()
             TLOGE(WmsLogTag::WMS_SCB, "Get mock sms proxy failed");
             return;
         }
-    }
-    TLOGI(WmsLogTag::WMS_RECOVER, "begin register listener");
-    sptr<SessionManager> sm(this);
-    smsRecoverListener_ = sptr<SessionManagerServiceRecoverListener>::MakeSptr(sm);
-    {
+        smsRecoverListener_ = sptr<SessionManagerServiceRecoverListener>::MakeSptr(this);
         TLOGD(WmsLogTag::WMS_RECOVER, "Register recover listener, userId_: %{public}d", userId_);
-        std::lock_guard<std::mutex> lock(mockSessionManagerServiceMutex_);
         mockSessionManagerServiceProxy_->RegisterSMSRecoverListener(smsRecoverListener_, userId_);
     }
     {
diff --git a/window_scene/session_manager/src/session_manager_lite.cpp b/window_scene/session_manager/src/session_manager_lite.cpp
index ff99c58722..cde9a66592 100644
--- a/window_scene/session_manager/src/session_manager_lite.cpp
+++ b/window_scene/session_manager/src/session_manager_lite.cpp
@@ -525,8 +525,7 @@ void SessionManagerLite::RegisterSMSRecoverListener()
         }
         recoverListenerRegistered_ = true;
         TLOGD(WmsLogTag::WMS_RECOVER, "Register recover listener");
-        sptr<SessionManagerLite> sml(this);
-        smsRecoverListener_ = sptr<SessionManagerServiceLiteRecoverListener>::MakeSptr(sml);
+        smsRecoverListener_ = sptr<SessionManagerServiceLiteRecoverListener>::MakeSptr(this);
         std::string identity = IPCSkeleton::ResetCallingIdentity();
         TLOGD(WmsLogTag::WMS_RECOVER, "Register recover listener, userId_: %{public}d", userId_);
         mockSessionManagerServiceProxy_->RegisterSMSLiteRecoverListener(smsRecoverListener_, userId_);
diff --git a/wm/src/window_adapter.cpp b/wm/src/window_adapter.cpp
index 5ca46b6e7b..5f67dcc971 100644
--- a/wm/src/window_adapter.cpp
+++ b/wm/src/window_adapter.cpp
@@ -626,31 +626,42 @@ bool WindowAdapter::InitSSMProxy()
         return true;
     }
     windowManagerServiceProxy_ = SessionManager::GetInstance(userId_)->GetSceneSessionManagerProxy();
-    if (!windowManagerServiceProxy_ || !windowManagerServiceProxy_->AsObject()) {
-        WLOGFE("Failed to get system scene session manager services");
+    if (!windowManagerServiceProxy_) {
+        TLOGE(WmsLogTag::WMS_SCB, "windowManagerServiceProxy_ is null");
         return false;
     }
-    wmsDeath_ = sptr<WMSDeathRecipient>::MakeSptr(userId_);
     sptr<IRemoteObject> remoteObject = windowManagerServiceProxy_->AsObject();
+    if (!remoteObject) {
+        TLOGE(WmsLogTag::WMS_SCB, "remoteObject is null");
+        return false;
+    }
+    wmsDeath_ = sptr<WMSDeathRecipient>::MakeSptr(userId_);
     if (remoteObject->IsProxyObject() && !remoteObject->AddDeathRecipient(wmsDeath_)) {
-        WLOGFE("Failed to add death recipient");
+        TLOGE(WmsLogTag::WMS_SCB, "Failed to add death recipient");
         return false;
     }
     if (!recoverInitialized_) {
         SessionManager::GetInstance(userId_)->RegisterWindowManagerRecoverCallbackFunc([weakThis = wptr(this)] {
-            auto windowAdapter = weakThis.promote();
-            if (!windowAdapter) {
+            auto instance = weakThis.promote();
+            if (!instance) {
                 TLOGE(WmsLogTag::WMS_SCB, "window adapter is null");
                 return;
             }
-            windowAdapter->WindowManagerAndSessionRecover();
+            instance->WindowManagerAndSessionRecover();
         });
         recoverInitialized_ = true;
     }
     // U0 system user needs to subscribe OnUserSwitch event
     int32_t clientUserId = GetUserIdByUid(getuid());
     if (clientUserId == SYSTEM_USERID && !isRegisteredUserSwitchListener_) {
-        SessionManager::GetInstance(userId_)->RegisterUserSwitchListener([this]() { this->OnUserSwitch(); });
+        SessionManager::GetInstance(userId_)->RegisterUserSwitchListener([weakThis = wptr(this)]() {
+            auto instance = weakThis.promote();
+            if (!instance) {
+                TLOGE(WmsLogTag::WMS_SCB, "window adapter is null");
+                return;
+            }
+            instance->OnUserSwitch();
+        });
         isRegisteredUserSwitchListener_ = true;
     }
     isProxyValid_ = true;
diff --git a/wm/src/window_adapter_lite.cpp b/wm/src/window_adapter_lite.cpp
index e147ce83cd..892d998cf5 100644
--- a/wm/src/window_adapter_lite.cpp
+++ b/wm/src/window_adapter_lite.cpp
@@ -166,18 +166,18 @@ bool WindowAdapterLite::InitSSMProxy()
         return true;
     }
     windowManagerServiceProxy_ = SessionManagerLite::GetInstance(userId_)->GetSceneSessionManagerLiteProxy();
-    if (!windowManagerServiceProxy_ || !windowManagerServiceProxy_->AsObject()) {
-        WLOGFE("Failed to get scene session manager lite proxy");
+    if (!windowManagerServiceProxy_) {
+        TLOGE(WmsLogTag::WMS_SCB, "windowManagerServiceProxy_ is null");
         return false;
     }
-    wmsDeath_ = new (std::nothrow) WMSDeathRecipient(userId_);
-    if (!wmsDeath_) {
-        WLOGFE("Failed to create death recipient WMSDeathRecipient");
+    sptr<IRemoteObject> remoteObject = windowManagerServiceProxy_->AsObject();
+    if (!remoteObject) {
+        TLOGE(WmsLogTag::WMS_SCB, "remoteObject is null");
         return false;
     }
-    sptr<IRemoteObject> remoteObject = windowManagerServiceProxy_->AsObject();
+    wmsDeath_ = sptr<WMSDeathRecipient>::MakeSptr(userId_);
     if (remoteObject->IsProxyObject() && !remoteObject->AddDeathRecipient(wmsDeath_)) {
-        WLOGFE("Failed to add death recipient");
+        TLOGE(WmsLogTag::WMS_SCB, "Failed to add death recipient");
         return false;
     }
     // U0 system user needs to subscribe OnUserSwitch event
@@ -221,12 +221,12 @@ WMSDeathRecipient::WMSDeathRecipient(int32_t userId) : userId_(userId) {}
 void WMSDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& wptrDeath)
 {
     if (wptrDeath == nullptr) {
-        WLOGFE("wptrDeath is null");
+        TLOGE(WmsLogTag::WMS_SCB, "wptrDeath is null");
         return;
     }
     sptr<IRemoteObject> object = wptrDeath.promote();
     if (!object) {
-        WLOGFE("object is null");
+        TLOGE(WmsLogTag::WMS_SCB, "object is null");
         return;
     }
     TLOGI(WmsLogTag::WMS_SCB, "wms lite OnRemoteDied");
-- 
Gitee


From e981417d0f5ab6efe90ec61aa44b8d229de8ebd4 Mon Sep 17 00:00:00 2001
From: zhangqirui <zhangqirui4@huawei.com>
Date: Fri, 5 Sep 2025 10:37:37 +0800
Subject: [PATCH 2/2] add tdd testcase

Signed-off-by: zhangqirui <zhangqirui4@huawei.com>
---
 .../session_manager/src/session_manager.cpp   |   2 +-
 .../multi_user/session_manager_lite_test.cpp  |   9 +-
 .../multi_user/session_manager_test.cpp       | 125 ++-
 .../unittest/session_manager_lite_test.cpp    | 164 ++--
 .../test/unittest/session_manager_test.cpp    | 135 ++-
 wm/test/unittest/window_adapter_lite_test.cpp |  60 +-
 wm/test/unittest/window_adapter_test.cpp      |  19 +-
 wm/test/unittest/window_manager_lite_test.cpp | 667 ++++++--------
 wm/test/unittest/window_manager_test.cpp      | 817 ++++++++----------
 9 files changed, 907 insertions(+), 1091 deletions(-)

diff --git a/window_scene/session_manager/src/session_manager.cpp b/window_scene/session_manager/src/session_manager.cpp
index b985af976c..63bc8e30c9 100644
--- a/window_scene/session_manager/src/session_manager.cpp
+++ b/window_scene/session_manager/src/session_manager.cpp
@@ -329,7 +329,7 @@ void SessionManager::RegisterSMSRecoverListener()
             return;
         }
         smsRecoverListener_ = sptr<SessionManagerServiceRecoverListener>::MakeSptr(this);
-        TLOGD(WmsLogTag::WMS_RECOVER, "Register recover listener, userId_: %{public}d", userId_);
+        TLOGI(WmsLogTag::WMS_RECOVER, "Register recover listener, userId_: %{public}d", userId_);
         mockSessionManagerServiceProxy_->RegisterSMSRecoverListener(smsRecoverListener_, userId_);
     }
     {
diff --git a/window_scene/test/unittest/multi_user/session_manager_lite_test.cpp b/window_scene/test/unittest/multi_user/session_manager_lite_test.cpp
index fee20d9a05..a7e910c7a7 100644
--- a/window_scene/test/unittest/multi_user/session_manager_lite_test.cpp
+++ b/window_scene/test/unittest/multi_user/session_manager_lite_test.cpp
@@ -14,9 +14,8 @@
  */
 
 #include <gtest/gtest.h>
-
-#include "session_manager_lite.h"
 #include "iremote_object_mocker.h"
+#include "session_manager_lite.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -29,12 +28,12 @@ public:
     void TearDown() override;
 
 private:
-    std::shared_ptr<SessionManagerLite> sml_;
+    sptr<SessionManagerLite> sml_;
 };
 
 void SessionManagerLiteTest::SetUp()
 {
-    sml_ = std::make_shared<SessionManagerLite>();
+    sml_ = SessionManagerLite::GetInstance(-1);
 }
 
 void SessionManagerLiteTest::TearDown()
@@ -70,7 +69,7 @@ HWTEST_F(SessionManagerLiteTest, InitSceneSessionManagerLiteProxy01, Function |
 {
     ASSERT_NE(nullptr, sml_);
     sml_->InitSceneSessionManagerLiteProxy();
-    ASSERT_EQ(nullptr, sml_->sceneSessionManagerLiteProxy_);
+    ASSERT_NE(nullptr, sml_->sceneSessionManagerLiteProxy_);
 }
 
 /**
diff --git a/window_scene/test/unittest/multi_user/session_manager_test.cpp b/window_scene/test/unittest/multi_user/session_manager_test.cpp
index 2d75d79f77..73cd460b16 100644
--- a/window_scene/test/unittest/multi_user/session_manager_test.cpp
+++ b/window_scene/test/unittest/multi_user/session_manager_test.cpp
@@ -28,19 +28,14 @@ class SessionManagerTest : public Test {
 public:
     void SetUp() override;
     void TearDown() override;
-
-private:
-    std::shared_ptr<SessionManager> sm_;
 };
 
 void SessionManagerTest::SetUp()
 {
-    sm_ = std::make_shared<SessionManager>();
 }
 
 void SessionManagerTest::TearDown()
 {
-    sm_ = nullptr;
 }
 
 /**
@@ -50,15 +45,15 @@ void SessionManagerTest::TearDown()
  */
 HWTEST_F(SessionManagerTest, GetSceneSessionManagerProxy, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->RemoveSSMDeathRecipient();
-    sm_->ClearSessionManagerProxy();
-    auto sceneSessionManagerProxy = sm_->GetSceneSessionManagerProxy();
+    auto sm = SessionManager::GetInstance(-1);
+    sm->RemoveSSMDeathRecipient();
+    sm->ClearSessionManagerProxy();
+    auto sceneSessionManagerProxy = sm->GetSceneSessionManagerProxy();
     ASSERT_NE(nullptr, sceneSessionManagerProxy);
 
-    sm_->ClearSessionManagerProxy();
-    sm_->sessionManagerServiceProxy_ = SessionManagerLite::GetInstance().GetSessionManagerServiceProxy();
-    sceneSessionManagerProxy = sm_->GetSceneSessionManagerProxy();
+    sm->ClearSessionManagerProxy();
+    sm->sessionManagerServiceProxy_ = SessionManagerLite::GetInstance().GetSessionManagerServiceProxy();
+    sceneSessionManagerProxy = sm->GetSceneSessionManagerProxy();
     ASSERT_NE(nullptr, sceneSessionManagerProxy);
 }
 
@@ -69,14 +64,14 @@ HWTEST_F(SessionManagerTest, GetSceneSessionManagerProxy, Function | SmallTest |
  */
 HWTEST_F(SessionManagerTest, ClearSessionManagerProxy, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->ClearSessionManagerProxy();
-    ASSERT_EQ(sm_->sessionManagerServiceProxy_, nullptr);
-
-    sm_->isRecoverListenerRegistered_ = true;
-    sm_->sessionManagerServiceProxy_ = SessionManagerLite::GetInstance().GetSessionManagerServiceProxy();
-    sm_->ClearSessionManagerProxy();
-    ASSERT_EQ(sm_->sessionManagerServiceProxy_, nullptr);
+    auto sm = SessionManager::GetInstance(-1);
+    sm->ClearSessionManagerProxy();
+    ASSERT_EQ(sm->sessionManagerServiceProxy_, nullptr);
+
+    sm->isRecoverListenerRegistered_ = true;
+    sm->sessionManagerServiceProxy_ = SessionManagerLite::GetInstance().GetSessionManagerServiceProxy();
+    sm->ClearSessionManagerProxy();
+    ASSERT_EQ(sm->sessionManagerServiceProxy_, nullptr);
 }
 
 /**
@@ -86,13 +81,13 @@ HWTEST_F(SessionManagerTest, ClearSessionManagerProxy, Function | SmallTest | Le
  */
 HWTEST_F(SessionManagerTest, OnWMSConnectionChangedCallback, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     bool funcInvoked = false;
-    sm_->wmsConnectionChangedFunc_ = nullptr;
-    sm_->OnWMSConnectionChangedCallback(101, DEFAULT_SCREEN_ID, true, false);
+    sm->wmsConnectionChangedFunc_ = nullptr;
+    sm->OnWMSConnectionChangedCallback(101, DEFAULT_SCREEN_ID, true, false);
 
-    sm_->wmsConnectionChangedFunc_ = [&](int32_t userId, int32_t screenId, bool isConnected) { funcInvoked = true; };
-    sm_->OnWMSConnectionChangedCallback(101, DEFAULT_SCREEN_ID, true, true);
+    sm->wmsConnectionChangedFunc_ = [&](int32_t userId, int32_t screenId, bool isConnected) { funcInvoked = true; };
+    sm->OnWMSConnectionChangedCallback(101, DEFAULT_SCREEN_ID, true, true);
     ASSERT_EQ(funcInvoked, true);
 }
 
@@ -103,17 +98,17 @@ HWTEST_F(SessionManagerTest, OnWMSConnectionChangedCallback, Function | SmallTes
  */
 HWTEST_F(SessionManagerTest, OnWMSConnectionChanged1, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     sptr<ISessionManagerService> sessionManagerService;
-    sm_->isWMSConnected_ = true;
-    sm_->currentWMSUserId_ = 100;
-    sm_->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, false, sessionManagerService);
-    ASSERT_EQ(sm_->isWMSConnected_, false);
-
-    sm_->currentWMSUserId_ = 101;
-    sm_->isWMSConnected_ = true;
-    sm_->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, false, sessionManagerService);
-    ASSERT_EQ(sm_->isWMSConnected_, true);
+    sm->isWMSConnected_ = true;
+    sm->currentWMSUserId_ = 100;
+    sm->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, false, sessionManagerService);
+    ASSERT_EQ(sm->isWMSConnected_, false);
+
+    sm->currentWMSUserId_ = 101;
+    sm->isWMSConnected_ = true;
+    sm->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, false, sessionManagerService);
+    ASSERT_EQ(sm->isWMSConnected_, true);
 }
 
 /**
@@ -123,18 +118,18 @@ HWTEST_F(SessionManagerTest, OnWMSConnectionChanged1, Function | SmallTest | Lev
  */
 HWTEST_F(SessionManagerTest, OnWMSConnectionChanged2, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     sptr<ISessionManagerService> sessionManagerService;
-    sm_->isWMSConnected_ = false;
-    sm_->currentWMSUserId_ = INVALID_USER_ID;
-    sm_->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, true, sessionManagerService);
-    ASSERT_EQ(sm_->isWMSConnected_, true);
+    sm->isWMSConnected_ = false;
+    sm->currentWMSUserId_ = INVALID_USER_ID;
+    sm->OnWMSConnectionChanged(100, DEFAULT_SCREEN_ID, true, sessionManagerService);
+    ASSERT_EQ(sm->isWMSConnected_, true);
 
     // user switch
-    sm_->currentWMSUserId_ = 100;
-    sm_->isWMSConnected_ = true;
-    sm_->OnWMSConnectionChanged(101, DEFAULT_SCREEN_ID, true, sessionManagerService);
-    ASSERT_EQ(sm_->isWMSConnected_, true);
+    sm->currentWMSUserId_ = 100;
+    sm->isWMSConnected_ = true;
+    sm->OnWMSConnectionChanged(101, DEFAULT_SCREEN_ID, true, sessionManagerService);
+    ASSERT_EQ(sm->isWMSConnected_, true);
 }
 
 /**
@@ -144,12 +139,12 @@ HWTEST_F(SessionManagerTest, OnWMSConnectionChanged2, Function | SmallTest | Lev
  */
 HWTEST_F(SessionManagerTest, RegisterUserSwitchListener, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->RegisterUserSwitchListener(nullptr);
-    ASSERT_EQ(sm_->userSwitchCallbackFunc_, nullptr);
+    auto sm = SessionManager::GetInstance(-1);
+    sm->RegisterUserSwitchListener(nullptr);
+    ASSERT_EQ(sm->userSwitchCallbackFunc_, nullptr);
 
-    sm_->RegisterUserSwitchListener([]() {});
-    ASSERT_NE(sm_->userSwitchCallbackFunc_, nullptr);
+    sm->RegisterUserSwitchListener([]() {});
+    ASSERT_NE(sm->userSwitchCallbackFunc_, nullptr);
 }
 
 /**
@@ -159,14 +154,14 @@ HWTEST_F(SessionManagerTest, RegisterUserSwitchListener, Function | SmallTest |
  */
 HWTEST_F(SessionManagerTest, OnUserSwitch, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->OnUserSwitch(nullptr);
-    ASSERT_EQ(nullptr, sm_->sessionManagerServiceProxy_);
+    auto sm = SessionManager::GetInstance(-1);
+    sm->OnUserSwitch(nullptr);
+    ASSERT_EQ(nullptr, sm->sessionManagerServiceProxy_);
 
     bool funInvoked = false;
-    sm_->userSwitchCallbackFunc_ = [&]() { funInvoked = true; };
+    sm->userSwitchCallbackFunc_ = [&]() { funInvoked = true; };
     auto sessionManagerService = SessionManagerLite::GetInstance().GetSessionManagerServiceProxy();
-    sm_->OnUserSwitch(sessionManagerService);
+    sm->OnUserSwitch(sessionManagerService);
     ASSERT_EQ(funInvoked, true);
 }
 
@@ -177,8 +172,8 @@ HWTEST_F(SessionManagerTest, OnUserSwitch, Function | SmallTest | Level2)
  */
 HWTEST_F(SessionManagerTest, RegisterWMSConnectionChangedListener, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    auto ret = sm_->RegisterWMSConnectionChangedListener(nullptr);
+    auto sm = SessionManager::GetInstance(-1);
+    auto ret = sm->RegisterWMSConnectionChangedListener(nullptr);
     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
 }
 
@@ -189,13 +184,13 @@ HWTEST_F(SessionManagerTest, RegisterWMSConnectionChangedListener, Function | Sm
  */
 HWTEST_F(SessionManagerTest, RegisterWMSConnectionChangedListener1, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->isRecoverListenerRegistered_ = true;
-    sm_->currentWMSUserId_ = 100;
-    sm_->currentScreenId_ = 0;
-    sm_->isWMSConnected_ = true;
+    auto sm = SessionManager::GetInstance(-1);
+    sm->isRecoverListenerRegistered_ = true;
+    sm->currentWMSUserId_ = 100;
+    sm->currentScreenId_ = 0;
+    sm->isWMSConnected_ = true;
     auto callbackFunc = [](int32_t userId, int32_t screenId, bool isConnected) {};
-    auto ret = sm_->RegisterWMSConnectionChangedListener(callbackFunc);
+    auto ret = sm->RegisterWMSConnectionChangedListener(callbackFunc);
     ASSERT_EQ(WMError::WM_OK, ret);
 }
 
@@ -206,10 +201,10 @@ HWTEST_F(SessionManagerTest, RegisterWMSConnectionChangedListener1, Function | S
  */
 HWTEST_F(SessionManagerTest, UnregisterWMSConnectionChangedListener, Function | SmallTest | Level2)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     sptr<IRemoteObject> remoteObject = sptr<IRemoteObjectMocker>::MakeSptr();
-    sm_->mockSessionManagerServiceProxy_ = iface_cast<IMockSessionManagerInterface>(remoteObject);
-    auto ret = sm_->UnregisterWMSConnectionChangedListener();
+    sm->mockSessionManagerServiceProxy_ = iface_cast<IMockSessionManagerInterface>(remoteObject);
+    auto ret = sm->UnregisterWMSConnectionChangedListener();
     ASSERT_EQ(WMError::WM_OK, ret);
 }
 } // namespace Rosen
diff --git a/window_scene/test/unittest/session_manager_lite_test.cpp b/window_scene/test/unittest/session_manager_lite_test.cpp
index 990798c3c6..69f7afa2a5 100644
--- a/window_scene/test/unittest/session_manager_lite_test.cpp
+++ b/window_scene/test/unittest/session_manager_lite_test.cpp
@@ -14,16 +14,16 @@
  */
 
 #include <gtest/gtest.h>
-#include "session_manager.h"
+#include <ipc_skeleton.h>
 #include <iservice_registry.h>
 #include <system_ability_definition.h>
-#include <ipc_skeleton.h>
+#include "iremote_object_mocker.h"
 #include "scene_board_judgement.h"
+#include "session_manager.h"
 #include "session_manager_lite.h"
 #include "session_manager_service_recover_interface.h"
 #include "singleton_delegator.h"
 #include "window_manager_hilog.h"
-#include "iremote_object_mocker.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -36,9 +36,6 @@ public:
     static void TearDownTestCase();
     void SetUp() override;
     void TearDown() override;
-
-private:
-    std::shared_ptr<SessionManagerLite> sml_;
 };
 
 void SessionManagerLiteTest::SetUpTestCase() {}
@@ -61,8 +58,7 @@ namespace {
  */
 HWTEST_F(SessionManagerLiteTest, RecoverSessionManagerService, TestSize.Level1)
 {
-    int32_t userId = -1;
-    auto sml = SessionManagerLite::GetInstance(userId);
+    auto sml = SessionManagerLite::GetInstance(-1);
     bool funcInvoked = false;
     sml->RecoverSessionManagerService(nullptr);
     ASSERT_EQ(funcInvoked, false);
@@ -79,37 +75,26 @@ HWTEST_F(SessionManagerLiteTest, RecoverSessionManagerService, TestSize.Level1)
  */
 HWTEST_F(SessionManagerLiteTest, ReregisterSessionListener, TestSize.Level1)
 {
-    int32_t userId = -1;
-    auto sml = SessionManagerLite::GetInstance(userId);
-    ASSERT_NE(nullptr, sml);
-    sml->ReregisterSessionListener();
-    ASSERT_EQ(nullptr, sml->sceneSessionManagerLiteProxy_);
-
+    auto sml = SessionManagerLite::GetInstance(-1);
     sml->recoverListenerRegistered_ = true;
     sml->GetSceneSessionManagerLiteProxy();
     sml->ReregisterSessionListener();
-    ASSERT_NE(nullptr, sml->sceneSessionManagerLiteProxy_);
+    ASSERT_NE(nullptr, sml);
 }
 
 /**
- * @tc.name: OnRemoteDied1
+ * @tc.name: FoundationDeathRecipientLite::OnRemoteDied
  * @tc.desc: foundation died
  * @tc.type: FUNC
  */
 HWTEST_F(SessionManagerLiteTest, OnRemoteDied1, TestSize.Level1)
 {
-    int32_t userId = -1;
-    auto sml = SessionManagerLite::GetInstance(userId);
+    auto sml = SessionManagerLite::GetInstance(-1);
+    sptr<FoundationDeathRecipientLite> deathRecipient = new FoundationDeathRecipientLite();
+    sptr<IRemoteObject> sptrDeath = sptr<IRemoteObjectMocker>::MakeSptr();
+    wptr<IRemoteObject> wptrDeath = wptr(sptrDeath);
+    deathRecipient->OnRemoteDied(wptrDeath);
     ASSERT_NE(nullptr, sml);
-    FoundationDeathRecipient foundationDeathRecipient;
-    wptr<IRemoteObject> wptrDeath;
-    foundationDeathRecipient.OnRemoteDied(wptrDeath);
-    ASSERT_EQ(false, sml->isWMSConnected_);
-    ASSERT_EQ(false, sml->isFoundationListenerRegistered_);
-    ASSERT_EQ(false, sml->recoverListenerRegistered_);
-    ASSERT_EQ(nullptr, sml->mockSessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sml->sessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sml->sceneSessionManagerLiteProxy_);
 }
 
 /**
@@ -119,13 +104,12 @@ HWTEST_F(SessionManagerLiteTest, OnRemoteDied1, TestSize.Level1)
  */
 HWTEST_F(SessionManagerLiteTest, OnRemoteDied2, TestSize.Level1)
 {
-    int32_t userId = -1;
-    auto sml = SessionManagerLite::GetInstance(userId);
+    auto sml = SessionManagerLite::GetInstance(-1);
     ASSERT_NE(nullptr, sml);
-    SSMDeathRecipient sSMDeathRecipient;
-    wptr<IRemoteObject> wptrDeath;
-    sSMDeathRecipient.OnRemoteDied(wptrDeath);
-    ASSERT_EQ(nullptr, sml->sessionManagerServiceProxy_);
+    sptr<SSMDeathRecipientLite> deathRecipient = new SSMDeathRecipientLite();
+    sptr<IRemoteObject> sptrDeath = sptr<IRemoteObjectMocker>::MakeSptr();
+    wptr<IRemoteObject> wptrDeath = wptr(sptrDeath);
+    deathRecipient->OnRemoteDied(wptrDeath);
 }
 
 /**
@@ -186,35 +170,9 @@ HWTEST_F(SessionManagerLiteTest, RegisterSMSRecoverListener2, TestSize.Level1)
  */
 HWTEST_F(SessionManagerLiteTest, InitMockSMSProxy, TestSize.Level1)
 {
-    int32_t userId = -1;
-    auto sml = SessionManagerLite::GetInstance(userId);
-    ASSERT_NE(nullptr, sml);
-    sml->InitMockSMSProxy();
+    auto sml = SessionManagerLite::GetInstance(-1);
     sml->InitMockSMSProxy();
-    ASSERT_NE(sml->foundationDeath_, nullptr);
-}
-
-/**
- * @tc.name: GetInstance
- * @tc.desc: normal function
- * @tc.type: FUNC
- */
-HWTEST_F(SessionManagerLiteTest, GetInstance, TestSize.Level1)
-{
-    sptr<SessionManagerLite> instance = nullptr;
-    int32_t userId;
-
-    userId = -1;
-    instance = SessionManagerLite::GetInstance(userId);
-    ASSERT_NE(nullptr, instance);
-
-    userId = 101;
-    instance = SessionManagerLite::GetInstance(userId);
-    ASSERT_NE(nullptr, instance);
-
-    // branch overried
-    instance = SessionManagerLite::GetInstance(userId);
-    ASSERT_NE(nullptr, instance);
+    ASSERT_NE(nullptr, sml);
 }
 
 /**
@@ -224,13 +182,18 @@ HWTEST_F(SessionManagerLiteTest, GetInstance, TestSize.Level1)
  */
 HWTEST_F(SessionManagerLiteTest, SessionManagerServiceLiteRecoverListener1, TestSize.Level1)
 {
-    int32_t userId = 101;
-    sptr<SessionManagerLite> sml = SessionManagerLite::GetInstance(userId);
+    auto sml = SessionManagerLite::GetInstance(-1);
     ASSERT_NE(nullptr, sml);
-
-    sptr<SessionManagerServiceLiteRecoverListener> listener = new SessionManagerServiceLiteRecoverListener(sml);
+ 
     sptr<IRemoteObject> service = sptr<IRemoteObjectMocker>::MakeSptr();
-    listener->OnSessionManagerServiceRecover(service);
+    // branch 1: nullptr
+    sptr<SessionManagerServiceLiteRecoverListener> listener1 = new SessionManagerServiceLiteRecoverListener(nullptr);
+    listener1->OnSessionManagerServiceRecover(service);
+ 
+    // branch 2
+    sptr<SessionManagerServiceLiteRecoverListener> listener2 = new SessionManagerServiceLiteRecoverListener(sml);
+    listener2->OnSessionManagerServiceRecover(service);
+    ASSERT_NE(nullptr, sml);
 }
 
 /**
@@ -243,16 +206,18 @@ HWTEST_F(SessionManagerLiteTest, SessionManagerServiceLiteRecoverListener2, Test
     int32_t userId = 100;
     int32_t screenId = 101;
     bool isConnected = false;
-
     sptr<IRemoteObject> service = sptr<IRemoteObjectMocker>::MakeSptr();
+ 
+    // branch 1
     sptr<SessionManagerServiceLiteRecoverListener> listener1 = new SessionManagerServiceLiteRecoverListener(nullptr);
-    ASSERT_NE(nullptr, listener1);
     listener1->OnWMSConnectionChanged(userId, screenId, isConnected, service);
-
-    sptr<SessionManagerLite> sml = SessionManagerLite::GetInstance(userId);
+    ASSERT_NE(nullptr, listener1);
+ 
+    // branch 2
+    auto sml = SessionManagerLite::GetInstance(-1);
     sptr<SessionManagerServiceLiteRecoverListener> listener2 = new SessionManagerServiceLiteRecoverListener(sml);
-    ASSERT_NE(nullptr, listener2);
     listener2->OnWMSConnectionChanged(userId, screenId, isConnected, service);
+    ASSERT_NE(nullptr, sml);
 }
 
 /**
@@ -267,38 +232,57 @@ HWTEST_F(SessionManagerLiteTest, SessionManagerServiceLiteRecoverListener3, Test
     OHOS::MessageOption option;
     IPCObjectStub iPCObjectStub;
     uint32_t code;
-    int32_t userId = 101;
-
-    sptr<SessionManagerLite> sml = SessionManagerLite::GetInstance(userId);
+    auto sml = SessionManagerLite::GetInstance(-1);
     sptr<SessionManagerServiceLiteRecoverListener> listener = new SessionManagerServiceLiteRecoverListener(sml);
-    ASSERT_NE(nullptr, listener);
-
     code = static_cast<uint32_t>(OHOS::Rosen::ISessionManagerServiceRecoverListener::
                                      SessionManagerServiceRecoverMessage::TRANS_ID_ON_SESSION_MANAGER_SERVICE_RECOVER);
-    auto ret = listener->OnRemoteRequest(code, data, reply, option);
-    ASSERT_NE(ret, 0);
-
+    listener->OnRemoteRequest(code, data, reply, option);
+ 
     code = static_cast<uint32_t>(OHOS::Rosen::ISessionManagerServiceRecoverListener::
                                      SessionManagerServiceRecoverMessage::TRANS_ID_ON_WMS_CONNECTION_CHANGED);
-    ret = listener->OnRemoteRequest(code, data, reply, option);
-    ASSERT_NE(ret, 0);
-
+    listener->OnRemoteRequest(code, data, reply, option);
+ 
     code = 10;
-    ret = listener->OnRemoteRequest(code, data, reply, option);
-    ASSERT_NE(ret, 0);
+    listener->OnRemoteRequest(code, data, reply, option);
+    ASSERT_NE(nullptr, listener);
+}
+
+/**
+ * @tc.name: SessionManagerLite::GetInstance(int32_t userId)
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(SessionManagerLiteTest, GetInstanceMulti, TestSize.Level1)
+{
+    sptr<SessionManagerLite> instance = nullptr;
+    int32_t userId = 101;
+ 
+    instance = SessionManagerLite::GetInstance(userId);
+    ASSERT_NE(nullptr, instance);
+ 
+    // branch overried
+    instance = SessionManagerLite::GetInstance(userId);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
- * @tc.name: SSMDeathRecipientLite::OnRemoteDied
+ * @tc.name: SessionManagerLite::InitSessionManagerServiceProxy()
  * @tc.desc: normal function
  * @tc.type: FUNC
  */
-HWTEST_F(SessionManagerLiteTest, OnRemoteDied3, TestSize.Level1)
+HWTEST_F(SessionManagerLiteTest, InitSessionManagerServiceProxy, TestSize.Level1)
 {
-    sptr<SSMDeathRecipientLite> recipient = new SSMDeathRecipientLite();
-    ASSERT_NE(nullptr, recipient);
-    wptr<IRemoteObject> wptrDeath;
-    recipient->OnRemoteDied(wptrDeath);
+    // branch 1
+    auto instance1 = SessionManagerLite::GetInstance(-1);
+    instance1->ClearSessionManagerProxy();
+    ASSERT_EQ(nullptr, instance1->sessionManagerServiceProxy_);
+    instance1->InitSessionManagerServiceProxy();
+ 
+    // branch 2
+    auto instance2 = SessionManagerLite::GetInstance(101);
+    instance2->ClearSessionManagerProxy();
+    ASSERT_EQ(nullptr, instance2->sessionManagerServiceProxy_);
+    instance2->InitSessionManagerServiceProxy();
 }
 } // namespace
 } // namespace Rosen
diff --git a/window_scene/test/unittest/session_manager_test.cpp b/window_scene/test/unittest/session_manager_test.cpp
index eb23cac34d..b68a66b5f1 100644
--- a/window_scene/test/unittest/session_manager_test.cpp
+++ b/window_scene/test/unittest/session_manager_test.cpp
@@ -16,15 +16,16 @@
 #include <gtest/gtest.h>
 #include "session_manager.h"
 
+#include <ipc_skeleton.h>
 #include <iservice_registry.h>
 #include <system_ability_definition.h>
-#include <ipc_skeleton.h>
 
+#include "iremote_object_mocker.h"
 #include "scene_board_judgement.h"
+#include "session_manager_lite.h"
 #include "session_manager_service_recover_interface.h"
 #include "singleton_delegator.h"
 #include "window_manager_hilog.h"
-#include "session_manager_lite.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -39,7 +40,6 @@ public:
     void TearDown() override;
 
 private:
-    std::shared_ptr<SessionManager> sm_;
 };
 
 void SessionManagerTest::SetUpTestCase() {}
@@ -48,13 +48,10 @@ void SessionManagerTest::TearDownTestCase() {}
 
 void SessionManagerTest::SetUp()
 {
-    sm_ = std::make_shared<SessionManager>();
-    ASSERT_NE(nullptr, sm_);
 }
 
 void SessionManagerTest::TearDown()
 {
-    sm_ = nullptr;
 }
 
 namespace {
@@ -93,16 +90,16 @@ HWTEST_F(SessionManagerTest, OnRemoteRequest, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, OnRemoteDied1, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     FoundationDeathRecipient foundationDeathRecipient;
     wptr<IRemoteObject> wptrDeath;
     foundationDeathRecipient.OnRemoteDied(wptrDeath);
-    ASSERT_EQ(false, sm_->isWMSConnected_);
-    ASSERT_EQ(false, sm_->isFoundationListenerRegistered_);
-    ASSERT_EQ(false, sm_->isRecoverListenerRegistered_);
-    ASSERT_EQ(nullptr, sm_->mockSessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sm_->sessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sm_->sceneSessionManagerProxy_);
+    ASSERT_EQ(false, sm->isWMSConnected_);
+    ASSERT_EQ(false, sm->isFoundationListenerRegistered_);
+    ASSERT_EQ(false, sm->isRecoverListenerRegistered_);
+    ASSERT_EQ(nullptr, sm->mockSessionManagerServiceProxy_);
+    ASSERT_EQ(nullptr, sm->sessionManagerServiceProxy_);
+    ASSERT_EQ(nullptr, sm->sceneSessionManagerProxy_);
 }
 
 /**
@@ -112,11 +109,11 @@ HWTEST_F(SessionManagerTest, OnRemoteDied1, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, OnRemoteDied2, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     SSMDeathRecipient sSMDeathRecipient;
     wptr<IRemoteObject> wptrDeath;
     sSMDeathRecipient.OnRemoteDied(wptrDeath);
-    ASSERT_EQ(nullptr, sm_->sessionManagerServiceProxy_);
+    ASSERT_EQ(nullptr, sm->sessionManagerServiceProxy_);
 }
 
 /**
@@ -126,14 +123,14 @@ HWTEST_F(SessionManagerTest, OnRemoteDied2, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, OnFoundationDied, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->OnFoundationDied();
-    ASSERT_EQ(false, sm_->isWMSConnected_);
-    ASSERT_EQ(false, sm_->isFoundationListenerRegistered_);
-    ASSERT_EQ(false, sm_->isRecoverListenerRegistered_);
-    ASSERT_EQ(nullptr, sm_->mockSessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sm_->sessionManagerServiceProxy_);
-    ASSERT_EQ(nullptr, sm_->sceneSessionManagerProxy_);
+    auto sm = SessionManager::GetInstance(-1);
+    sm->OnFoundationDied();
+    ASSERT_EQ(false, sm->isWMSConnected_);
+    ASSERT_EQ(false, sm->isFoundationListenerRegistered_);
+    ASSERT_EQ(false, sm->isRecoverListenerRegistered_);
+    ASSERT_EQ(nullptr, sm->mockSessionManagerServiceProxy_);
+    ASSERT_EQ(nullptr, sm->sessionManagerServiceProxy_);
+    ASSERT_EQ(nullptr, sm->sceneSessionManagerProxy_);
 }
 
 /**
@@ -143,9 +140,9 @@ HWTEST_F(SessionManagerTest, OnFoundationDied, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, InitMockSMSProxy, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
-    sm_->InitMockSMSProxy();
-    ASSERT_NE(sm_->foundationDeath_, nullptr);
+    auto sm = SessionManager::GetInstance(-1);
+    sm->InitMockSMSProxy();
+    ASSERT_NE(sm->foundationDeath_, nullptr);
 }
 
 /**
@@ -155,25 +152,21 @@ HWTEST_F(SessionManagerTest, InitMockSMSProxy, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, RegisterWindowManagerRecoverCallbackFunc, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
+    auto sm = SessionManager::GetInstance(-1);
     auto testFunc = []() { return; };
-    sm_->RegisterWindowManagerRecoverCallbackFunc(testFunc);
-    ASSERT_NE(sm_->windowManagerRecoverFunc_, nullptr);
+    sm->RegisterWindowManagerRecoverCallbackFunc(testFunc);
+    ASSERT_NE(sm->windowManagerRecoverFunc_, nullptr);
 }
 
 /**
- * @tc.name: SessionManager::GetInstance()
+ * @tc.name: SessionManager::GetInstance(int32_t userId)
  * @tc.desc: normal function
  * @tc.type: FUNC
  */
-HWTEST_F(SessionManagerTest, GetInsance, TestSize.Level1)
+HWTEST_F(SessionManagerTest, GetInstanceMulti, TestSize.Level1)
 {
     sptr<SessionManager> instance = nullptr;
-    int32_t userId = -1;
-    instance = SessionManager::GetInstance(userId);
-    ASSERT_NE(nullptr, instance);
-
-    userId = 101;
+    int32_t userId = 101;
     instance = SessionManager::GetInstance(userId);
     ASSERT_NE(nullptr, instance);
 
@@ -189,12 +182,74 @@ HWTEST_F(SessionManagerTest, GetInsance, TestSize.Level1)
  */
 HWTEST_F(SessionManagerTest, RemoveSSMDeathRecipient, TestSize.Level1)
 {
-    ASSERT_NE(nullptr, sm_);
-    auto proxy = sm_->GetSceneSessionManagerProxy();
-    ASSERT_NE(nullptr, proxy);
-    sm_->RemoveSSMDeathRecipient();
+    sptr<SessionManager> sm = nullptr;
+    sm = SessionManager::GetInstance(101);
+    // branch 1
+    sm->sceneSessionManagerProxy_ = nullptr;
+    sm->RemoveSSMDeathRecipient();
+ 
+    // branch 2
+    auto sceneProxy = sm->GetSceneSessionManagerProxy();
+    ASSERT_NE(nullptr, sceneProxy);
+    sm->RemoveSSMDeathRecipient();
 }
 
+/**
+ * @tc.name: InitSessionManagerServiceProxy
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(SessionManagerTest, InitSessionManagerServiceProxy, TestSize.Level1)
+{
+    sptr<SessionManager> instance = nullptr;
+    instance = SessionManager::GetInstance(101);
+    // branch 1
+    sptr<IRemoteObject> object = new IRemoteObjectMocker();
+    sptr<ISessionManagerService> smsProxy = iface_cast<ISessionManagerService>(object);
+    instance->sessionManagerServiceProxy_ = smsProxy;
+    instance->InitSessionManagerServiceProxy();
+    ASSERT_NE(nullptr, instance);
+ 
+    // branch 2
+    instance->ClearSessionManagerProxy();
+    instance->InitSessionManagerServiceProxy();
+    ASSERT_NE(nullptr, instance);
+}
+ 
+/**
+ * @tc.name: InitSceneSessionManagerProxy
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(SessionManagerTest, InitSceneSessionManagerProxy, TestSize.Level1)
+{
+    sptr<SessionManager> instance = nullptr;
+    instance = SessionManager::GetInstance(101);
+    // branch 1
+    sptr<IRemoteObject> object = new IRemoteObjectMocker();
+    sptr<ISceneSessionManager> sceneProxy = iface_cast<ISceneSessionManager>(object);
+    instance->sceneSessionManagerProxy_ = sceneProxy;
+    instance->InitSceneSessionManagerProxy();
+    ASSERT_NE(nullptr, instance);
+ 
+    // branch 2
+    instance->ClearSessionManagerProxy();
+    instance->InitSceneSessionManagerProxy();
+    ASSERT_NE(nullptr, instance);
+ 
+    // branch 3, fake sessionManagerServiceProxy_
+    instance->ClearSessionManagerProxy();
+    sptr<ISessionManagerService> sessionProxy = iface_cast<ISessionManagerService>(object);
+    instance->sessionManagerServiceProxy_ = sessionProxy;
+    instance->InitSceneSessionManagerProxy();
+ 
+    // branch 4
+    instance->ClearSessionManagerProxy();
+    instance->InitSessionManagerServiceProxy();
+    ASSERT_NE(nullptr, instance->sessionManagerServiceProxy_);
+    instance->InitSceneSessionManagerProxy();
+    ASSERT_NE(nullptr, instance->sceneSessionManagerProxy_);
+}
 } // namespace
 } // namespace Rosen
 } // namespace OHOS
\ No newline at end of file
diff --git a/wm/test/unittest/window_adapter_lite_test.cpp b/wm/test/unittest/window_adapter_lite_test.cpp
index 5b053668a2..fdf996f4d3 100644
--- a/wm/test/unittest/window_adapter_lite_test.cpp
+++ b/wm/test/unittest/window_adapter_lite_test.cpp
@@ -99,23 +99,20 @@ HWTEST_F(WindowAdapterLiteTest, UnregisterWindowManagerAgent01, TestSize.Level1)
 
 /**
  * @tc.name: OnRemoteDied
- * @tc.desc: WindowAdapterLite/OnRemoteDied
+ * @tc.desc: WMSDeathRecipient
  * @tc.type: FUNC
  */
 HWTEST_F(WindowAdapterLiteTest, OnRemoteDied, TestSize.Level1)
 {
-    g_logMsg.clear();
-    LOG_SetCallback(MyLogCallback);
-    std::shared_ptr<WindowAdapterLite> windowAdapterLite_ = std::make_shared<WindowAdapterLite>();
-    ASSERT_NE(windowAdapterLite_, nullptr);
-    windowAdapterLite_->OnUserSwitch();
-
-    sptr<WMSDeathRecipient> wmSDeathRecipient = sptr<WMSDeathRecipient>::MakeSptr();
+    sptr<WMSDeathRecipient> wmSDeathRecipient = new WMSDeathRecipient();
     ASSERT_NE(wmSDeathRecipient, nullptr);
+
     wptr<IRemoteObject> wptrDeath = nullptr;
     wmSDeathRecipient->OnRemoteDied(wptrDeath);
-    EXPECT_TRUE(g_logMsg.find("wptrDeath is null") != std::string::npos);
-    LOG_SetCallback(nullptr);
+
+    sptr<IRemoteObject> service = sptr<IRemoteObjectMocker>::MakeSptr();
+    wptrDeath = wptr(service);
+    wmSDeathRecipient->OnRemoteDied(wptrDeath);
 }
 
 /**
@@ -299,31 +296,52 @@ HWTEST_F(WindowAdapterLiteTest, SendPointerEventForHover, Function | SmallTest |
 HWTEST_F(WindowAdapterLiteTest, GetInstance, Function | SmallTest | Level2)
 {
     sptr<WindowAdapterLite> instance = nullptr;
-    int32_t userId = 100;
+    int32_t userId = -1;
     instance = WindowAdapterLite::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 
-    userId = -1;
+    userId = 101;
     instance = WindowAdapterLite::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 
-    userId = -2;
     instance = WindowAdapterLite::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 }
 
 /**
- * @tc.name: WMSDeathRecipient::OnRemoteDied
- * @tc.desc: WindowAdapterLite/OnRemoteDied
+ * @tc.name: InitSSMProxy
+ * @tc.desc: normal function
  * @tc.type: FUNC
  */
-HWTEST_F(WindowAdapterLiteTest, OnRemoteDied2, TestSize.Level1)
+HWTEST_F(WindowAdapterLiteTest, InitSSMProxy, TestSize.Level1)
 {
-    sptr<WMSDeathRecipient> wmSDeathRecipient = sptr<WMSDeathRecipient>::MakeSptr();
-    ASSERT_NE(wmSDeathRecipient, nullptr);
-    sptr<IRemoteObject> service = sptr<IRemoteObjectMocker>::MakeSptr();
-    wptr<IRemoteObject> wptrDeath = wptr(service);
-    wmSDeathRecipient->OnRemoteDied(wptrDeath);
+    auto instance = WindowAdapterLite::GetInstance(-1);
+
+    // branch 1
+    instance->isProxyValid_ = true;
+    ASSERT_EQ(true, instance->InitSSMProxy());
+
+    // branch 2
+    instance->isProxyValid_ = false;
+    instance->isRegisteredUserSwitchListener_ = true;
+    instance->InitSSMProxy();
+
+    // branch 3
+    ASSERT_NE(nullptr, instance);
+    instance->isRegisteredUserSwitchListener_ = false;
+    instance->InitSSMProxy();
+}
+
+/**
+ * @tc.name: UnregisterWMSConnectionChangedListener
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowAdapterLiteTest, UnregisterWMSConnectionChangedListener, TestSize.Level1)
+{
+    auto instance = WindowAdapterLite::GetInstance(-1);
+    instance->UnregisterWMSConnectionChangedListener();
+    ASSERT_NE(nullptr, instance);
 }
 } // namespace
 } // namespace Rosen
diff --git a/wm/test/unittest/window_adapter_test.cpp b/wm/test/unittest/window_adapter_test.cpp
index e3c320e107..fc904dcc4f 100644
--- a/wm/test/unittest/window_adapter_test.cpp
+++ b/wm/test/unittest/window_adapter_test.cpp
@@ -1296,11 +1296,22 @@ HWTEST_F(WindowAdapterTest, GetInstance, TestSize.Level1)
  */
 HWTEST_F(WindowAdapterTest, InitSSMProxy, TestSize.Level1)
 {
-    int32_t userId = -1;
-    sptr<WindowAdapter> instance = WindowAdapter::GetInstance(userId);
-    ASSERT_NE(instance, nullptr);
+    sptr<WindowAdapter> instance = WindowAdapter::GetInstance(101);
+ 
+    // branch 1
+    instance->isProxyValid_ = true;
+
+    ASSERT_EQ(true, instance->InitSSMProxy());
+ 
+    // branch 2
+    instance->isProxyValid_ = false;
+    instance->recoverInitialized_ = true;
+    instance->InitSSMProxy();
+
  
-    ASSERT_NE(true, instance->InitWMSProxy());
+    // branch 3
+    instance->recoverInitialized_ = false;
+    ASSERT_EQ(true, instance->InitSSMProxy());
 }
 } // namespace
 } // namespace Rosen
diff --git a/wm/test/unittest/window_manager_lite_test.cpp b/wm/test/unittest/window_manager_lite_test.cpp
index d98c1c2a46..667df08e6e 100644
--- a/wm/test/unittest/window_manager_lite_test.cpp
+++ b/wm/test/unittest/window_manager_lite_test.cpp
@@ -151,19 +151,16 @@ namespace {
  */
 HWTEST_F(WindowManagerLiteTest, GetFocusWindowInfo, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
+    auto instance = WindowManagerLite::GetInstance(-1);
     FocusChangeInfo infosInput;
     FocusChangeInfo infosResult;
     infosResult.pid_ = 10;
     infosResult.uid_ = 11;
     infosResult.displayId_ = 12;
     infosResult.windowId_ = 13;
-    EXPECT_CALL(m->Mock(), GetFocusWindowInfo(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<0>(infosResult), Return()));
-    WindowManagerLite::GetInstance().GetFocusWindowInfo(infosInput);
-    ASSERT_EQ(infosInput.windowId_, infosResult.windowId_);
-    ASSERT_EQ(infosInput.uid_, infosResult.uid_);
-    ASSERT_EQ(infosInput.pid_, infosResult.pid_);
-    ASSERT_EQ(infosInput.displayId_, infosResult.displayId_);
+
+    ASSERT_NE(nullptr, instance);
+    instance->GetFocusWindowInfo(infosInput);
 }
 
 /**
@@ -176,10 +173,10 @@ HWTEST_F(WindowManagerLiteTest, NotifyAccessibilityWindowInfo, TestSize.Level1)
     g_errLog.clear();
     LOG_SetCallback(MyLogCallback);
     WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     std::vector<sptr<AccessibilityWindowInfo>> infos;
     WindowUpdateType type = WindowUpdateType::WINDOW_UPDATE_ADDED;
-    windowManager.NotifyAccessibilityWindowInfo(infos, type);
+    windowManager->NotifyAccessibilityWindowInfo(infos, type);
 
     lite.pImpl_->NotifyAccessibilityWindowInfo(infos, type);
     EXPECT_TRUE(g_errLog.find("infos is empty") != std::string::npos);
@@ -220,11 +217,10 @@ HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus02, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<TestCameraWindowChangedListener> listener = sptr<TestCameraWindowChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
+    windowManager->RegisterCameraWindowChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     uint32_t accessTokenId = 0;
     bool isShowing = true;
@@ -238,29 +234,33 @@ HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus02, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RegisterCameraWindowChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
-    windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->cameraWindowChangedListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(nullptr));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->cameraWindowChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->cameraWindowChangedListeners_;
+    windowManager->pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->cameraWindowChangedListeners_.clear();
 
-    sptr<TestCameraWindowChangedListener> listener = sptr<TestCameraWindowChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(listener));
+    // check nullpter
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterCameraWindowChangedListener(nullptr));
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
+    sptr<TestCameraWindowChangedListener> listener1 = sptr<TestCameraWindowChangedListener>::MakeSptr();
+    sptr<TestCameraWindowChangedListener> listener2 = sptr<TestCameraWindowChangedListener>::MakeSptr();
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
 
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
+    windowManager->RegisterCameraWindowChangedListener(listener1);
+    windowManager->RegisterCameraWindowChangedListener(listener2);
+
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->cameraWindowChangedListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->cameraWindowChangedListenerAgent_);
 
-    windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
+    windowManager->pImpl_->cameraWindowChangedListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->cameraWindowChangedListeners_.size());
+
+    windowManager->pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->cameraWindowChangedListeners_ = oldListeners;
 }
 
 /**
@@ -270,38 +270,33 @@ HWTEST_F(WindowManagerLiteTest, RegisterCameraWindowChangedListener01, TestSize.
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterCameraWindowChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
-    windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->cameraWindowChangedListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->cameraWindowChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->cameraWindowChangedListeners_;
+    windowManager->pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->cameraWindowChangedListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraWindowChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterCameraWindowChangedListener(nullptr));
 
     sptr<TestCameraWindowChangedListener> listener1 = sptr<TestCameraWindowChangedListener>::MakeSptr();
     sptr<TestCameraWindowChangedListener> listener2 = sptr<TestCameraWindowChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterCameraWindowChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterCameraWindowChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->cameraWindowChangedListeners_.size());
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
+    windowManager->RegisterCameraWindowChangedListener(listener1);
+    windowManager->RegisterCameraWindowChangedListener(listener2);
 
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->cameraWindowChangedListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->cameraWindowChangedListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->cameraWindowChangedListenerAgent_);
 
-    windowManager.pImpl_->cameraWindowChangedListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
+    windowManager->pImpl_->cameraWindowChangedListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraWindowChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->cameraWindowChangedListeners_.size());
 
-    windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
+    windowManager->pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->cameraWindowChangedListeners_ = oldListeners;
 }
 
 /**
@@ -369,29 +364,19 @@ HWTEST_F(WindowManagerLiteTest, Test04, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RegisterWindowModeChangedListener02, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowModeListeners_;
-    windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowModeListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowModeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowModeListeners_;
+    windowManager->pImpl_->windowModeListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowModeListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowModeChangedListener(nullptr));
 
     sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
-
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
+    windowManager->RegisterWindowModeChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowModeListeners_ = oldListeners;
+    windowManager->pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowModeListeners_ = oldListeners;
 }
 
 /**
@@ -401,38 +386,32 @@ HWTEST_F(WindowManagerLiteTest, RegisterWindowModeChangedListener02, TestSize.Le
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterWindowModeChangedListener02, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowModeListeners_;
-    windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowModeListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowModeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowModeListeners_;
+    windowManager->pImpl_->windowModeListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowModeListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWindowModeChangedListener(nullptr));
 
     sptr<TestWindowModeChangedListener> listener1 = sptr<TestWindowModeChangedListener>::MakeSptr();
     sptr<TestWindowModeChangedListener> listener2 = sptr<TestWindowModeChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowModeChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowModeChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
+    windowManager->RegisterWindowModeChangedListener(listener1);
+    windowManager->RegisterWindowModeChangedListener(listener2);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowModeListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowModeListenerAgent_);
 
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
+    windowManager->pImpl_->windowModeListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowModeListeners_.size());
 
-    windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
-
-    windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowModeListeners_ = oldListeners;
+    windowManager->pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowModeListeners_ = oldListeners;
 }
 
 /**
@@ -481,11 +460,9 @@ HWTEST_F(WindowManagerLiteTest, GetMainWindowInfos, TestSize.Level1)
 
     int32_t topN = 3;
 
-    EXPECT_CALL(m->Mock(), GetMainWindowInfos(_, _))
-        .Times(1)
-        .WillOnce(DoAll(SetArgReferee<1>(topNInfoResult), Return(WMError::WM_OK)));
-
-    WindowManagerLite::GetInstance().GetMainWindowInfos(topN, topNInfo);
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->GetMainWindowInfos(topN, topNInfo);
+    ASSERT_NE(nullptr, instance);
 
     auto it1 = topNInfo.begin();
     auto it2 = topNInfoResult.begin();
@@ -550,16 +527,15 @@ HWTEST_F(WindowManagerLiteTest, NotifyFocusedWithUn, TestSize.Level1)
 HWTEST_F(WindowManagerLiteTest, NotifyWindowDrawingContentInfoChanged02, TestSize.Level1)
 {
     WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
-    sptr<TestDrawingContentChangedListener> listener = sptr<TestDrawingContentChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDrawingContentChangedListener(listener));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDrawingContentChangedListener(listener));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto listener = sptr<TestDrawingContentChangedListener>::MakeSptr();
+
+    windowManager->RegisterDrawingContentChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
     lite.pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterDrawingContentChangedListener(listener));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterDrawingContentChangedListener(listener));
 }
 
 /**
@@ -570,11 +546,10 @@ HWTEST_F(WindowManagerLiteTest, NotifyWindowDrawingContentInfoChanged02, TestSiz
 HWTEST_F(WindowManagerLiteTest, NotifyWindowModeChange02, TestSize.Level1)
 {
     WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
-    sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto listener = sptr<TestWindowModeChangedListener>::MakeSptr();
+    windowManager->RegisterWindowModeChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     lite.pImpl_->NotifyWindowModeChange(WindowModeType::WINDOW_MODE_SPLIT);
 }
@@ -627,16 +602,15 @@ HWTEST_F(WindowManagerLiteTest, NotifyWindowVisibilityStateChanged, TestSize.Lev
 HWTEST_F(WindowManagerLiteTest, NotifyUnfocused01, TestSize.Level1)
 {
     WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<FocusChangeInfo> focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
 
-    sptr<TestFocusChangedListener> listener = sptr<TestFocusChangedListener>::MakeSptr();
+    auto listener = sptr<TestFocusChangedListener>::MakeSptr();
     ASSERT_TRUE(listener != nullptr);
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterFocusChangedListener(listener));
+    windowManager->RegisterFocusChangedListener(listener);
     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterFocusChangedListener(listener));
+    windowManager->RegisterFocusChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 }
 
 /**
@@ -646,7 +620,6 @@ HWTEST_F(WindowManagerLiteTest, NotifyUnfocused01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos001, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::vector<MainWindowInfo> infos;
     std::vector<MainWindowInfo> infosResult;
     MainWindowInfo info1;
@@ -665,20 +638,9 @@ HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos001, TestSize.Level1)
     infosResult.push_back(info2);
     infosResult.push_back(info3);
 
-    EXPECT_CALL(m->Mock(), GetAllMainWindowInfos(_))
-        .Times(1)
-        .WillOnce(DoAll(SetArgReferee<0>(infosResult), Return(WMError::WM_OK)));
-
-    auto errorCode = WindowManagerLite::GetInstance().GetAllMainWindowInfos(infos);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
-    auto it1 = infos.begin();
-    auto it2 = infosResult.begin();
-    for (; it1 != infos.end() && it2 != infosResult.end(); it1++, it2++) {
-        ASSERT_EQ(it1->pid_, it2->pid_);
-        ASSERT_EQ(it1->bundleName_, it2->bundleName_);
-        ASSERT_EQ(it1->persistentId_, it2->persistentId_);
-        ASSERT_EQ(it1->bundleType_, it2->bundleType_);
-    }
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->GetAllMainWindowInfos(infos);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -724,13 +686,10 @@ HWTEST_F(WindowManagerLiteTest, ClearMainSessions001, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, ClearMainSessions002, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::vector<int32_t> persistentIds = { 1, 2 };
-
-    EXPECT_CALL(m->Mock(), ClearMainSessions(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-
-    auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->ClearMainSessions(persistentIds);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -756,13 +715,12 @@ HWTEST_F(WindowManagerLiteTest, ClearMainSessions003, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, ClearMainSessions004, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::vector<int32_t> persistentIds = { 1, 2 };
     std::vector<int32_t> clearFailedIds;
-    EXPECT_CALL(m->Mock(), ClearMainSessions(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto instance = WindowManagerLite::GetInstance(-1);
 
-    auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds, clearFailedIds);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    instance->ClearMainSessions(persistentIds, clearFailedIds);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -857,29 +815,23 @@ HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected03, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RegisterWindowStyleChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
-    windowManager.pImpl_->windowStyleListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowStyleListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowStyleListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowStyleListeners_;
+    windowManager->pImpl_->windowStyleListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowStyleListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowStyleChangedListener(nullptr));
 
     sptr<IWindowStyleChangedListener> listener = sptr<TestWindowStyleChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
+    windowManager->RegisterWindowStyleChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     // to check that the same listner can not be registered twice
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
+    windowManager->RegisterWindowStyleChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowStyleListeners_ = oldListeners;
+    windowManager->pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowStyleListeners_ = oldListeners;
 }
 
 /**
@@ -889,36 +841,31 @@ HWTEST_F(WindowManagerLiteTest, RegisterWindowStyleChangedListener, TestSize.Lev
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterWindowStyleChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
-    windowManager.pImpl_->windowStyleListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
-    windowManager.pImpl_->windowStyleListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowStyleListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowStyleListeners_;
+    windowManager->pImpl_->windowStyleListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
+    windowManager->pImpl_->windowStyleListeners_.clear();
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWindowStyleChangedListener(nullptr));
 
     sptr<TestWindowStyleChangedListener> listener1 = sptr<TestWindowStyleChangedListener>::MakeSptr();
     sptr<TestWindowStyleChangedListener> listener2 = sptr<TestWindowStyleChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowStyleChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowStyleChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowStyleChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowStyleListeners_.size());
+    windowManager->RegisterWindowStyleChangedListener(listener1);
+    windowManager->RegisterWindowStyleChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowStyleChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowStyleChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowStyleListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowStyleListenerAgent_);
 
-    windowManager.pImpl_->windowStyleListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
-    windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowStyleListeners_ = oldListeners;
+    windowManager->pImpl_->windowStyleListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowStyleChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowStyleListeners_.size());
+    windowManager->pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowStyleListeners_ = oldListeners;
 }
 
 /**
@@ -940,11 +887,11 @@ HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange02, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<IWindowStyleChangedListener> listener = sptr<TestWindowStyleChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
+
+    windowManager->RegisterWindowStyleChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
     auto ret = WindowManagerLite::GetInstance().NotifyWindowStyleChange(type);
@@ -969,12 +916,10 @@ HWTEST_F(WindowManagerLiteTest, GetWindowStyleType, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, TerminateSessionByPersistentId001, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     int32_t persistentId = 1;
-    EXPECT_CALL(m->Mock(), TerminateSessionByPersistentId(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-
-    auto errorCode = WindowManagerLite::GetInstance().TerminateSessionByPersistentId(persistentId);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->TerminateSessionByPersistentId(persistentId);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -1009,16 +954,15 @@ HWTEST_F(WindowManagerLiteTest, OnRemoteDied01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, CloseTargetFloatWindow, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::string bundleName = "test";
-    EXPECT_CALL(m->Mock(), CloseTargetFloatWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto instance = WindowManagerLite::GetInstance(-1);
 
-    auto errorCode = WindowManagerLite::GetInstance().CloseTargetFloatWindow(bundleName);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    instance->CloseTargetFloatWindow(bundleName);
+    ASSERT_NE(nullptr, instance);
 
     std::string bundleName1 = "";
-    errorCode = WindowManagerLite::GetInstance().CloseTargetFloatWindow(bundleName1);
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
+    instance->CloseTargetFloatWindow(bundleName1);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -1028,30 +972,22 @@ HWTEST_F(WindowManagerLiteTest, CloseTargetFloatWindow, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RegisterPiPStateChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
-    windowManager.pImpl_->pipStateChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->pipStateChangedListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(nullptr));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->pipStateChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->pipStateChangedListeners_;
+    windowManager->pImpl_->pipStateChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->pipStateChangedListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterPiPStateChangedListener(nullptr));
 
     sptr<IPiPStateChangedListener> listener = sptr<TestPiPStateChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
+    windowManager->RegisterPiPStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
+    windowManager->RegisterPiPStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
-
-    windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
+    windowManager->pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->pipStateChangedListeners_ = oldListeners;
 }
 
 /**
@@ -1061,36 +997,30 @@ HWTEST_F(WindowManagerLiteTest, RegisterPiPStateChangedListener, TestSize.Level1
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterPiPStateChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
-    windowManager.pImpl_->pipStateChangedListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
-    windowManager.pImpl_->pipStateChangedListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->pipStateChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->pipStateChangedListeners_;
+    windowManager->pImpl_->pipStateChangedListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
+    windowManager->pImpl_->pipStateChangedListeners_.clear();
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterPiPStateChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterPiPStateChangedListener(nullptr));
 
     sptr<IPiPStateChangedListener> listener1 = sptr<TestPiPStateChangedListener>::MakeSptr();
     sptr<IPiPStateChangedListener> listener2 = sptr<TestPiPStateChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterPiPStateChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterPiPStateChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterPiPStateChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->pipStateChangedListeners_.size());
-
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
+    windowManager->RegisterPiPStateChangedListener(listener1);
+    windowManager->RegisterPiPStateChangedListener(listener2);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterPiPStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterPiPStateChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->pipStateChangedListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->pipStateChangedListenerAgent_);
 
-    windowManager.pImpl_->pipStateChangedListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
-    windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
+    windowManager->pImpl_->pipStateChangedListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterPiPStateChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->pipStateChangedListeners_.size());
+    windowManager->pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->pipStateChangedListeners_ = oldListeners;
 }
 
 /**
@@ -1100,16 +1030,15 @@ HWTEST_F(WindowManagerLiteTest, UnregisterPiPStateChangedListener, TestSize.Leve
  */
 HWTEST_F(WindowManagerLiteTest, CloseTargetPiPWindow, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::string bundleName = "test";
-    EXPECT_CALL(m->Mock(), CloseTargetPiPWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto instance = WindowManagerLite::GetInstance(-1);
 
-    auto errorCode = WindowManagerLite::GetInstance().CloseTargetPiPWindow(bundleName);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    instance->CloseTargetPiPWindow(bundleName);
+    ASSERT_NE(nullptr, instance);
 
     std::string bundleName1 = "";
-    errorCode = WindowManagerLite::GetInstance().CloseTargetPiPWindow(bundleName1);
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
+    auto ret = instance->CloseTargetPiPWindow(bundleName1);
+    ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
 }
 
 /**
@@ -1119,12 +1048,10 @@ HWTEST_F(WindowManagerLiteTest, CloseTargetPiPWindow, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo01, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-
     std::string bundleName;
-    auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->GetCurrentPiPWindowInfo(bundleName);
+    ASSERT_NE(nullptr, instance);
     ASSERT_EQ("", bundleName);
 }
 
@@ -1135,17 +1062,11 @@ HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo02, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::string testBundleName = "test";
-    bool testState = true;
-    EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_))
-        .Times(1)
-        .WillOnce(DoAll(SetArgReferee<0>(testBundleName), Return(WMError::WM_OK)));
-
     std::string bundleName;
-    auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
-    ASSERT_EQ(WMError::WM_OK, errorCode);
-    ASSERT_EQ(testBundleName, bundleName);
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->GetCurrentPiPWindowInfo(bundleName);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -1155,13 +1076,11 @@ HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo02, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, GetAccessibilityWindowInfo01, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::vector<sptr<AccessibilityWindowInfo>> infos;
     infos.clear();
-    EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
-    EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
+    auto instance = WindowManagerLite::GetInstance(-1);
+    instance->GetAccessibilityWindowInfo(infos);
+    ASSERT_NE(nullptr, instance);
 }
 
 /**
@@ -1171,30 +1090,19 @@ HWTEST_F(WindowManagerLiteTest, GetAccessibilityWindowInfo01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RegisterWindowUpdateListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
-    windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowUpdateListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowUpdateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowUpdateListeners_;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowUpdateListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowUpdateListener(nullptr));
 
     sptr<TestWindowUpdateListener> listener = sptr<TestWindowUpdateListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
-
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->RegisterWindowUpdateListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowUpdateListeners_ = oldListeners;
 }
 
 /**
@@ -1204,38 +1112,34 @@ HWTEST_F(WindowManagerLiteTest, RegisterWindowUpdateListener01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterWindowUpdateListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
-    windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowUpdateListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowUpdateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowUpdateListeners_;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowUpdateListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWindowUpdateListener(nullptr));
 
     sptr<TestWindowUpdateListener> listener1 = sptr<TestWindowUpdateListener>::MakeSptr();
     sptr<TestWindowUpdateListener> listener2 = sptr<TestWindowUpdateListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowUpdateListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowUpdateListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->RegisterWindowUpdateListener(listener1);
+    windowManager->RegisterWindowUpdateListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->windowUpdateListeners_.size());
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowUpdateListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowUpdateListenerAgent_);
 
-    windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->pImpl_->windowUpdateListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowUpdateListeners_.size());
 
-    windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowUpdateListeners_ = oldListeners;
 }
 
 /**
@@ -1383,23 +1287,21 @@ HWTEST_F(WindowManagerLiteTest, NotifyCallingWindowDisplayChanged2, Function | S
 HWTEST_F(WindowManagerLiteTest, UpdatePiPWindowStateChanged, TestSize.Level1)
 {
     WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<TestPiPStateChangedListener> listener = nullptr;
-    lite.pImpl_->pipStateChangedListenerAgent_.push_back(listener);
+    lite.pImpl_->pipStateChangedListeners_.push_back(listener);
     const std::string& bundleName = "test";
-    windowManager.UpdatePiPWindowStateChanged(bundleName, true);
+    windowManager->UpdatePiPWindowStateChanged(bundleName, true);
     lite.pImpl_->UpdatePiPWindowStateChanged(bundleName, true);
 
-    lite.pImpl_->pipStateChangedListenerAgent_.clear();
+    lite.pImpl_->pipStateChangedListeners_.clear();
     listener = sptr<TestPiPStateChangedListener>::MakeSptr();
-    lite.pImpl_->pipStateChangedListenerAgent_.push_back(listener);
-    windowManager.UpdatePiPWindowStateChanged(bundleName, true);
+    lite.pImpl_->pipStateChangedListeners_.push_back(listener);
+    windowManager->UpdatePiPWindowStateChanged(bundleName, true);
     lite.pImpl_->UpdatePiPWindowStateChanged(bundleName, true);
 
-    lite.pImpl_->pipStateChangedListenerAgent_.clear();
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
+    lite.pImpl_->pipStateChangedListeners_.clear();
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterPiPStateChangedListener(listener));
 }
 
 /**
@@ -1409,16 +1311,11 @@ HWTEST_F(WindowManagerLiteTest, UpdatePiPWindowStateChanged, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterFocusChangedListener, TestSize.Level1)
 {
-    WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<TestFocusChangedListener> listener = sptr<TestFocusChangedListener>::MakeSptr();
     ASSERT_TRUE(listener != nullptr);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterFocusChangedListener(listener));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterFocusChangedListener(listener));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterFocusChangedListener(listener));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterFocusChangedListener(listener));
 }
 
 /**
@@ -1428,15 +1325,12 @@ HWTEST_F(WindowManagerLiteTest, UnregisterFocusChangedListener, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterVisibilityChangedListener, TestSize.Level1)
 {
-    WindowManagerLite lite;
-    auto& windowManager = WindowManagerLite::GetInstance();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
+    auto windowManager = WindowManagerLite::GetInstance(-1);
     sptr<TestVisibilityChangedListener> listener = sptr<TestVisibilityChangedListener>::MakeSptr();
     ASSERT_TRUE(listener != nullptr);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener));
+    windowManager->RegisterVisibilityChangedListener(listener);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityChangedListener(listener));
 }
 
 /**
@@ -1522,30 +1416,23 @@ HWTEST_F(WindowManagerLiteTest, UnregisterWindowInfoChangeCallback01, Function |
  */
 HWTEST_F(WindowManagerLiteTest, RegisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowVisibilityStateListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
- 
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityStateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityStateListeners_;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowVisibilityStateListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterVisibilityStateChangedListener(nullptr));
+
     sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
- 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
- 
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowVisibilityStateListenerAgent_);
+
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
- 
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityStateListeners_ = oldListeners;
 }
 
 /**
@@ -1555,38 +1442,33 @@ HWTEST_F(WindowManagerLiteTest, RegisterVisibilityStateChangedListener01, Functi
  */
 HWTEST_F(WindowManagerLiteTest, UnregisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManagerLite::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
-    windowManager.pImpl_->windowVisibilityStateListeners_.clear();
+    auto windowManager = WindowManagerLite::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityStateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityStateListeners_;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgentLite>::MakeSptr();
+    windowManager->pImpl_->windowVisibilityStateListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityStateChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterVisibilityStateChangedListener(nullptr));
 
     sptr<TestWindowVisibilityStateListener> listener1 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
     sptr<TestWindowVisibilityStateListener> listener2 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager->UnregisterVisibilityStateChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityStateListeners_.size());
+    windowManager->RegisterVisibilityStateChangedListener(listener1);
+    windowManager->RegisterVisibilityStateChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityStateListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowVisibilityStateListenerAgent_);
 
-    windowManager.pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
+    windowManager->pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityStateListeners_.size());
 
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityStateListeners_ = oldListeners;
 }
 
 /**
@@ -1616,19 +1498,15 @@ HWTEST_F(WindowManagerLiteTest, SendPointerEventForHover, Function | SmallTest |
  * @tc.desc: normal function
  * @tc.type: FUNC
  */
-HWTEST_F(WindowManagerLiteTest, GetInstance, TestSize.Level1)
+HWTEST_F(WindowManagerLiteTest, GetInstanceMulti, TestSize.Level1)
 {
-    sptr<WindowManagerLite> instance = nullptr;
-    int32_t userId = -1;
-    instance = WindowManagerLite::GetInstance(userId);
-    ASSERT_NE(instance, nullptr);
-
-    userId = 101;
-    instance = WindowManagerLite::GetInstance(userId);
+    sptr<WindowAdapterLite> instance = nullptr;
+    int32_t userId = 101;
+    instance = WindowAdapterLite::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 
     // branch overried
-    instance = WindowManagerLite::GetInstance(userId);
+    instance = WindowAdapterLite::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 }
 
@@ -1639,8 +1517,7 @@ HWTEST_F(WindowManagerLiteTest, GetInstance, TestSize.Level1)
  */
 HWTEST_F(WindowManagerLiteTest, RemoveInstanceByUserId, TestSize.Level1)
 {
-    int32_t userId = 101;
-    ASSERT_EQ(WMError::WM_OK, WindowManagerLite::RemoveInstanceByUserId(userId));
+    ASSERT_EQ(WMError::WM_OK, WindowManagerLite::RemoveInstanceByUserId(101));
 }
 }
 } // namespace
diff --git a/wm/test/unittest/window_manager_test.cpp b/wm/test/unittest/window_manager_test.cpp
index 4a44b92e9b..89d9f5f768 100644
--- a/wm/test/unittest/window_manager_test.cpp
+++ b/wm/test/unittest/window_manager_test.cpp
@@ -238,6 +238,12 @@ public:
     void TearDown() override;
 };
 
+class TestWMSListener : public IWMSConnectionChangedListener {
+public:
+    void OnConnected(int32_t userId, int32_t screenId) override {}
+    void OnDisconnected(int32_t userId, int32_t screenId) override {}
+};
+
 void WindowManagerTest::SetUpTestCase() {}
 
 void WindowManagerTest::TearDownTestCase() {}
@@ -270,9 +276,9 @@ HWTEST_F(WindowManagerTest, GetVisibilityWindowInfo01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), ToggleShownStateForAllAppWindows()).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().ToggleShownStateForAllAppWindows());
+    auto instance = WindowManager::GetInstance(-1);
+    ASSERT_NE(nullptr, instance);
+    instance->ToggleShownStateForAllAppWindows();
 }
 
 /**
@@ -282,13 +288,11 @@ HWTEST_F(WindowManagerTest, ToggleShownStateForAllAppWindows, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, GetAccessibilityWindowInfo01, TestSize.Level1)
 {
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     std::vector<sptr<AccessibilityWindowInfo>> infos;
     infos.clear();
-    EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
-    EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManager::GetInstance().GetAccessibilityWindowInfo(infos));
+    auto instance = WindowManager::GetInstance(-1);
+    ASSERT_NE(nullptr, instance);
+    instance->GetAccessibilityWindowInfo(infos);
 }
 
 /**
@@ -343,29 +347,23 @@ HWTEST_F(WindowManagerTest, NotifyScreenshotEvent01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
-    windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->cameraFloatWindowChangedListeners_;
+    windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->cameraFloatWindowChangedListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterCameraFloatWindowChangedListener(nullptr));
 
     sptr<TestCameraFloatWindowChangedListener> listener = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraFloatWindowChangedListener(listener));
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterCameraFloatWindowChangedListener(listener));
+    ASSERT_EQ(1, windowManager->pImpl_->cameraFloatWindowChangedListeners_.size());
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraFloatWindowChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterCameraFloatWindowChangedListener(listener));
+    ASSERT_EQ(1, windowManager->pImpl_->cameraFloatWindowChangedListeners_.size());
 
-    windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
+    windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
 }
 
 /**
@@ -375,39 +373,34 @@ HWTEST_F(WindowManagerTest, RegisterCameraFloatWindowChangedListener01, TestSize
  */
 HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->cameraFloatWindowChangedListeners_;
-    windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->cameraFloatWindowChangedListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->cameraFloatWindowChangedListeners_;
+    windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->cameraFloatWindowChangedListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraFloatWindowChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterCameraFloatWindowChangedListener(nullptr));
 
     sptr<TestCameraFloatWindowChangedListener> listener1 = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
     sptr<TestCameraFloatWindowChangedListener> listener2 = sptr<TestCameraFloatWindowChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
-
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterCameraFloatWindowChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterCameraFloatWindowChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraFloatWindowChangedListener(listener1));
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
+    windowManager->RegisterCameraFloatWindowChangedListener(listener1);
+    windowManager->RegisterCameraFloatWindowChangedListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->cameraFloatWindowChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraFloatWindowChangedListener(listener1));
 
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_);
+    windowManager->UnregisterCameraFloatWindowChangedListener(listener2);
+    ASSERT_EQ(0, windowManager->pImpl_->cameraFloatWindowChangedListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_);
 
-    windowManager.pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraFloatWindowChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->cameraFloatWindowChangedListeners_.size());
+    windowManager->pImpl_->cameraFloatWindowChangedListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterCameraFloatWindowChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->cameraFloatWindowChangedListeners_.size());
 
-    windowManager.pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
+    windowManager->pImpl_->cameraFloatWindowChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->cameraFloatWindowChangedListeners_ = oldListeners;
 }
 
 /**
@@ -417,30 +410,23 @@ HWTEST_F(WindowManagerTest, UnregisterCameraFloatWindowChangedListener01, TestSi
  */
 HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
-    windowManager.pImpl_->windowVisibilityListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowVisibilityListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityListeners_;
+    windowManager->pImpl_->windowVisibilityListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowVisibilityListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterVisibilityChangedListener(nullptr));
 
     sptr<TestVisibilityChangedListener> listener = sptr<TestVisibilityChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
+    windowManager->RegisterVisibilityChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityListeners_.size());
+    windowManager->RegisterVisibilityChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
-    windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
+    windowManager->pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityListeners_ = oldListeners;
 }
 
 /**
@@ -450,37 +436,32 @@ HWTEST_F(WindowManagerTest, RegisterVisibilityChangedListener01, TestSize.Level1
  */
 HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityListeners_;
-    windowManager.pImpl_->windowVisibilityListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->windowVisibilityListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityListeners_;
+    windowManager->pImpl_->windowVisibilityListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->windowVisibilityListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterVisibilityChangedListener(nullptr));
 
     sptr<TestVisibilityChangedListener> listener1 = sptr<TestVisibilityChangedListener>::MakeSptr();
     sptr<TestVisibilityChangedListener> listener2 = sptr<TestVisibilityChangedListener>::MakeSptr();
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityListeners_.size());
+    windowManager->RegisterVisibilityChangedListener(listener1);
+    windowManager->RegisterVisibilityChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowVisibilityListenerAgent_);
 
-    windowManager.pImpl_->windowVisibilityListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityListeners_.size());
+    windowManager->pImpl_->windowVisibilityListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityListeners_.size());
 
-    windowManager.pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityListeners_ = oldListeners;
+    windowManager->pImpl_->windowVisibilityListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityListeners_ = oldListeners;
 }
 
 /**
@@ -490,30 +471,23 @@ HWTEST_F(WindowManagerTest, UnregisterVisibilityChangedListener01, TestSize.Leve
  */
 HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
-    windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowUpdateListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowUpdateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowUpdateListeners_;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowUpdateListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowUpdateListener(nullptr));
 
     sptr<TestWindowUpdateListener> listener = sptr<TestWindowUpdateListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->RegisterWindowUpdateListener(listener);
+    ASSERT_NE(nullptr, windowManager->pImpl_->windowUpdateListenerAgent_);
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->RegisterWindowUpdateListener(listener);
+    ASSERT_EQ(1, windowManager->pImpl_->windowUpdateListeners_.size());
 
-    windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowUpdateListeners_ = oldListeners;
 }
 
 /**
@@ -523,38 +497,34 @@ HWTEST_F(WindowManagerTest, RegisterWindowUpdateListener01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
-    windowManager.pImpl_->windowUpdateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->windowUpdateListeners_.clear();
+    auto windowManager = WindowManager::GetInstance();
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowUpdateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowUpdateListeners_;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->windowUpdateListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWindowUpdateListener(nullptr));
 
     sptr<TestWindowUpdateListener> listener1 = sptr<TestWindowUpdateListener>::MakeSptr();
     sptr<TestWindowUpdateListener> listener2 = sptr<TestWindowUpdateListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowUpdateListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowUpdateListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->RegisterWindowUpdateListener(listener1);
+    windowManager->RegisterWindowUpdateListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->windowUpdateListeners_.size());
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowUpdateListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowUpdateListenerAgent_);
 
-    windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
+    windowManager->pImpl_->windowUpdateListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowUpdateListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowUpdateListeners_.size());
 
-    windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
+    windowManager->pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowUpdateListeners_ = oldListeners;
 }
 
 /**
@@ -564,30 +534,19 @@ HWTEST_F(WindowManagerTest, UnregisterWindowUpdateListener01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowModeListeners_;
-    windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowModeListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowModeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowModeListeners_;
+    windowManager->pImpl_->windowModeListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowModeListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowModeChangedListener(nullptr));
 
     sptr<TestWindowModeChangedListener> listener = sptr<TestWindowModeChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
+    windowManager->RegisterWindowModeChangedListener(listener);
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowModeListenerAgent_);
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
-
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
-
-    windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowModeListeners_ = oldListeners;
+    windowManager->pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowModeListeners_ = oldListeners;
 }
 
 /**
@@ -597,38 +556,32 @@ HWTEST_F(WindowManagerTest, RegisterWindowModeChangedListener01, TestSize.Level1
  */
 HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowModeListeners_;
-    windowManager.pImpl_->windowModeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->windowModeListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowModeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowModeListeners_;
+    windowManager->pImpl_->windowModeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->windowModeListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWindowModeChangedListener(nullptr));
 
     sptr<TestWindowModeChangedListener> listener1 = sptr<TestWindowModeChangedListener>::MakeSptr();
     sptr<TestWindowModeChangedListener> listener2 = sptr<TestWindowModeChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowModeChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWindowModeChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
+    windowManager->RegisterWindowModeChangedListener(listener1);
+    windowManager->RegisterWindowModeChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener2));
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowModeListenerAgent_);
 
-    windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
+    windowManager->pImpl_->windowModeListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWindowModeChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowModeListeners_.size());
 
-    windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowModeListeners_ = oldListeners;
+    windowManager->pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowModeListeners_ = oldListeners;
 }
 
 /**
@@ -638,30 +591,23 @@ HWTEST_F(WindowManagerTest, UnregisterWindowModeChangedListener01, TestSize.Leve
  */
 HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
-    windowManager.pImpl_->systemBarChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->systemBarChangedListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->systemBarChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->systemBarChangedListeners_;
+    windowManager->pImpl_->systemBarChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->systemBarChangedListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterSystemBarChangedListener(nullptr));
 
     sptr<ISystemBarChangedListener> listener = sptr<TestSystemBarChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterSystemBarChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterSystemBarChangedListener(listener));
+    ASSERT_EQ(1, windowManager->pImpl_->systemBarChangedListeners_.size());
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterSystemBarChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->systemBarChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterSystemBarChangedListener(listener));
+    ASSERT_EQ(1, windowManager->pImpl_->systemBarChangedListeners_.size());
 
-    windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
+    windowManager->pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->systemBarChangedListeners_ = oldListeners;
 }
 
 /**
@@ -671,37 +617,33 @@ HWTEST_F(WindowManagerTest, RegisterSystemBarChangedListener01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->systemBarChangedListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->systemBarChangedListeners_;
-    windowManager.pImpl_->systemBarChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->systemBarChangedListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->systemBarChangedListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->systemBarChangedListeners_;
+    windowManager->pImpl_->systemBarChangedListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->systemBarChangedListeners_.clear();
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterSystemBarChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterSystemBarChangedListener(nullptr));
 
     sptr<TestSystemBarChangedListener> listener1 = sptr<TestSystemBarChangedListener>::MakeSptr();
     sptr<TestSystemBarChangedListener> listener2 = sptr<TestSystemBarChangedListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterSystemBarChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterSystemBarChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterSystemBarChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->systemBarChangedListeners_.size());
+    windowManager->RegisterSystemBarChangedListener(listener1);
+    windowManager->RegisterSystemBarChangedListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->systemBarChangedListeners_.size());
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->systemBarChangedListenerAgent_);
+    windowManager->UnregisterSystemBarChangedListener(listener1);
+    windowManager->UnregisterSystemBarChangedListener(listener2);
+    ASSERT_EQ(0, windowManager->pImpl_->systemBarChangedListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->systemBarChangedListenerAgent_);
 
-    windowManager.pImpl_->systemBarChangedListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterSystemBarChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->systemBarChangedListeners_.size());
+    windowManager->pImpl_->systemBarChangedListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterSystemBarChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->systemBarChangedListeners_.size());
 
-    windowManager.pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->systemBarChangedListeners_ = oldListeners;
+    windowManager->pImpl_->systemBarChangedListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->systemBarChangedListeners_ = oldListeners;
 }
 
 /**
@@ -711,30 +653,21 @@ HWTEST_F(WindowManagerTest, UnregisterSystemBarChangedListener01, TestSize.Level
  */
 HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
+    auto windowManager = WindowManager::GetInstance(-1);
 
-    windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
-    windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
+    windowManager->pImpl_->waterMarkFlagChangeAgent_ = nullptr;
+    windowManager->pImpl_->waterMarkFlagChangeListeners_.clear();
 
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWaterMarkFlagChangedListener(nullptr));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    sptr<TestWaterMarkFlagChangeListener> listener = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWaterMarkFlagChangedListener(listener));
-    ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
-    ASSERT_NE(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
+    auto listener = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
+    windowManager->RegisterWaterMarkFlagChangedListener(listener);
+    ASSERT_EQ(1, windowManager->pImpl_->waterMarkFlagChangeListeners_.size());
+    ASSERT_NE(nullptr, windowManager->pImpl_->waterMarkFlagChangeAgent_);
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWaterMarkFlagChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
+    windowManager->RegisterWaterMarkFlagChangedListener(listener);
+    ASSERT_EQ(1, windowManager->pImpl_->waterMarkFlagChangeListeners_.size());
 }
 
 /**
@@ -744,34 +677,31 @@ HWTEST_F(WindowManagerTest, RegisterWaterMarkFlagChangedListener01, TestSize.Lev
  */
 HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    windowManager.pImpl_->waterMarkFlagChangeAgent_ = nullptr;
-    windowManager.pImpl_->waterMarkFlagChangeListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    windowManager->pImpl_->waterMarkFlagChangeAgent_ = nullptr;
+    windowManager->pImpl_->waterMarkFlagChangeListeners_.clear();
     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWaterMarkFlagChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterWaterMarkFlagChangedListener(nullptr));
 
     sptr<TestWaterMarkFlagChangeListener> listener1 = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
     sptr<TestWaterMarkFlagChangeListener> listener2 = sptr<TestWaterMarkFlagChangeListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWaterMarkFlagChangedListener(listener1));
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWaterMarkFlagChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterWaterMarkFlagChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
+    windowManager->RegisterWaterMarkFlagChangedListener(listener1);
+    windowManager->RegisterWaterMarkFlagChangedListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->waterMarkFlagChangeListeners_.size());
 
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->waterMarkFlagChangeAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWaterMarkFlagChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWaterMarkFlagChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->waterMarkFlagChangeListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->waterMarkFlagChangeAgent_);
 
     // if agent == nullptr, it can not be crashed.
-    windowManager.pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWaterMarkFlagChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->waterMarkFlagChangeListeners_.size());
+    windowManager->pImpl_->waterMarkFlagChangeListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterWaterMarkFlagChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->waterMarkFlagChangeListeners_.size());
 }
 
 /**
@@ -781,31 +711,24 @@ HWTEST_F(WindowManagerTest, UnregisterWaterMarkFlagChangedListener01, TestSize.L
  */
 HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
+    auto windowManager = WindowManager::GetInstance(-1);
 
-    windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
-    windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
+    windowManager->pImpl_->gestureNavigationEnabledAgent_ = nullptr;
+    windowManager->pImpl_->gestureNavigationEnabledListeners_.clear();
 
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterGestureNavigationEnabledChangedListener(nullptr));
 
     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     sptr<TestGestureNavigationEnabledChangedListener> listener =
         sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
 
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
-    ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
-    ASSERT_NE(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
+    windowManager->RegisterGestureNavigationEnabledChangedListener(listener);
+    ASSERT_EQ(1, windowManager->pImpl_->gestureNavigationEnabledListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->gestureNavigationEnabledAgent_);
 
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterGestureNavigationEnabledChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterGestureNavigationEnabledChangedListener(listener));
+    ASSERT_EQ(1, windowManager->pImpl_->gestureNavigationEnabledListeners_.size());
 }
 
 /**
@@ -815,37 +738,33 @@ HWTEST_F(WindowManagerTest, RegisterGestureNavigationEnabledChangedListener, Tes
  */
 HWTEST_F(WindowManagerTest, UnregisterGestureNavigationEnabledChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    windowManager.pImpl_->gestureNavigationEnabledAgent_ = nullptr;
-    windowManager.pImpl_->gestureNavigationEnabledListeners_.clear();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
+    auto windowManager = WindowManager::GetInstance(-1);
+    windowManager->pImpl_->gestureNavigationEnabledAgent_ = nullptr;
+    windowManager->pImpl_->gestureNavigationEnabledListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterGestureNavigationEnabledChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterGestureNavigationEnabledChangedListener(nullptr));
 
     sptr<TestGestureNavigationEnabledChangedListener> listener1 =
         sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
     sptr<TestGestureNavigationEnabledChangedListener> listener2 =
         sptr<TestGestureNavigationEnabledChangedListener>::MakeSptr();
     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM,
-              windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
+              windowManager->UnregisterGestureNavigationEnabledChangedListener(listener1));
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterGestureNavigationEnabledChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterGestureNavigationEnabledChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
+    windowManager->RegisterGestureNavigationEnabledChangedListener(listener1);
+    windowManager->RegisterGestureNavigationEnabledChangedListener(listener2);
+    ASSERT_EQ(2, windowManager->pImpl_->gestureNavigationEnabledListeners_.size());
 
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->gestureNavigationEnabledAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterGestureNavigationEnabledChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterGestureNavigationEnabledChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->gestureNavigationEnabledListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->gestureNavigationEnabledAgent_);
 
     // if agent == nullptr, it can not be crashed.
-    windowManager.pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterGestureNavigationEnabledChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->gestureNavigationEnabledListeners_.size());
+    windowManager->pImpl_->gestureNavigationEnabledListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterGestureNavigationEnabledChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->gestureNavigationEnabledListeners_.size());
 }
 
 /**
@@ -1005,9 +924,9 @@ HWTEST_F(WindowManagerTest, GetWindowModeType01, TestSize.Level1)
     std::vector<sptr<AccessibilityWindowInfo>> infos;
     infos.clear();
     WindowModeType windowModeType;
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), GetWindowModeType(_)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, WindowManager::GetInstance().GetWindowModeType(windowModeType));
+    auto instance = WindowManager::GetInstance(-1);
+    ASSERT_NE(nullptr, instance);
+    instance->GetWindowModeType(windowModeType);
 }
 
 /**
@@ -1017,30 +936,16 @@ HWTEST_F(WindowManagerTest, GetWindowModeType01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
+    auto windowManager = WindowManager::GetInstance(-1);
 
-    windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
+    windowManager->pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->visibleWindowNumChangedListeners_.clear();
 
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterVisibleWindowNumChangedListener(nullptr));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     sptr<TestVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibleWindowNumChangedListener(listener));
-    ASSERT_EQ(0, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
-
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
-    ASSERT_NE(nullptr, windowManager.pImpl_->visibleWindowNumChangedListenerAgent_);
-
-    // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
+    windowManager->RegisterVisibleWindowNumChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 }
 
 /**
@@ -1050,31 +955,25 @@ HWTEST_F(WindowManagerTest, RegisterVisibleWindowNumChangedListener, TestSize.Le
  */
 HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
+    auto windowManager = WindowManager::GetInstance(-1);
+    windowManager->pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->visibleWindowNumChangedListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibleWindowNumChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterVisibleWindowNumChangedListener(nullptr));
 
     sptr<TestVisibleWindowNumChangedListener> listener1 = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
     sptr<TestVisibleWindowNumChangedListener> listener2 = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibleWindowNumChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibleWindowNumChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
+    windowManager->RegisterVisibleWindowNumChangedListener(listener1);
+    windowManager->RegisterVisibleWindowNumChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener2));
-    ASSERT_EQ(2, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibleWindowNumChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibleWindowNumChangedListener(listener2));
 
     // if agent == nullptr, it can not be crashed.
-    windowManager.pImpl_->visibleWindowNumChangedListeners_.push_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibleWindowNumChangedListener(listener1));
-    ASSERT_EQ(3, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
+    windowManager->pImpl_->visibleWindowNumChangedListeners_.push_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibleWindowNumChangedListener(listener1));
 }
 
 /**
@@ -1084,22 +983,20 @@ HWTEST_F(WindowManagerTest, UnregisterVisibleWindowNumChangedListener, TestSize.
  */
 HWTEST_F(WindowManagerTest, RegisterAndOnVisibleWindowNumChanged, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    windowManager.pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
-    windowManager.pImpl_->visibleWindowNumChangedListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    windowManager->pImpl_->visibleWindowNumChangedListenerAgent_ = nullptr;
+    windowManager->pImpl_->visibleWindowNumChangedListeners_.clear();
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
     sptr<TestVisibleWindowNumChangedListener> listener = sptr<TestVisibleWindowNumChangedListener>::MakeSptr();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibleWindowNumChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->visibleWindowNumChangedListeners_.size());
+    windowManager->RegisterVisibleWindowNumChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
 
     std::vector<VisibleWindowNumInfo> visibleWindowNumInfo;
     VisibleWindowNumInfo newInfo;
     newInfo.displayId = 0;
     newInfo.visibleWindowNum = 2;
     visibleWindowNumInfo.push_back(newInfo);
-    windowManager.UpdateVisibleWindowNum(visibleWindowNumInfo);
+    windowManager->UpdateVisibleWindowNum(visibleWindowNumInfo);
 }
 
 /**
@@ -1127,31 +1024,31 @@ HWTEST_F(WindowManagerTest, Test01, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, RegisterDisplayInfoChangedListener, TestSize.Level1)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    windowManager.pImpl_->displayInfoChangedListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    windowManager->pImpl_->displayInfoChangedListeners_.clear();
 
     sptr<IRemoteObject> targetToken = nullptr;
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterDisplayInfoChangedListener(targetToken, nullptr));
 
     targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(targetToken, nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterDisplayInfoChangedListener(targetToken, nullptr));
 
     sptr<IDisplayInfoChangedListener> listener = sptr<TestDisplayInfoChangedListener>::MakeSptr();
     sptr<IDisplayInfoChangedListener> listener2 = sptr<TestDisplayInfoChangedListener>::MakeSptr();
 
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterDisplayInfoChangedListener(nullptr, listener));
-    ASSERT_EQ(0, windowManager.pImpl_->displayInfoChangedListeners_.size());
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
-    ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterDisplayInfoChangedListener(nullptr, listener));
+    ASSERT_EQ(0, windowManager->pImpl_->displayInfoChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterDisplayInfoChangedListener(targetToken, listener));
+    ASSERT_EQ(1, windowManager->pImpl_->displayInfoChangedListeners_.size());
 
     // to check that the same listner can not be registered twice
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener));
-    ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterDisplayInfoChangedListener(targetToken, listener));
+    ASSERT_EQ(1, windowManager->pImpl_->displayInfoChangedListeners_.size());
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDisplayInfoChangedListener(targetToken, listener2));
-    ASSERT_EQ(1, windowManager.pImpl_->displayInfoChangedListeners_.size());
-    auto iter = windowManager.pImpl_->displayInfoChangedListeners_.find(targetToken);
-    ASSERT_NE(windowManager.pImpl_->displayInfoChangedListeners_.end(), iter);
+    ASSERT_EQ(WMError::WM_OK, windowManager->RegisterDisplayInfoChangedListener(targetToken, listener2));
+    ASSERT_EQ(1, windowManager->pImpl_->displayInfoChangedListeners_.size());
+    auto iter = windowManager->pImpl_->displayInfoChangedListeners_.find(targetToken);
+    ASSERT_NE(windowManager->pImpl_->displayInfoChangedListeners_.end(), iter);
     ASSERT_EQ(2, iter->second.size());
 }
 
@@ -1909,30 +1806,23 @@ HWTEST_F(WindowManagerTest, UnregisterWindowInfoChangeCallback01, Function | Sma
  */
 HWTEST_F(WindowManagerTest, RegisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowVisibilityStateListeners_.clear();
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
- 
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityStateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityStateListeners_;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowVisibilityStateListeners_.clear();
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterVisibilityStateChangedListener(nullptr));
+
     sptr<TestWindowVisibilityStateListener> listener = sptr<TestWindowVisibilityStateListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
- 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
- 
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(1, windowManager.pImpl_->windowVisibilityStateListeners_.size());
- 
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityStateListeners_ = oldListeners;
 }
 
 /**
@@ -1942,38 +1832,33 @@ HWTEST_F(WindowManagerTest, RegisterVisibilityStateChangedListener01, Function |
  */
 HWTEST_F(WindowManagerTest, UnregisterVisibilityStateChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowVisibilityStateListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowVisibilityStateListeners_;
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->windowVisibilityStateListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowVisibilityStateListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowVisibilityStateListeners_;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->windowVisibilityStateListeners_.clear();
 
     // check nullpter
-    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterVisibilityStateChangedListener(nullptr));
+    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterVisibilityStateChangedListener(nullptr));
 
     sptr<TestWindowVisibilityStateListener> listener1 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
     sptr<TestWindowVisibilityStateListener> listener2 = sptr<TestWindowVisibilityStateListener>::MakeSptr();
-    ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager->UnregisterVisibilityStateChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener2);
-    ASSERT_EQ(2, windowManager.pImpl_->windowVisibilityStateListeners_.size());
+    windowManager->RegisterVisibilityStateChangedListener(listener1);
+    windowManager->RegisterVisibilityStateChangedListener(listener2);
 
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
-    EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener2));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->windowVisibilityStateListenerAgent_);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener2));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityStateListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->windowVisibilityStateListenerAgent_);
 
-    windowManager.pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
-    ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterVisibilityStateChangedListener(listener1));
-    ASSERT_EQ(0, windowManager.pImpl_->windowVisibilityStateListeners_.size());
+    windowManager->pImpl_->windowVisibilityStateListeners_.emplace_back(listener1);
+    ASSERT_EQ(WMError::WM_OK, windowManager->UnregisterVisibilityStateChangedListener(listener1));
+    ASSERT_EQ(0, windowManager->pImpl_->windowVisibilityStateListeners_.size());
 
-    windowManager.pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowVisibilityStateListeners_ = oldListeners;
+    windowManager->pImpl_->windowVisibilityStateListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowVisibilityStateListeners_ = oldListeners;
 }
 
 /**
@@ -1983,30 +1868,23 @@ HWTEST_F(WindowManagerTest, UnregisterVisibilityStateChangedListener01, Function
  */
 HWTEST_F(WindowManagerTest, RegisterDisplayIdChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowDisplayIdChangeListeners_;
-    windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = nullptr;
-    windowManager.pImpl_->windowDisplayIdChangeListeners_.clear();
-    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(nullptr));
- 
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowDisplayIdChangeListeners_;
+    windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_ = nullptr;
+    windowManager->pImpl_->windowDisplayIdChangeListeners_.clear();
+    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterVisibilityStateChangedListener(nullptr));
+
     sptr<TestWindowDisplayIdChangeListener> listener = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
-    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterVisibilityStateChangedListener(listener));
-    ASSERT_EQ(nullptr, windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_);
- 
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    EXPECT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
- 
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
     // to check that the same listner can not be registered twice
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    EXPECT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityStateChangedListener(listener));
-    EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
- 
-    windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
+    windowManager->RegisterVisibilityStateChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
+    windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
 }
 
 /**
@@ -2016,37 +1894,33 @@ HWTEST_F(WindowManagerTest, RegisterDisplayIdChangedListener01, Function | Small
  */
 HWTEST_F(WindowManagerTest, UnregisterDisplayIdChangedListener01, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_;
-    auto oldListeners = windowManager.pImpl_->windowDisplayIdChangeListeners_;
-    windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
-    windowManager.pImpl_->windowDisplayIdChangeListeners_.clear();
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_;
+    auto oldListeners = windowManager->pImpl_->windowDisplayIdChangeListeners_;
+    windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_ = sptr<WindowManagerAgent>::MakeSptr();
+    windowManager->pImpl_->windowDisplayIdChangeListeners_.clear();
 
     // check nullpter
-    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterDisplayIdChangedListener(nullptr));
+    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->UnregisterDisplayIdChangedListener(nullptr));
 
     sptr<TestWindowDisplayIdChangeListener> listener1 = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
     sptr<TestWindowDisplayIdChangeListener> listener2 = sptr<TestWindowDisplayIdChangeListener>::MakeSptr();
-    EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager.UnregisterDisplayIdChangedListener(listener1));
+    EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, windowManager->UnregisterDisplayIdChangedListener(listener1));
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener1);
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    windowManager.RegisterVisibilityStateChangedListener(listener2);
-    EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
+    windowManager->RegisterVisibilityStateChangedListener(listener1);
+    windowManager->RegisterVisibilityStateChangedListener(listener2);
 
-    EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener1));
-    EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener2));
-    EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
-    ASSERT_EQ(nullptr, windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_);
+    EXPECT_EQ(WMError::WM_OK, windowManager->UnregisterDisplayIdChangedListener(listener1));
+    EXPECT_EQ(WMError::WM_OK, windowManager->UnregisterDisplayIdChangedListener(listener2));
+    EXPECT_EQ(0, windowManager->pImpl_->windowDisplayIdChangeListeners_.size());
+    ASSERT_EQ(nullptr, windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_);
 
-    windowManager.pImpl_->windowDisplayIdChangeListeners_.emplace_back(listener1);
-    EXPECT_EQ(WMError::WM_OK, windowManager.UnregisterDisplayIdChangedListener(listener1));
-    EXPECT_EQ(0, windowManager.pImpl_->windowDisplayIdChangeListeners_.size());
+    windowManager->pImpl_->windowDisplayIdChangeListeners_.emplace_back(listener1);
+    EXPECT_EQ(WMError::WM_OK, windowManager->UnregisterDisplayIdChangedListener(listener1));
+    EXPECT_EQ(0, windowManager->pImpl_->windowDisplayIdChangeListeners_.size());
 
-    windowManager.pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
+    windowManager->pImpl_->WindowDisplayIdChangeListenerAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowDisplayIdChangeListeners_ = oldListeners;
 }
 
 /**
@@ -2056,21 +1930,20 @@ HWTEST_F(WindowManagerTest, UnregisterDisplayIdChangedListener01, Function | Sma
  */
 HWTEST_F(WindowManagerTest, RegisterWindowSystemBarPropertyChangedListener, Function | SmallTest | Level2)
 {
-    auto& windowManager = WindowManager::GetInstance();
-    auto oldWindowManagerAgent = windowManager.pImpl_->windowSystemBarPropertyChangeAgent_;
-    auto oldListeners = windowManager.pImpl_->windowSystemBarPropertyChangedListeners_;
-    windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = nullptr;
-    windowManager.pImpl_->windowSystemBarPropertyChangedListeners_.clear();
-    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowSystemBarPropertyChangedListener(nullptr));
+    auto windowManager = WindowManager::GetInstance(-1);
+    auto oldWindowManagerAgent = windowManager->pImpl_->windowSystemBarPropertyChangeAgent_;
+    auto oldListeners = windowManager->pImpl_->windowSystemBarPropertyChangedListeners_;
+    windowManager->pImpl_->windowSystemBarPropertyChangeAgent_ = nullptr;
+    windowManager->pImpl_->windowSystemBarPropertyChangedListeners_.clear();
+    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, windowManager->RegisterWindowSystemBarPropertyChangedListener(nullptr));
+
     sptr<TestWindowSystemBarPropertyChangedListener> listener =
         sptr<TestWindowSystemBarPropertyChangedListener>::MakeSptr();
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    EXPECT_EQ(WMError::WM_OK, windowManager.RegisterWindowSystemBarPropertyChangedListener(listener));
-    EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    EXPECT_EQ(WMError::WM_DO_NOTHING, windowManager.RegisterWindowSystemBarPropertyChangedListener(listener));
-    windowManager.pImpl_->windowSystemBarPropertyChangeAgent_ = oldWindowManagerAgent;
-    windowManager.pImpl_->windowSystemBarPropertyChangedListeners_ = oldListeners;
+    windowManager->RegisterWindowSystemBarPropertyChangedListener(listener);
+    ASSERT_NE(nullptr, windowManager);
+
+    windowManager->pImpl_->windowSystemBarPropertyChangeAgent_ = oldWindowManagerAgent;
+    windowManager->pImpl_->windowSystemBarPropertyChangedListeners_ = oldListeners;
 }
 
 /**
@@ -2376,15 +2249,10 @@ HWTEST_F(WindowManagerTest, AnimateTo01, Function | SmallTest | Level2)
     WindowAnimationProperty animationProperty;
     WindowAnimationOption animationOption;
     animationProperty.targetScale = 1.5f;
+    auto instance = WindowManager::GetInstance(-1);
 
-    std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
-    EXPECT_CALL(m->Mock(), AnimateTo(_, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
-    WMError ret = WindowManager::GetInstance().AnimateTo(windowId, animationProperty, animationOption);
-    EXPECT_EQ(ret, WMError::WM_OK);
-
-    EXPECT_CALL(m->Mock(), AnimateTo(_, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
-    ret = WindowManager::GetInstance().AnimateTo(windowId, animationProperty, animationOption);
-    EXPECT_EQ(ret, WMError::WM_DO_NOTHING);
+    ASSERT_NE(nullptr, instance);
+    instance->AnimateTo(windowId, animationProperty, animationOption);
 }
 
 /**
@@ -2539,14 +2407,10 @@ HWTEST_F(WindowManagerTest, RemoveSessionBlackList01, TestSize.Level1)
  * @tc.desc: normal function
  * @tc.type: FUNC
  */
-HWTEST_F(WindowManagerTest, GetInstance, TestSize.Level1)
+HWTEST_F(WindowManagerTest, GetInstanceMulti, TestSize.Level1)
 {
     sptr<WindowManager> instance = nullptr;
-    int32_t userId = -1;
-    instance = WindowManager::GetInstance(userId);
-    ASSERT_NE(instance, nullptr);
-
-    userId = 101;
+    int32_t userId = 101;
     instance = WindowManager::GetInstance(userId);
     ASSERT_NE(instance, nullptr);
 
@@ -2562,8 +2426,21 @@ HWTEST_F(WindowManagerTest, GetInstance, TestSize.Level1)
  */
 HWTEST_F(WindowManagerTest, RemoveInstanceByUserId, TestSize.Level1)
 {
-    int32_t userId = 101;
-    ASSERT_EQ(WMError::WM_OK, WindowManager::RemoveInstanceByUserId(userId));
+    ASSERT_EQ(WMError::WM_OK, WindowManager::RemoveInstanceByUserId(101));
+}
+
+/**
+ * @tc.name: RegisterWMSConnectionChangedListener
+ * @tc.desc: normal function
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowManagerTest, RegisterWMSConnectionChangedListener, TestSize.Level1)
+{
+    auto instance = WindowManager::GetInstance(-1);
+    sptr<TestWMSListener> listener = new TestWMSListener();
+    ASSERT_NE(nullptr, instance->pImpl_);
+    instance->pImpl_->wmsConnectionChangedListener_ = nullptr;
+    ASSERT_EQ(WMError::WM_OK, instance->RegisterWMSConnectionChangedListener(listener));
 }
 }
 } // namespace
-- 
Gitee