diff --git a/wm/test/unittest/window_scene_session_impl_layout_test.cpp b/wm/test/unittest/window_scene_session_impl_layout_test.cpp
index e0ff48c920a78a3f7d2faeb75d385c620ba66e20..5d8eb630625937e02174d43a55ccc2b0d077801e 100644
--- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp
+++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp
@@ -24,8 +24,10 @@
 #include "scene_board_judgement.h"
 #include "session/host/include/scene_session.h"
 #include "singleton_mocker.h"
+#include "window_adapter.h"
 #include "window_scene_session_impl.h"
 #include "window_session_impl.h"
+#include "wm_common.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -576,6 +578,801 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, MoveTo03, Function | SmallTest | Leve
     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 4));
     WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
 }
+
+/**
+ * @tc.name: moveWindowTo01
+ * @tc.desc: test moveWindowTo for ALN/PC with windowMode: 102, windowType: 2107
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo01, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("moveWindowTo01");
+    option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        window->property_->SetPersistentId(11111);
+        Rect rect;
+        WMError ret;
+        ret = window->Create(abilityContext_, nullptr);
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->MoveTo(-300, -300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(-300, rect.posX_);
+        EXPECT_EQ(-300, rect.posY_);
+
+        ret = window->MoveTo(0, 0);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(0, rect.posX_);
+        EXPECT_EQ(0, rect.posY_);
+
+        ret = window->MoveTo(300, 300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(300, rect.posX_);
+        EXPECT_EQ(300, rect.posY_);
+
+        ret = window->MoveTo(15000, 15000);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(15000, rect.posX_);
+        EXPECT_EQ(15000, rect.posY_);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: moveWindowTo02
+ * @tc.desc: test moveWindowTo for ALN with windowMode: 102, windowType: 1001
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo02, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("moveWindowTo02");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+
+        SessionInfo sessionInfo = { "bundleName_moveWindowTo02",
+                                    "moduleName_moveWindowTo02",
+                                    "abilityName_moveWindowTo02" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        Rect rectOld;
+        Rect rectNow;
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(22222);
+
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(-300, -300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(0, 0);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(300, 300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: moveWindowTo03
+ * @tc.desc: test moveWindowTo for ALN with windowMode: 1, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("moveWindowTo03");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        window->property_->SetPersistentId(33333);
+        SessionInfo sessionInfo = { "bundleName_moveWindowTo03",
+                                    "moduleName_moveWindowTo03",
+                                    "abilityName_moveWindowTo03" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+        Rect rectOld;
+        Rect rectNow;
+        WMError ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(-300, -300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(0, 0);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(300, 300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(15000, 15000);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: moveWindowTo04
+ * @tc.desc: test moveWindowTo for ALN with windowMode: 100, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("moveWindowTo04");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        window->property_->SetPersistentId(44444);
+        SessionInfo sessionInfo = { "bundleName_moveWindowTo04",
+                                    "moduleName_moveWindowTo04",
+                                    "abilityName_moveWindowTo04" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+        Rect rectOld;
+        Rect rectNow;
+        WMError ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(-300, -300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(0, 0);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(300, 300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        rectNow = window->property_->GetWindowRect();
+        EXPECT_EQ(rectOld.posX_, rectNow.posX_);
+        EXPECT_EQ(rectOld.posY_, rectNow.posY_);
+        rectOld = window->property_->GetWindowRect();
+        ret = window->MoveTo(15000, 15000);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize01
+ * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2107
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize01, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize01");
+    option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        Rect rect;
+        WMError ret;
+        ret = window->Create(abilityContext_, nullptr);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10008);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        WindowLimits windowLimits;
+        ret = window->GetWindowLimits(windowLimits);
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->Resize(-300, -300);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        usleep(WAIT_SERVERAL_FRAMES);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
+        EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
+
+        ret = window->Resize(300, 300);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        usleep(WAIT_SERVERAL_FRAMES);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(300, rect.width_);
+        EXPECT_EQ(300, rect.height_);
+
+        ret = window->Resize(15000, 15000);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        usleep(WAIT_SERVERAL_FRAMES);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
+        EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
+
+        ret = window->Resize(0, 0);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize02
+ * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize02, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize02");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize02", "moduleName_resize02", "abilityName_resize02" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10009);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->Resize(300, 300);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(15000, 15000);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(0, 0);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize03
+ * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize03, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize03");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize03", "moduleName_resize03", "abilityName_resize03" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10010);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->Resize(300, 300);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(15000, 15000);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(0, 0);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize04
+ * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize04, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize04");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize04", "moduleName_resize04", "abilityName_resize04" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10011);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        ret = window->Resize(300, 300);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(15000, 15000);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(0, 0);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize05
+ * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2107
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize05, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize05");
+    option->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        Rect rect;
+        WMError ret;
+        ret = window->Create(abilityContext_, nullptr);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10012);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        WindowLimits windowLimits;
+        ret = window->GetWindowLimits(windowLimits);
+
+        ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        usleep(WAIT_SERVERAL_FRAMES);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(windowLimits.maxWidth_ - 100, rect.width_);
+        EXPECT_EQ(windowLimits.maxHeight_ - 100, rect.height_);
+
+        ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        usleep(WAIT_SERVERAL_FRAMES);
+        rect = window->property_->GetWindowRect();
+        EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
+        EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize06
+ * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize06, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize06");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize06", "moduleName_resize06", "abilityName_resize06" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10013);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        WindowLimits windowLimits;
+        ret = window->GetWindowLimits(windowLimits);
+
+        ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize07
+ * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize07, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize07");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize07", "moduleName_resize07", "abilityName_resize07" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10014);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        WindowLimits windowLimits;
+        ret = window->GetWindowLimits(windowLimits);
+
+        ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+
+        ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: resize08
+ * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, resize08, Function | MediumTest | Level3)
+{
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("resize08");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
+
+    sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        SessionInfo sessionInfo = { "bundleName_resize08", "moduleName_resize08", "abilityName_resize08" };
+        sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+
+        WMError ret;
+        ret = window->Create(abilityContext_, sceneSession);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        window->property_->SetPersistentId(10015);
+        ret = window->Show();
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        WindowLimits windowLimits;
+        ret = window->GetWindowLimits(windowLimits);
+
+        ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+        ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
+        EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(window->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: SetWindowLimitsDataRoute
+ * @tc.desc: test data route for SetWindowLimits
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, SetWindowLimitsDataRoute, Function | MediumTest | Level3)
+{
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### begin ###");
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("SetWindowLimitsDataRoute");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (windowSceneSessionImpl->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        windowSceneSessionImpl->property_->SetPersistentId(1);
+        windowSceneSessionImpl->property_->SetDisplayId(0);
+
+        SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
+        sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
+
+        windowSceneSessionImpl->hostSession_ = session;
+        windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
+
+        WindowLimits windowLimits1 = { 4000, 4000, 2000, 2000, 0.0f, 0.0f };
+        WMError ret = windowSceneSessionImpl->SetWindowLimits(windowLimits1);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        auto windowProperty = windowSceneSessionImpl->GetProperty();
+        ASSERT_NE(nullptr, windowProperty);
+
+        WindowLimits windowLimits2 = windowProperty->GetWindowLimits();
+        EXPECT_EQ(windowLimits1.maxWidth_, windowLimits2.maxWidth_);
+        EXPECT_EQ(windowLimits1.maxHeight_, windowLimits2.maxHeight_);
+        EXPECT_EQ(windowLimits1.minWidth_, windowLimits2.minWidth_);
+        EXPECT_EQ(windowLimits1.minHeight_, windowLimits2.minHeight_);
+        TLOGI(WmsLogTag::WMS_LAYOUT, "### end ###");
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(windowSceneSessionImpl->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+}
+
+/**
+ * @tc.name: SetAspectRatioDataRoute
+ * @tc.desc: test data route for SetAspectRatioDataRoute
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, SetAspectRatioDataRoute, Function | MediumTest | Level3)
+{
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### begin ###");
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("SetAspectRatioDataRoute");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+
+    sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (windowSceneSessionImpl->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        windowSceneSessionImpl->property_->SetPersistentId(1);
+        windowSceneSessionImpl->property_->SetDisplayId(0);
+
+        SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
+        sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
+
+        windowSceneSessionImpl->hostSession_ = session;
+        windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
+
+        WindowLimits windowLimits1 = { 4000, 4000, 2000, 2000, 0.0f, 0.0f };
+        WMError ret = windowSceneSessionImpl->SetWindowLimits(windowLimits1);
+        EXPECT_EQ(WMError::WM_OK, ret);
+        const float ratio = 1.5;
+
+        ret = windowSceneSessionImpl->SetAspectRatio(ratio);
+        EXPECT_EQ(WMError::WM_OK, ret);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(windowSceneSessionImpl->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### end ###");
+}
+
+/**
+ * @tc.name: moveToDataRoute
+ * @tc.desc: test data route for moveTo
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, moveToDataRoute, Function | MediumTest | Level3)
+{
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### begin ###");
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("moveToDataRoute");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+    sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (windowSceneSessionImpl->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        windowSceneSessionImpl->property_->SetPersistentId(1);
+        windowSceneSessionImpl->property_->SetDisplayId(0);
+
+        SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
+        sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
+
+        windowSceneSessionImpl->hostSession_ = session;
+        windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
+
+        WMError ret = windowSceneSessionImpl->MoveTo(300, 300);
+        usleep(WAIT_SERVERAL_FRAMES);
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
+        EXPECT_EQ(300, rect.posX_);
+        EXPECT_EQ(300, rect.posY_);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(windowSceneSessionImpl->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### end ###");
+}
+
+/**
+ * @tc.name: ResizeDataRoute
+ * @tc.desc: test data route for Resize
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, ResizeDataRoute, Function | MediumTest | Level3)
+{
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### begin ###");
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("ResizeDataRoute");
+    option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+    sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (windowSceneSessionImpl->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        windowSceneSessionImpl->property_->SetPersistentId(1);
+        windowSceneSessionImpl->property_->SetDisplayId(0);
+
+        SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
+        sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+        session->isActive_ = true;
+        session->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
+        session->SetSessionState(SessionState::STATE_FOREGROUND);
+        windowSceneSessionImpl->hostSession_ = session;
+        windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
+
+        WMError ret = windowSceneSessionImpl->Resize(300, 300);
+        EXPECT_EQ(WMError::WM_OK, ret);
+
+        Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
+        EXPECT_EQ(300, rect.width_);
+        EXPECT_EQ(300, rect.height_);
+
+        WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
+        WSError ret2 = session->UpdateSessionRect(wsRect, SizeChangeReason::RESIZE, false);
+        EXPECT_EQ(WSError::WS_OK, ret2);
+
+        usleep(WAIT_SERVERAL_FRAMES);
+        Rect rect2 = session->property_->GetRequestRect();
+        EXPECT_EQ(300, rect2.width_);
+        EXPECT_EQ(300, rect2.height_);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(windowSceneSessionImpl->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### end ###");
+}
+
+/**
+ * @tc.name: AdjustRectByAspectRatio
+ * @tc.desc: test AdjustRectByAspectRatio
+ * @tc.type: FUNC
+ */
+HWTEST_F(WindowSceneSessionImplLayoutTest, AdjustRectByAspectRatio, Function | MediumTest | Level0)
+{
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### begin ###");
+    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
+    option->SetWindowName("AdjustRectByAspectRatio");
+    option->SetWindowType(WindowType::APP_WINDOW_BASE);
+    option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+    sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
+    if (windowSceneSessionImpl->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) {
+        GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW";
+        windowSceneSessionImpl->property_->SetPersistentId(1);
+        windowSceneSessionImpl->property_->SetDisplayId(0);
+
+        SessionInfo sessionInfo = { "CeateTestBundle", "CreateTestModule", "CreateTestAbility" };
+        sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
+        session->isActive_ = true;
+        session->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
+        session->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
+        session->SetSessionState(SessionState::STATE_FOREGROUND);
+
+        windowSceneSessionImpl->hostSession_ = session;
+        windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
+
+        WindowLimits windowLimits1 = { 3000, 3000, 1200, 1200, 0.0f, 0.0f };
+        WMError wmRet1 = windowSceneSessionImpl->SetWindowLimits(windowLimits1);
+        EXPECT_EQ(WMError::WM_OK, wmRet1);
+
+        WMError wmRet2 = windowSceneSessionImpl->Resize(1600, 1600);
+        EXPECT_EQ(WMError::WM_OK, wmRet2);
+
+        float ratio = 0.8;
+        WMError wmRet3 = windowSceneSessionImpl->SetAspectRatio(ratio);
+        EXPECT_EQ(WMError::WM_OK, wmRet3);
+
+        // 服务端执行相同的逻辑
+        auto property = windowSceneSessionImpl->property_;
+        WSPropertyChangeAction action = WSPropertyChangeAction::ACTION_UPDATE_WINDOW_LIMITS;
+        WMError wsRet1 = session->UpdateSessionPropertyByAction(property, action);
+        EXPECT_EQ(WMError::WM_OK, wsRet1);
+
+        Rect rect = windowSceneSessionImpl->property_->GetRequestRect();
+        WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
+        // 异步接口加一个延迟
+        WSError wsRet2 = session->UpdateSessionRect(wsRect, SizeChangeReason::RESIZE, false);
+        EXPECT_EQ(WSError::WS_OK, wsRet2);
+        usleep(WAIT_SERVERAL_FRAMES);
+        WSError wsRet3 = session->UpdateRect(wsRect, SizeChangeReason::RESIZE, "AdjustRectByAspectRatio", nullptr);
+        EXPECT_EQ(WSError::WS_OK, wsRet3);
+        usleep(WAIT_SERVERAL_FRAMES);
+        WSError wsRet4 = session->SetAspectRatio(ratio);
+        EXPECT_EQ(WSError::WS_OK, wsRet4);
+    } else {
+        GTEST_LOG_(INFO) << "windowUIType != WindowUIType::PHONE_WINDOW";
+        ASSERT_NE(windowSceneSessionImpl->windowSystemConfig_.windowUIType_, WindowUIType::PHONE_WINDOW);
+    }
+    TLOGI(WmsLogTag::WMS_LAYOUT, "### end ###");
+}
 } // namespace
 } // namespace Rosen
 } // namespace OHOS