From 60708bde6f382c0ed60ec7318bbe49422cf5d822 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=A8=E6=9D=A8?= Date: Mon, 30 Dec 2024 15:13:04 +0800 Subject: [PATCH 1/5] add TDD ut case MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许杨杨 --- .../window_scene_session_impl_layout_test.cpp | 819 ++++++++++++++++++ 1 file changed, 819 insertions(+) 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 e0ff48c920..199daad1c7 100644 --- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp +++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp @@ -17,6 +17,7 @@ #include #include "ability_context_impl.h" +#include "common_test_utils.h" #include "display_info.h" #include "mock_session.h" #include "mock_uicontent.h" @@ -24,8 +25,11 @@ #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 "window_test_utils.h" +#include "wm_common.h" using namespace testing; using namespace testing::ext; @@ -576,6 +580,821 @@ 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 option = sptr::MakeSptr(); + option->SetWindowName("moveWindowTo01"); + option->SetWindowType(WindowType::WINDOW_TYPE_TOAST); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr window = sptr::MakeSptr(option); + if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { + GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; + window->property_->SetPersistentId(10001); + 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(-500, -500); + usleep(WAIT_SERVERAL_FRAMES); + EXPECT_EQ(WMError::WM_OK, ret); + rect = window->property_->GetWindowRect(); + EXPECT_EQ(-500, rect.posX_); + EXPECT_EQ(-500, 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(500, 500); + usleep(WAIT_SERVERAL_FRAMES); + EXPECT_EQ(WMError::WM_OK, ret); + rect = window->property_->GetWindowRect(); + EXPECT_EQ(500, rect.posX_); + EXPECT_EQ(500, rect.posY_); + + ret = window->MoveTo(20000, 20000); + usleep(WAIT_SERVERAL_FRAMES); + EXPECT_EQ(WMError::WM_OK, ret); + rect = window->property_->GetWindowRect(); + EXPECT_EQ(20000, rect.posX_); + EXPECT_EQ(20000, 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 option = sptr::MakeSptr(); + option->SetWindowName("moveWindowTo02"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr window = sptr::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 = sptr::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(10002); + + rectOld = window->property_->GetWindowRect(); + ret = window->MoveTo(-500, -500); + 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(500, 500); + 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 option = sptr::MakeSptr(); + option->SetWindowName("moveWindowTo03"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + + sptr window = sptr::MakeSptr(option); + if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { + GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; + window->property_->SetPersistentId(10003); + + SessionInfo sessionInfo = { "bundleName_moveWindowTo03", + "moduleName_moveWindowTo03", + "abilityName_moveWindowTo03" }; + sptr sceneSession = sptr::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); + + rectOld = window->property_->GetWindowRect(); + ret = window->MoveTo(-500, -500); + 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(500, 500); + 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(20000, 20000); + 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: moveWindowTo04 + * @tc.desc: test moveWindowTo for ALN with windowMode: 100, windowType: 1 + * @tc.type: FUNC + */ +HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest | Level3) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("moveWindowTo04"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); + + sptr window = sptr::MakeSptr(option); + if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { + GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; + window->property_->SetPersistentId(10004); + + SessionInfo sessionInfo = { "bundleName_moveWindowTo04", + "moduleName_moveWindowTo04", + "abilityName_moveWindowTo04" }; + sptr sceneSession = sptr::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); + + rectOld = window->property_->GetWindowRect(); + ret = window->MoveTo(-500, -500); + 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(500, 500); + 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(20000, 20000); + 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: resize01 + * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2107 + * @tc.type: FUNC + */ +HWTEST_F(WindowSceneSessionImplLayoutTest, resize01, Function | MediumTest | Level3) +{ + sptr option = sptr::MakeSptr(); + option->SetWindowName("resize01"); + option->SetWindowType(WindowType::WINDOW_TYPE_TOAST); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr window = sptr::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(-500, -500); + 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(500, 500); + EXPECT_EQ(WMError::WM_OK, ret); + usleep(WAIT_SERVERAL_FRAMES); + rect = window->property_->GetWindowRect(); + EXPECT_EQ(500, rect.width_); + EXPECT_EQ(500, rect.height_); + + ret = window->Resize(20000, 20000); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize02"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + + sptr window = sptr::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 = sptr::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(500, 500); + EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); + + ret = window->Resize(20000, 20000); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize03"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + + sptr window = sptr::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 = sptr::MakeSptr(sessionInfo, nullptr); + + WMError ret; + ret = window->Create(abilityContext_, sceneSession); + EXPECT_EQ(WMError::WM_OK, ret); + window->property_->SetPersistentId(100010); + ret = window->Show(); + EXPECT_EQ(WMError::WM_OK, ret); + + ret = window->Resize(500, 500); + EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); + + ret = window->Resize(20000, 20000); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize04"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); + + sptr window = sptr::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 = sptr::MakeSptr(sessionInfo, nullptr); + + WMError ret; + ret = window->Create(abilityContext_, sceneSession); + EXPECT_EQ(WMError::WM_OK, ret); + window->property_->SetPersistentId(100011); + ret = window->Show(); + EXPECT_EQ(WMError::WM_OK, ret); + + ret = window->Resize(500, 500); + EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); + + ret = window->Resize(20000, 20000); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize05"); + option->SetWindowType(WindowType::WINDOW_TYPE_TOAST); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr window = sptr::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 option = sptr::MakeSptr(); + option->SetWindowName("resize06"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + + sptr window = sptr::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 = sptr::MakeSptr(sessionInfo, nullptr); + + WMError ret; + ret = window->Create(abilityContext_, sceneSession); + EXPECT_EQ(WMError::WM_OK, ret); + window->property_->SetPersistentId(100013); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize07"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + + sptr window = sptr::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 = sptr::MakeSptr(sessionInfo, nullptr); + + WMError ret; + ret = window->Create(abilityContext_, sceneSession); + EXPECT_EQ(WMError::WM_OK, ret); + window->property_->SetPersistentId(100014); + 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 option = sptr::MakeSptr(); + option->SetWindowName("resize08"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); + + sptr window = sptr::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 = sptr::MakeSptr(sessionInfo, nullptr); + + WMError ret; + ret = window->Create(abilityContext_, sceneSession); + EXPECT_EQ(WMError::WM_OK, ret); + window->property_->SetPersistentId(100015); + 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 option = sptr::MakeSptr(); + option->SetWindowName("SetWindowLimitsDataRoute"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr windowSceneSessionImpl = sptr::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 session = sptr::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 option = sptr::MakeSptr(); + option->SetWindowName("SetAspectRatioDataRoute"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + + sptr windowSceneSessionImpl = sptr::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 session = sptr::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 option = sptr::MakeSptr(); + option->SetWindowName("moveToDataRoute"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + sptr windowSceneSessionImpl = sptr::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 session = sptr::MakeSptr(sessionInfo); + + windowSceneSessionImpl->hostSession_ = session; + windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN; + + WMError ret = windowSceneSessionImpl->MoveTo(500, 500); + usleep(WAIT_SERVERAL_FRAMES); + EXPECT_EQ(WMError::WM_OK, ret); + + Rect rect = windowSceneSessionImpl->property_->GetRequestRect(); + EXPECT_EQ(500, rect.posX_); + EXPECT_EQ(500, 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 option = sptr::MakeSptr(); + option->SetWindowName("ResizeDataRoute"); + option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + sptr windowSceneSessionImpl = sptr::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 session = sptr::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(500, 500); + EXPECT_EQ(WMError::WM_OK, ret); + + Rect rect = windowSceneSessionImpl->property_->GetRequestRect(); + EXPECT_EQ(500, rect.width_); + EXPECT_EQ(500, 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(500, rect2.width_); + EXPECT_EQ(500, 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 option = sptr::MakeSptr(); + option->SetWindowName("AdjustRectByAspectRatio"); + option->SetWindowType(WindowType::APP_WINDOW_BASE); + option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + sptr windowSceneSessionImpl = sptr::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 session = sptr::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 -- Gitee From ca6202c1c0e9f56f509add903df8dbdc487f4553 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=A8=E6=9D=A8?= Date: Mon, 30 Dec 2024 07:33:52 +0000 Subject: [PATCH 2/5] update wm/test/unittest/window_scene_session_impl_layout_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许杨杨 --- wm/test/unittest/window_scene_session_impl_layout_test.cpp | 2 -- 1 file changed, 2 deletions(-) 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 199daad1c7..79e93a28e9 100644 --- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp +++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp @@ -17,7 +17,6 @@ #include #include "ability_context_impl.h" -#include "common_test_utils.h" #include "display_info.h" #include "mock_session.h" #include "mock_uicontent.h" @@ -28,7 +27,6 @@ #include "window_adapter.h" #include "window_scene_session_impl.h" #include "window_session_impl.h" -#include "window_test_utils.h" #include "wm_common.h" using namespace testing; -- Gitee From a69650986c2626eed0469d91a8e78cb3b723ee17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=A8=E6=9D=A8?= Date: Mon, 30 Dec 2024 08:17:10 +0000 Subject: [PATCH 3/5] update wm/test/unittest/window_scene_session_impl_layout_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许杨杨 --- .../window_scene_session_impl_layout_test.cpp | 12 ------------ 1 file changed, 12 deletions(-) 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 79e93a28e9..9300c72670 100644 --- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp +++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp @@ -711,12 +711,10 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; window->property_->SetPersistentId(10003); - SessionInfo sessionInfo = { "bundleName_moveWindowTo03", "moduleName_moveWindowTo03", "abilityName_moveWindowTo03" }; sptr sceneSession = sptr::MakeSptr(sessionInfo, nullptr); - Rect rectOld; Rect rectNow; WMError ret; @@ -724,7 +722,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest EXPECT_EQ(WMError::WM_OK, ret); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(-500, -500); usleep(WAIT_SERVERAL_FRAMES); @@ -732,7 +729,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest 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); @@ -740,7 +736,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest rectNow = window->property_->GetWindowRect(); EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(500, 500); usleep(WAIT_SERVERAL_FRAMES); @@ -748,7 +743,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest rectNow = window->property_->GetWindowRect(); EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(20000, 20000); usleep(WAIT_SERVERAL_FRAMES); @@ -778,12 +772,10 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; window->property_->SetPersistentId(10004); - SessionInfo sessionInfo = { "bundleName_moveWindowTo04", "moduleName_moveWindowTo04", "abilityName_moveWindowTo04" }; sptr sceneSession = sptr::MakeSptr(sessionInfo, nullptr); - Rect rectOld; Rect rectNow; WMError ret; @@ -791,7 +783,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest EXPECT_EQ(WMError::WM_OK, ret); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(-500, -500); usleep(WAIT_SERVERAL_FRAMES); @@ -799,7 +790,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest 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); @@ -807,7 +797,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest rectNow = window->property_->GetWindowRect(); EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(500, 500); usleep(WAIT_SERVERAL_FRAMES); @@ -815,7 +804,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest rectNow = window->property_->GetWindowRect(); EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); - rectOld = window->property_->GetWindowRect(); ret = window->MoveTo(20000, 20000); usleep(WAIT_SERVERAL_FRAMES); -- Gitee From fca32a31b06036f4d940ae3303eb412d20d0579f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=A8=E6=9D=A8?= Date: Mon, 30 Dec 2024 08:57:19 +0000 Subject: [PATCH 4/5] update wm/test/unittest/window_scene_session_impl_layout_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许杨杨 --- .../window_scene_session_impl_layout_test.cpp | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) 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 9300c72670..a8f0595f2f 100644 --- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp +++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp @@ -717,8 +717,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest sptr sceneSession = sptr::MakeSptr(sessionInfo, nullptr); Rect rectOld; Rect rectNow; - WMError ret; - ret = window->Create(abilityContext_, sceneSession); + WMError ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); @@ -747,9 +746,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest ret = window->MoveTo(20000, 20000); 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); @@ -778,8 +774,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest sptr sceneSession = sptr::MakeSptr(sessionInfo, nullptr); Rect rectOld; Rect rectNow; - WMError ret; - ret = window->Create(abilityContext_, sceneSession); + WMError ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); @@ -808,9 +803,6 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest ret = window->MoveTo(20000, 20000); 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); -- Gitee From 69709fa1c3531f238374555e8a24d952c59e8fb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=A8=E6=9D=A8?= Date: Tue, 31 Dec 2024 03:56:39 +0000 Subject: [PATCH 5/5] update wm/test/unittest/window_scene_session_impl_layout_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许杨杨 --- .../window_scene_session_impl_layout_test.cpp | 90 +++++++++---------- 1 file changed, 45 insertions(+), 45 deletions(-) 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 a8f0595f2f..5d8eb63062 100644 --- a/wm/test/unittest/window_scene_session_impl_layout_test.cpp +++ b/wm/test/unittest/window_scene_session_impl_layout_test.cpp @@ -594,7 +594,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo01, Function | MediumTest sptr window = sptr::MakeSptr(option); if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; - window->property_->SetPersistentId(10001); + window->property_->SetPersistentId(11111); Rect rect; WMError ret; ret = window->Create(abilityContext_, nullptr); @@ -603,12 +603,12 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo01, Function | MediumTest ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - ret = window->MoveTo(-500, -500); + ret = window->MoveTo(-300, -300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rect = window->property_->GetWindowRect(); - EXPECT_EQ(-500, rect.posX_); - EXPECT_EQ(-500, rect.posY_); + EXPECT_EQ(-300, rect.posX_); + EXPECT_EQ(-300, rect.posY_); ret = window->MoveTo(0, 0); usleep(WAIT_SERVERAL_FRAMES); @@ -617,19 +617,19 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo01, Function | MediumTest EXPECT_EQ(0, rect.posX_); EXPECT_EQ(0, rect.posY_); - ret = window->MoveTo(500, 500); + ret = window->MoveTo(300, 300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rect = window->property_->GetWindowRect(); - EXPECT_EQ(500, rect.posX_); - EXPECT_EQ(500, rect.posY_); + EXPECT_EQ(300, rect.posX_); + EXPECT_EQ(300, rect.posY_); - ret = window->MoveTo(20000, 20000); + ret = window->MoveTo(15000, 15000); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rect = window->property_->GetWindowRect(); - EXPECT_EQ(20000, rect.posX_); - EXPECT_EQ(20000, rect.posY_); + 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); @@ -664,10 +664,10 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo02, Function | MediumTest EXPECT_EQ(WMError::WM_OK, ret); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(10002); + window->property_->SetPersistentId(22222); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(-500, -500); + ret = window->MoveTo(-300, -300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rectNow = window->property_->GetWindowRect(); @@ -683,7 +683,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo02, Function | MediumTest EXPECT_EQ(rectOld.posY_, rectNow.posY_); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(500, 500); + ret = window->MoveTo(300, 300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rectNow = window->property_->GetWindowRect(); @@ -710,7 +710,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest sptr window = sptr::MakeSptr(option); if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; - window->property_->SetPersistentId(10003); + window->property_->SetPersistentId(33333); SessionInfo sessionInfo = { "bundleName_moveWindowTo03", "moduleName_moveWindowTo03", "abilityName_moveWindowTo03" }; @@ -722,7 +722,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(-500, -500); + ret = window->MoveTo(-300, -300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rectNow = window->property_->GetWindowRect(); @@ -736,14 +736,14 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo03, Function | MediumTest EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(500, 500); + 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(20000, 20000); + ret = window->MoveTo(15000, 15000); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); } else { @@ -767,7 +767,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest sptr window = sptr::MakeSptr(option); if (window->windowSystemConfig_.windowUIType_ == WindowUIType::PHONE_WINDOW) { GTEST_LOG_(INFO) << "windowUIType = WindowUIType::PHONE_WINDOW"; - window->property_->SetPersistentId(10004); + window->property_->SetPersistentId(44444); SessionInfo sessionInfo = { "bundleName_moveWindowTo04", "moduleName_moveWindowTo04", "abilityName_moveWindowTo04" }; @@ -779,7 +779,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(-500, -500); + ret = window->MoveTo(-300, -300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); rectNow = window->property_->GetWindowRect(); @@ -793,14 +793,14 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveWindowTo04, Function | MediumTest EXPECT_EQ(rectOld.posX_, rectNow.posX_); EXPECT_EQ(rectOld.posY_, rectNow.posY_); rectOld = window->property_->GetWindowRect(); - ret = window->MoveTo(500, 500); + 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(20000, 20000); + ret = window->MoveTo(15000, 15000); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); } else { @@ -836,21 +836,21 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize01, Function | MediumTest | Lev ret = window->GetWindowLimits(windowLimits); EXPECT_EQ(WMError::WM_OK, ret); - ret = window->Resize(-500, -500); + 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(500, 500); + ret = window->Resize(300, 300); EXPECT_EQ(WMError::WM_OK, ret); usleep(WAIT_SERVERAL_FRAMES); rect = window->property_->GetWindowRect(); - EXPECT_EQ(500, rect.width_); - EXPECT_EQ(500, rect.height_); + EXPECT_EQ(300, rect.width_); + EXPECT_EQ(300, rect.height_); - ret = window->Resize(20000, 20000); + ret = window->Resize(15000, 15000); EXPECT_EQ(WMError::WM_OK, ret); usleep(WAIT_SERVERAL_FRAMES); rect = window->property_->GetWindowRect(); @@ -890,10 +890,10 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize02, Function | MediumTest | Lev ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - ret = window->Resize(500, 500); + ret = window->Resize(300, 300); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); - ret = window->Resize(20000, 20000); + ret = window->Resize(15000, 15000); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); ret = window->Resize(0, 0); @@ -925,14 +925,14 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize03, Function | MediumTest | Lev WMError ret; ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(100010); + window->property_->SetPersistentId(10010); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - ret = window->Resize(500, 500); + ret = window->Resize(300, 300); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); - ret = window->Resize(20000, 20000); + ret = window->Resize(15000, 15000); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); ret = window->Resize(0, 0); @@ -964,14 +964,14 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize04, Function | MediumTest | Lev WMError ret; ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(100011); + window->property_->SetPersistentId(10011); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); - ret = window->Resize(500, 500); + ret = window->Resize(300, 300); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); - ret = window->Resize(20000, 20000); + ret = window->Resize(15000, 15000); EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); ret = window->Resize(0, 0); @@ -1048,7 +1048,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize06, Function | MediumTest | Lev WMError ret; ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(100013); + window->property_->SetPersistentId(10013); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); @@ -1087,7 +1087,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize07, Function | MediumTest | Lev WMError ret; ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(100014); + window->property_->SetPersistentId(10014); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); @@ -1126,7 +1126,7 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, resize08, Function | MediumTest | Lev WMError ret; ret = window->Create(abilityContext_, sceneSession); EXPECT_EQ(WMError::WM_OK, ret); - window->property_->SetPersistentId(100015); + window->property_->SetPersistentId(10015); ret = window->Show(); EXPECT_EQ(WMError::WM_OK, ret); @@ -1249,13 +1249,13 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, moveToDataRoute, Function | MediumTes windowSceneSessionImpl->hostSession_ = session; windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN; - WMError ret = windowSceneSessionImpl->MoveTo(500, 500); + WMError ret = windowSceneSessionImpl->MoveTo(300, 300); usleep(WAIT_SERVERAL_FRAMES); EXPECT_EQ(WMError::WM_OK, ret); Rect rect = windowSceneSessionImpl->property_->GetRequestRect(); - EXPECT_EQ(500, rect.posX_); - EXPECT_EQ(500, rect.posY_); + 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); @@ -1289,12 +1289,12 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, ResizeDataRoute, Function | MediumTes windowSceneSessionImpl->hostSession_ = session; windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN; - WMError ret = windowSceneSessionImpl->Resize(500, 500); + WMError ret = windowSceneSessionImpl->Resize(300, 300); EXPECT_EQ(WMError::WM_OK, ret); Rect rect = windowSceneSessionImpl->property_->GetRequestRect(); - EXPECT_EQ(500, rect.width_); - EXPECT_EQ(500, rect.height_); + 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); @@ -1302,8 +1302,8 @@ HWTEST_F(WindowSceneSessionImplLayoutTest, ResizeDataRoute, Function | MediumTes usleep(WAIT_SERVERAL_FRAMES); Rect rect2 = session->property_->GetRequestRect(); - EXPECT_EQ(500, rect2.width_); - EXPECT_EQ(500, rect2.height_); + 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); -- Gitee