1/* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16// gtest 17#include <gtest/gtest.h> 18#include "common_test_utils.h" 19#include "window_test_utils.h" 20#include "wm_common.h" 21#include "window_adapter.h" 22#include "window_scene_session_impl.h" 23#include "ability_context_impl.h" 24#include "mock_session.h" 25#include "session/host/include/scene_session.h" 26 27 28using namespace testing; 29using namespace testing::ext; 30 31namespace OHOS { 32namespace Rosen { 33using Utils = WindowTestUtils; 34class WindowLayoutTest : public testing::Test { 35public: 36 static void SetUpTestCase(); 37 static void TearDownTestCase(); 38 virtual void SetUp() override; 39 virtual void TearDown() override; 40 DisplayId displayId_ = 0; 41 std::vector<sptr<Window>> activeWindows_; 42 static vector<Rect> fullScreenExpecteds_; 43 static inline float virtualPixelRatio_ = 0.0; 44private: 45 static constexpr uint32_t WAIT_SYANC_US = 100000; 46 static constexpr uint32_t WAIT_SERVERAL_FRAMES = 36000; 47 static constexpr uint32_t WAIT_SYANC_S = 1; // second; 48 static void InitAvoidArea(); 49 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_; 50}; 51 52vector<Rect> WindowLayoutTest::fullScreenExpecteds_; 53 54void WindowLayoutTest::SetUpTestCase() 55{ 56 SingletonContainer::Get<WindowAdapter>().MinimizeAllAppWindows(0); 57 sleep(2); 58 auto display = DisplayManager::GetInstance().GetDisplayById(0); 59 ASSERT_NE(display, nullptr); 60 ASSERT_TRUE((display != nullptr)); 61 Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()}; 62 Utils::InitByDisplayRect(displayRect); 63 64 virtualPixelRatio_ = WindowTestUtils::GetVirtualPixelRatio(0); 65 66 // calc expected rects 67 Rect expected = { // 0. only statusBar 68 0, 69 Utils::statusBarRect_.height_, 70 Utils::displayRect_.width_, 71 Utils::displayRect_.height_ - Utils::statusBarRect_.height_, 72 }; 73 fullScreenExpecteds_.push_back(expected); 74 expected = { // 1. both statusBar and naviBar 75 0, 76 Utils::statusBarRect_.height_, 77 Utils::displayRect_.width_, 78 Utils::displayRect_.height_ - Utils::statusBarRect_.height_ - Utils::naviBarRect_.height_, 79 }; 80 fullScreenExpecteds_.push_back(expected); 81 expected = { // 2. only naviBar 82 0, 83 0, 84 Utils::displayRect_.width_, 85 Utils::displayRect_.height_ - Utils::naviBarRect_.height_, 86 }; 87 fullScreenExpecteds_.push_back(expected); 88 InitAvoidArea(); 89 sleep(2); 90} 91 92void WindowLayoutTest::InitAvoidArea() 93{ 94 Utils::TestWindowInfo info = { 95 .name = "avoidArea", 96 .rect = {0, 0, 0, 0}, 97 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 98 .mode = WindowMode::WINDOW_MODE_FLOATING, 99 .needAvoid = true, 100 .parentLimit = false, 101 .parentId = INVALID_WINDOW_ID, 102 }; 103 const sptr<Window>& window = Utils::CreateTestWindow(info); 104 ASSERT_NE(window, nullptr); 105 window->Show(); 106 window->SetLayoutFullScreen(true); 107 window->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM, WindowTestUtils::systemAvoidArea_); 108 window->Hide(); 109 window->Destroy(); 110} 111 112void WindowLayoutTest::TearDownTestCase() 113{ 114} 115 116void WindowLayoutTest::SetUp() 117{ 118 activeWindows_.clear(); 119 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 120 CommonTestUtils::GuaranteeFloatWindowPermission("wms_window_app_floating_window_test"); 121} 122 123void WindowLayoutTest::TearDown() 124{ 125 for (auto window: activeWindows_) { 126 window->Destroy(); 127 } 128 sleep(WAIT_SYANC_S); 129 abilityContext_ = nullptr; 130} 131 132namespace { 133/** 134 * @tc.name: LayoutWindow01 135 * @tc.desc: One FLOATING APP Window with on custom rect 136 * @tc.type: FUNC 137 */ 138HWTEST_F(WindowLayoutTest, LayoutWindow01, Function | MediumTest | Level3) 139{ 140 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE); 141 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 142 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE); 143 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 144 145 Utils::TestWindowInfo info = { 146 .name = "main1", 147 .rect = {0, 0, 0, 0}, 148 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 149 .mode = WindowMode::WINDOW_MODE_FLOATING, 150 .needAvoid = true, 151 .parentLimit = false, 152 .showWhenLocked = true, 153 .parentId = INVALID_WINDOW_ID, 154 }; 155 const sptr<Window>& window = Utils::CreateTestWindow(info); 156 ASSERT_NE(window, nullptr); 157 ASSERT_EQ(true, window != nullptr); 158 activeWindows_.push_back(window); 159 Rect expect = Utils::GetDefaultFloatingRect(window, true); 160 ASSERT_EQ(WMError::WM_OK, window->Show()); 161 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::GetFloatingLimitedRect(expect, virtualPixelRatio_))); 162 ASSERT_EQ(WMError::WM_OK, window->Hide()); 163} 164 165/** 166 * @tc.name: LayoutWindow02 167 * @tc.desc: One FLOATING APP Window 168 * @tc.type: FUNC 169 */ 170HWTEST_F(WindowLayoutTest, LayoutWindow02, Function | MediumTest | Level3) 171{ 172 Rect res = Utils::GetFloatingLimitedRect(Utils::customAppRect_, virtualPixelRatio_); 173 Utils::TestWindowInfo info = { 174 .name = "main2", 175 .rect = res, 176 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 177 .mode = WindowMode::WINDOW_MODE_FLOATING, 178 .needAvoid = true, 179 .parentLimit = false, 180 .showWhenLocked = true, 181 .parentId = INVALID_WINDOW_ID, 182 }; 183 const sptr<Window>& window = Utils::CreateTestWindow(info); 184 ASSERT_NE(window, nullptr); 185 activeWindows_.push_back(window); 186 187 ASSERT_EQ(WMError::WM_OK, window->Show()); 188 if (window->IsDecorEnable()) { 189 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::GetDecorateRect(res, virtualPixelRatio_))); 190 } else { 191 ASSERT_TRUE(Utils::RectEqualTo(window, res)); 192 } 193 ASSERT_EQ(WMError::WM_OK, window->Hide()); 194} 195 196/** 197 * @tc.name: LayoutWindow04 198 * @tc.desc: One FLOATING APP Window & One StatusBar Window 199 * @tc.type: FUNC 200 */ 201HWTEST_F(WindowLayoutTest, LayoutWindow04, Function | MediumTest | Level3) 202{ 203 // app window 204 Rect res = Utils::GetFloatingLimitedRect(Utils::customAppRect_, virtualPixelRatio_); 205 Utils::TestWindowInfo info = { 206 .name = "main4", 207 .rect = res, 208 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 209 .mode = WindowMode::WINDOW_MODE_FLOATING, 210 .needAvoid = true, 211 .parentLimit = false, 212 .showWhenLocked = true, 213 .parentId = INVALID_WINDOW_ID, 214 }; 215 sptr<Window> appWin = Utils::CreateTestWindow(info); 216 ASSERT_NE(appWin, nullptr); 217 218 activeWindows_.push_back(appWin); 219 220 // statusBar window 221 sptr<Window> statBar = Utils::CreateStatusBarWindow(); 222 activeWindows_.push_back(statBar); 223 224 ASSERT_EQ(WMError::WM_OK, appWin->Show()); 225 if (appWin->IsDecorEnable()) { 226 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_))); 227 } else { 228 ASSERT_TRUE(Utils::RectEqualTo(appWin, res)); 229 } 230 ASSERT_EQ(WMError::WM_OK, statBar->Show()); 231 if (appWin->IsDecorEnable()) { 232 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_))); 233 } else { 234 ASSERT_TRUE(Utils::RectEqualTo(appWin, res)); 235 } 236 ASSERT_EQ(WMError::WM_OK, statBar->Hide()); 237 if (appWin->IsDecorEnable()) { 238 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_))); 239 } else { 240 ASSERT_TRUE(Utils::RectEqualTo(appWin, res)); 241 } 242} 243 244/** 245 * @tc.name: LayoutWindow06 246 * @tc.desc: StatusBar Window and NaviBar & Sys Window FULLSCRENN,NOT NEEDVOID,PARENTLIMIT 247 * @tc.type: FUNC 248 */ 249HWTEST_F(WindowLayoutTest, LayoutWindow06, Function | MediumTest | Level3) 250{ 251 sptr<Window> statBar = Utils::CreateStatusBarWindow(); 252 ASSERT_NE(statBar, nullptr); 253 254 activeWindows_.push_back(statBar); 255 sptr<Window> naviBar = Utils::CreateNavigationBarWindow(); 256 activeWindows_.push_back(naviBar); 257 Utils::TestWindowInfo info = { 258 .name = "main6", 259 .rect = Utils::customAppRect_, 260 .type = WindowType::WINDOW_TYPE_PANEL, 261 .mode = WindowMode::WINDOW_MODE_FULLSCREEN, 262 .needAvoid = false, 263 .parentLimit = true, 264 .showWhenLocked = true, 265 .parentId = INVALID_WINDOW_ID, 266 }; 267 sptr<Window> sysWin = Utils::CreateTestWindow(info); 268 ASSERT_NE(sysWin, nullptr); 269 activeWindows_.push_back(sysWin); 270 if (statBar->Show() == WMError::WM_OK) { 271 ASSERT_EQ(WMError::WM_OK, statBar->Show()); 272 } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) { 273 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show()); 274 } 275 sysWin->Show(); 276 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) { 277 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_)); 278 } 279 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) { 280 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_)); 281 } else { 282 ASSERT_FALSE(Utils::RectEqualTo(sysWin, Utils::displayRect_)); 283 } 284 if (WMError::WM_OK == naviBar->Show()) { 285 ASSERT_EQ(WMError::WM_OK, naviBar->Show()); 286 } 287 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) { 288 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_)); 289 } 290 if (WMError::WM_OK == statBar->Hide()) { 291 ASSERT_EQ(WMError::WM_OK, statBar->Hide()); 292 } 293 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) { 294 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_)); 295 } 296} 297 298/** 299 * @tc.name: LayoutWindow07 300 * @tc.desc: StatusBar Window and NaviBar & One Floating Sys Window 301 * @tc.type: FUNC 302 */ 303HWTEST_F(WindowLayoutTest, LayoutWindow07, Function | MediumTest | Level3) 304{ 305 // statusBar window 306 sptr<Window> statBar = Utils::CreateStatusBarWindow(); 307 if (statBar == nullptr) { 308 return; 309 } 310 activeWindows_.push_back(statBar); 311 312 // naviBar window 313 sptr<Window> naviBar = Utils::CreateNavigationBarWindow(); 314 ASSERT_NE(naviBar, nullptr); 315 activeWindows_.push_back(naviBar); 316 // sys window 317 Utils::TestWindowInfo info = { 318 .name = "main7", 319 .rect = Utils::customAppRect_, 320 .type = WindowType::WINDOW_TYPE_PANEL, 321 .mode = WindowMode::WINDOW_MODE_FLOATING, 322 .needAvoid = false, 323 .parentLimit = true, 324 .showWhenLocked = true, 325 .parentId = INVALID_WINDOW_ID, 326 }; 327 sptr<Window> sysWin = Utils::CreateTestWindow(info); 328 ASSERT_NE(sysWin, nullptr); 329 activeWindows_.push_back(sysWin); 330 if (statBar->Show() == WMError::WM_OK) { 331 ASSERT_EQ(WMError::WM_OK, statBar->Show()); 332 } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) { 333 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show()); 334 } 335 sysWin->Show(); 336 337 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_)); 338 339 if (WMError::WM_OK == naviBar->Show()) { 340 ASSERT_EQ(WMError::WM_OK, naviBar->Show()); 341 } else { 342 ASSERT_NE(WMError::WM_OK, naviBar->Show()); 343 } 344 345 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_)); 346 if (statBar->Hide() == WMError::WM_OK) { 347 ASSERT_EQ(WMError::WM_OK, statBar->Hide()); 348 } else if (statBar->Hide() == WMError::WM_ERROR_INVALID_WINDOW) { 349 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Hide()); 350 } 351 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_)); 352} 353 354/** 355 * @tc.name: LayoutWindow08 356 * @tc.desc: One FLOATING APP Window with on custom rect 357 * @tc.type: FUNC 358 */ 359HWTEST_F(WindowLayoutTest, LayoutWindow08, Function | MediumTest | Level3) 360{ 361 Utils::TestWindowInfo info = { 362 .name = "main8", 363 .rect = {0, 0, 0, 0}, 364 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 365 .mode = WindowMode::WINDOW_MODE_FLOATING, 366 .needAvoid = true, 367 .parentLimit = false, 368 .showWhenLocked = true, 369 .parentId = INVALID_WINDOW_ID, 370 }; 371 const sptr<Window>& window = Utils::CreateTestWindow(info); 372 ASSERT_NE(window, nullptr); 373 374 activeWindows_.push_back(window); 375 Rect expect = Utils::GetDefaultFloatingRect(window, true); 376 ASSERT_EQ(WMError::WM_OK, window->Show()); 377 usleep(WAIT_SYANC_US); 378 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 379 ASSERT_EQ(WMError::WM_OK, window->Hide()); 380 usleep(WAIT_SYANC_US); 381} 382 383/** 384 * @tc.name: LayoutWindow09 385 * @tc.desc: Add a floating and resize(2, 2) 386 * @tc.type: FUNC 387 */ 388HWTEST_F(WindowLayoutTest, LayoutWindow09, Function | MediumTest | Level3) 389{ 390 Utils::TestWindowInfo info = { 391 .name = "main9", 392 .rect = {0, 0, 0, 0}, 393 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 394 .mode = WindowMode::WINDOW_MODE_FLOATING, 395 .needAvoid = true, 396 .parentLimit = false, 397 .showWhenLocked = true, 398 .parentId = INVALID_WINDOW_ID, 399 }; 400 const sptr<Window>& window = Utils::CreateTestWindow(info); 401 if (window == nullptr) { 402 return; 403 } 404 activeWindows_.push_back(window); 405 Rect expect = Utils::GetDefaultFloatingRect(window, true); 406 407 ASSERT_EQ(WMError::WM_OK, window->Show()); 408 usleep(WAIT_SYANC_US); 409 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 410 411 ASSERT_EQ(WMError::WM_OK, window->Resize(2u, 2u)); // 2: custom min size 412 Rect finalExcept = { expect.posX_, expect.posY_, 2u, 2u}; // 2: custom min size 413 finalExcept = Utils::GetFloatingLimitedRect(finalExcept, virtualPixelRatio_); 414 ASSERT_TRUE(Utils::RectEqualTo(window, finalExcept)); 415 ASSERT_EQ(WMError::WM_OK, window->Hide()); 416} 417 418/** 419 * @tc.name: LayoutWindow10 420 * @tc.desc: One FLOATING APP Window do max and recovery 421 * @tc.type: FUNC 422 */ 423HWTEST_F(WindowLayoutTest, LayoutWindow10, Function | MediumTest | Level3) 424{ 425 Utils::TestWindowInfo info = { 426 .name = "main10", 427 .rect = {0, 0, 0, 0}, 428 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 429 .mode = WindowMode::WINDOW_MODE_FLOATING, 430 .needAvoid = true, 431 .parentLimit = false, 432 .showWhenLocked = true, 433 .parentId = INVALID_WINDOW_ID, 434 }; 435 const sptr<Window>& window = Utils::CreateTestWindow(info); 436 ASSERT_NE(window, nullptr); 437 438 activeWindows_.push_back(window); 439 Rect expect = Utils::GetDefaultFloatingRect(window, true); 440 ASSERT_EQ(WMError::WM_OK, window->Show()); 441 usleep(WAIT_SYANC_US); 442 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 443 ASSERT_EQ(WMError::WM_OK, window->Maximize()); 444 usleep(WAIT_SYANC_US); 445 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::displayRect_)); 446 ASSERT_EQ(WMError::WM_OK, window->Recover()); 447 usleep(WAIT_SYANC_US); 448 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 449 ASSERT_EQ(WMError::WM_OK, window->Minimize()); 450 usleep(WAIT_SYANC_US); 451 ASSERT_EQ(WMError::WM_OK, window->Close()); 452} 453 454/** 455 * @tc.name: LayoutTile01 456 * @tc.desc: One FLOATING APP Window into tile mode, show 4 new window 457 * @tc.type: FUNC 458 */ 459HWTEST_F(WindowLayoutTest, LayoutTile01, Function | MediumTest | Level3) 460{ 461 Utils::TestWindowInfo info = { 462 .name = "mainTile1", .rect = {0, 0, 0, 0}, .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 463 .mode = WindowMode::WINDOW_MODE_FLOATING, .needAvoid = true, .parentLimit = false, 464 .parentId = INVALID_WINDOW_ID, 465 }; 466 467 const sptr<Window>& window = Utils::CreateTestWindow(info); 468 ASSERT_NE(window, nullptr); 469 470 activeWindows_.push_back(window); 471 Rect expect = Utils::GetDefaultFloatingRect(window, true); 472 ASSERT_EQ(WMError::WM_OK, window->Show()); 473 usleep(WAIT_SYANC_US); 474 // init tile window rects and get max tile window num 475 Utils::InitTileWindowRects(window, false); 476 uint32_t maxTileNum = Utils::GetMaxTileWinNum(); 477 if (maxTileNum < 1) { 478 return; 479 } 480 481 usleep(WAIT_SYANC_US); 482 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 483 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE); 484 usleep(WAIT_SYANC_US); 485 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_)); 486 487 info.name = "test1"; 488 const sptr<Window>& test1 = Utils::CreateTestWindow(info); 489 ASSERT_NE(nullptr, test1); 490 activeWindows_.push_back(test1); 491 ASSERT_EQ(WMError::WM_OK, test1->Show()); 492 usleep(WAIT_SYANC_US); 493 if (maxTileNum == 1) { 494 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_)); 495 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 496 return; 497 } 498 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0])); 499 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1])); 500 501 info.name = "test2"; 502 const sptr<Window>& test2 = Utils::CreateTestWindow(info); 503 ASSERT_NE(nullptr, test2); 504 activeWindows_.push_back(test2); 505 ASSERT_EQ(WMError::WM_OK, test2->Show()); 506 usleep(WAIT_SYANC_US); 507 if (maxTileNum == 2) { 508 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0])); 509 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1])); 510 } else { 511 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0])); 512 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1])); 513 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx 514 } 515 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 516} 517 518/** 519 * @tc.name: LayoutTileNegative01 520 * @tc.desc: negative test for tile window 521 * @tc.type: FUNC 522 */ 523HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3) 524{ 525 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 526 Utils::TestWindowInfo info = { 527 .name = "mainTileNegative1", .rect = {-1, -100, -1, -100}, // -1, -100, -1, -100 is typical negative case nums 528 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, .mode = WindowMode::WINDOW_MODE_FLOATING, 529 .needAvoid = true, .parentLimit = false, .parentId = INVALID_WINDOW_ID, 530 }; 531 const sptr<Window>& window = Utils::CreateTestWindow(info); 532 ASSERT_NE(window, nullptr); 533 534 activeWindows_.push_back(window); 535 ASSERT_EQ(WMError::WM_OK, window->Show()); 536 usleep(WAIT_SYANC_US); 537 // init tile window rects and get max tile window num 538 Utils::InitTileWindowRects(window, false); 539 uint32_t maxTileNum = Utils::GetMaxTileWinNum(); 540 if (maxTileNum < 1) { 541 return; 542 } 543 544 usleep(WAIT_SYANC_US); 545 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE); 546 usleep(WAIT_SYANC_US); 547 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_)); 548 549 info.name = "test1"; 550 const sptr<Window>& test1 = Utils::CreateTestWindow(info); 551 ASSERT_NE(nullptr, test1); 552 activeWindows_.push_back(test1); 553 ASSERT_EQ(WMError::WM_OK, test1->Show()); 554 usleep(WAIT_SYANC_US); 555 if (maxTileNum == 1) { 556 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_)); 557 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 558 return; 559 } 560 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0])); 561 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1])); 562 563 info.name = "test2"; 564 const sptr<Window>& test2 = Utils::CreateTestWindow(info); 565 ASSERT_NE(nullptr, test2); 566 activeWindows_.push_back(test2); 567 ASSERT_EQ(WMError::WM_OK, test2->Show()); 568 usleep(WAIT_SYANC_US); 569 if (maxTileNum == 2) { 570 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0])); 571 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1])); 572 } else { 573 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0])); 574 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1])); 575 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx 576 } 577 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 578} 579 580/** 581 * @tc.name: LayoutTileNegative01 582 * @tc.desc: move window out of the display 583 * @tc.type: FUNC 584 */ 585HWTEST_F(WindowLayoutTest, LayoutNegative01, Function | MediumTest | Level3) 586{ 587 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 588 Utils::TestWindowInfo info = { 589 .name = "mainNegative1", 590 .rect = {0, 0, 0, 0}, 591 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 592 .mode = WindowMode::WINDOW_MODE_FLOATING, 593 .needAvoid = true, 594 .parentLimit = false, 595 .parentId = INVALID_WINDOW_ID, 596 }; 597 const sptr<Window>& window = Utils::CreateTestWindow(info); 598 ASSERT_NE(window, nullptr); 599 600 activeWindows_.push_back(window); 601 Rect expect = Utils::GetDefaultFloatingRect(window, true); 602 ASSERT_EQ(WMError::WM_OK, window->Show()); 603 usleep(WAIT_SYANC_US); 604 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 605} 606 607/** 608 * @tc.name: LayoutNegative02 609 * @tc.desc: resize window to negative size 610 * @tc.type: FUNC 611 */ 612HWTEST_F(WindowLayoutTest, LayoutNegative02, Function | MediumTest | Level3) 613{ 614 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE); 615 const uint32_t negativeW = 0; 616 const uint32_t negativeH = 0; 617 Utils::TestWindowInfo info = { 618 .name = "mainNegative2", 619 .rect = {0, 0, 0, 0}, 620 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 621 .mode = WindowMode::WINDOW_MODE_FLOATING, 622 .needAvoid = true, 623 .parentLimit = false, 624 .parentId = INVALID_WINDOW_ID, 625 }; 626 const sptr<Window>& window = Utils::CreateTestWindow(info); 627 ASSERT_NE(window, nullptr); 628 629 activeWindows_.push_back(window); 630 Rect expect = Utils::GetDefaultFloatingRect(window, true); 631 ASSERT_EQ(WMError::WM_OK, window->Show()); 632 usleep(WAIT_SYANC_US); 633 ASSERT_TRUE(Utils::RectEqualTo(window, expect)); 634 window->Resize(negativeW, negativeH); 635 usleep(WAIT_SYANC_US); 636 Rect expect2 = {expect.posX_, expect.posY_, negativeW, negativeH}; 637 expect2 = Utils::CalcLimitedRect(expect2, virtualPixelRatio_); 638 ASSERT_TRUE(Utils::RectEqualTo(window, expect2)); 639} 640 641/** 642 * @tc.name: moveWindowTo01 643 * @tc.desc: test moveWindowTo for ALN/PC with windowMode: 102, windowType: 2106 644 * @tc.type: FUNC 645 */ 646HWTEST_F(WindowLayoutTest, moveWindowTo01, Function | MediumTest | Level3) 647{ 648 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 649 option->SetWindowName("moveWindowTo01"); 650 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 651 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 652 653 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 654 655 window->property_->SetPersistentId(10001); 656 657 Rect rect; 658 WMError ret; 659 ret = window->Create(abilityContext_, nullptr); 660 EXPECT_EQ(WMError::WM_OK, ret); 661 662 ret = window->Show(); 663 EXPECT_EQ(WMError::WM_OK, ret); 664 665 ret = window->MoveTo(-500, -500); 666 usleep(WAIT_SERVERAL_FRAMES); 667 EXPECT_EQ(WMError::WM_OK, ret); 668 rect = window->property_->GetWindowRect(); 669 EXPECT_EQ(-500, rect.posX_); 670 EXPECT_EQ(-500, rect.posY_); 671 672 ret = window->MoveTo(0, 0); 673 usleep(WAIT_SERVERAL_FRAMES); 674 EXPECT_EQ(WMError::WM_OK, ret); 675 rect = window->property_->GetWindowRect(); 676 EXPECT_EQ(0, rect.posX_); 677 EXPECT_EQ(0, rect.posY_); 678 679 ret = window->MoveTo(500, 500); 680 usleep(WAIT_SERVERAL_FRAMES); 681 EXPECT_EQ(WMError::WM_OK, ret); 682 rect = window->property_->GetWindowRect(); 683 EXPECT_EQ(500, rect.posX_); 684 EXPECT_EQ(500, rect.posY_); 685 686 ret = window->MoveTo(20000, 20000); 687 usleep(WAIT_SERVERAL_FRAMES); 688 EXPECT_EQ(WMError::WM_OK, ret); 689 rect = window->property_->GetWindowRect(); 690 EXPECT_EQ(20000, rect.posX_); 691 EXPECT_EQ(20000, rect.posY_); 692} 693 694/** 695 * @tc.name: moveWindowTo02 696 * @tc.desc: test moveWindowTo for ALN with windowMode: 102, windowType: 1001 697 * @tc.type: FUNC 698 */ 699HWTEST_F(WindowLayoutTest, moveWindowTo02, Function | MediumTest | Level3) 700{ 701 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 702 option->SetWindowName("moveWindowTo02"); 703 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); 704 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 705 706 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 707 708 SessionInfo sessionInfo = { "bundleName_moveWindowTo02", 709 "moduleName_moveWindowTo02", "abilityName_moveWindowTo02" }; 710 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 711 712 Rect rectOld; 713 Rect rectNow; 714 WMError ret; 715 ret = window->Create(abilityContext_, sceneSession); 716 EXPECT_EQ(WMError::WM_OK, ret); 717 ret = window->Show(); 718 EXPECT_EQ(WMError::WM_OK, ret); 719 window->property_->SetPersistentId(10002); 720 721 rectOld = window->property_->GetWindowRect(); 722 ret = window->MoveTo(-500, -500); 723 usleep(WAIT_SERVERAL_FRAMES); 724 EXPECT_EQ(WMError::WM_OK, ret); 725 rectNow = window->property_->GetWindowRect(); 726 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 727 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 728 729 rectOld = window->property_->GetWindowRect(); 730 ret = window->MoveTo(0, 0); 731 usleep(WAIT_SERVERAL_FRAMES); 732 EXPECT_EQ(WMError::WM_OK, ret); 733 rectNow = window->property_->GetWindowRect(); 734 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 735 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 736 737 rectOld = window->property_->GetWindowRect(); 738 ret = window->MoveTo(500, 500); 739 usleep(WAIT_SERVERAL_FRAMES); 740 EXPECT_EQ(WMError::WM_OK, ret); 741 rectNow = window->property_->GetWindowRect(); 742 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 743 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 744} 745 746/** 747 * @tc.name: moveWindowTo03 748 * @tc.desc: test moveWindowTo for ALN with windowMode: 1, windowType: 1 749 * @tc.type: FUNC 750 */ 751HWTEST_F(WindowLayoutTest, moveWindowTo03, Function | MediumTest | Level3) 752{ 753 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 754 option->SetWindowName("moveWindowTo03"); 755 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 756 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 757 758 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 759 760 window->property_->SetPersistentId(10003); 761 762 SessionInfo sessionInfo = { "bundleName_moveWindowTo03", 763 "moduleName_moveWindowTo03", "abilityName_moveWindowTo03" }; 764 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 765 766 Rect rectOld; 767 Rect rectNow; 768 WMError ret; 769 ret = window->Create(abilityContext_, sceneSession); 770 EXPECT_EQ(WMError::WM_OK, ret); 771 ret = window->Show(); 772 EXPECT_EQ(WMError::WM_OK, ret); 773 774 rectOld = window->property_->GetWindowRect(); 775 ret = window->MoveTo(-500, -500); 776 usleep(WAIT_SERVERAL_FRAMES); 777 EXPECT_EQ(WMError::WM_OK, ret); 778 rectNow = window->property_->GetWindowRect(); 779 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 780 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 781 782 rectOld = window->property_->GetWindowRect(); 783 ret = window->MoveTo(0, 0); 784 usleep(WAIT_SERVERAL_FRAMES); 785 EXPECT_EQ(WMError::WM_OK, ret); 786 rectNow = window->property_->GetWindowRect(); 787 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 788 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 789 790 rectOld = window->property_->GetWindowRect(); 791 ret = window->MoveTo(500, 500); 792 usleep(WAIT_SERVERAL_FRAMES); 793 EXPECT_EQ(WMError::WM_OK, ret); 794 rectNow = window->property_->GetWindowRect(); 795 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 796 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 797 798 rectOld = window->property_->GetWindowRect(); 799 ret = window->MoveTo(20000, 20000); 800 usleep(WAIT_SERVERAL_FRAMES); 801 EXPECT_EQ(WMError::WM_OK, ret); 802 rectNow = window->property_->GetWindowRect(); 803 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 804 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 805} 806 807/** 808 * @tc.name: moveWindowTo04 809 * @tc.desc: test moveWindowTo for ALN with windowMode: 100, windowType: 1 810 * @tc.type: FUNC 811 */ 812HWTEST_F(WindowLayoutTest, moveWindowTo04, Function | MediumTest | Level3) 813{ 814 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 815 option->SetWindowName("moveWindowTo04"); 816 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 817 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); 818 819 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 820 821 window->property_->SetPersistentId(10004); 822 823 SessionInfo sessionInfo = { "bundleName_moveWindowTo04", 824 "moduleName_moveWindowTo04", "abilityName_moveWindowTo04" }; 825 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 826 827 Rect rectOld; 828 Rect rectNow; 829 WMError ret; 830 ret = window->Create(abilityContext_, sceneSession); 831 EXPECT_EQ(WMError::WM_OK, ret); 832 ret = window->Show(); 833 EXPECT_EQ(WMError::WM_OK, ret); 834 835 rectOld = window->property_->GetWindowRect(); 836 ret = window->MoveTo(-500, -500); 837 usleep(WAIT_SERVERAL_FRAMES); 838 EXPECT_EQ(WMError::WM_OK, ret); 839 rectNow = window->property_->GetWindowRect(); 840 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 841 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 842 843 rectOld = window->property_->GetWindowRect(); 844 ret = window->MoveTo(0, 0); 845 usleep(WAIT_SERVERAL_FRAMES); 846 EXPECT_EQ(WMError::WM_OK, ret); 847 rectNow = window->property_->GetWindowRect(); 848 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 849 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 850 851 rectOld = window->property_->GetWindowRect(); 852 ret = window->MoveTo(500, 500); 853 usleep(WAIT_SERVERAL_FRAMES); 854 EXPECT_EQ(WMError::WM_OK, ret); 855 rectNow = window->property_->GetWindowRect(); 856 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 857 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 858 859 rectOld = window->property_->GetWindowRect(); 860 ret = window->MoveTo(20000, 20000); 861 usleep(WAIT_SERVERAL_FRAMES); 862 EXPECT_EQ(WMError::WM_OK, ret); 863 rectNow = window->property_->GetWindowRect(); 864 EXPECT_EQ(rectOld.posX_, rectNow.posX_); 865 EXPECT_EQ(rectOld.posY_, rectNow.posY_); 866} 867 868/** 869 * @tc.name: resize01 870 * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2106 871 * @tc.type: FUNC 872 */ 873HWTEST_F(WindowLayoutTest, resize01, Function | MediumTest | Level3) 874{ 875 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 876 option->SetWindowName("resize01"); 877 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 878 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 879 880 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 881 882 Rect rect; 883 WMError ret; 884 ret = window->Create(abilityContext_, nullptr); 885 EXPECT_EQ(WMError::WM_OK, ret); 886 window->property_->SetPersistentId(10008); 887 ret = window->Show(); 888 EXPECT_EQ(WMError::WM_OK, ret); 889 890 WindowLimits windowLimits; 891 ret = window->GetWindowLimits(windowLimits); 892 EXPECT_EQ(WMError::WM_OK, ret); 893 894 ret = window->Resize(-500, -500); 895 EXPECT_EQ(WMError::WM_OK, ret); 896 usleep(WAIT_SERVERAL_FRAMES); 897 rect = window->property_->GetWindowRect(); 898 EXPECT_EQ(windowLimits.maxWidth_, rect.width_); 899 EXPECT_EQ(windowLimits.maxHeight_, rect.height_); 900 901 ret = window->Resize(500, 500); 902 EXPECT_EQ(WMError::WM_OK, ret); 903 usleep(WAIT_SERVERAL_FRAMES); 904 rect = window->property_->GetWindowRect(); 905 EXPECT_EQ(500, rect.width_); 906 EXPECT_EQ(500, rect.height_); 907 908 ret = window->Resize(20000, 20000); 909 EXPECT_EQ(WMError::WM_OK, ret); 910 usleep(WAIT_SERVERAL_FRAMES); 911 rect = window->property_->GetWindowRect(); 912 EXPECT_EQ(windowLimits.maxWidth_, rect.width_); 913 EXPECT_EQ(windowLimits.maxHeight_, rect.height_); 914 915 ret = window->Resize(0, 0); 916 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first 917} 918 919/** 920 * @tc.name: resize02 921 * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1 922 * @tc.type: FUNC 923 */ 924HWTEST_F(WindowLayoutTest, resize02, Function | MediumTest | Level3) 925{ 926 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 927 option->SetWindowName("resize02"); 928 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 929 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 930 931 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 932 933 SessionInfo sessionInfo = { "bundleName_resize02", "moduleName_resize02", "abilityName_resize02" }; 934 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 935 936 WMError ret; 937 ret = window->Create(abilityContext_, sceneSession); 938 EXPECT_EQ(WMError::WM_OK, ret); 939 window->property_->SetPersistentId(10009); 940 ret = window->Show(); 941 EXPECT_EQ(WMError::WM_OK, ret); 942 943 ret = window->Resize(500, 500); 944 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 945 946 ret = window->Resize(20000, 20000); 947 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 948 949 ret = window->Resize(0, 0); 950 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first 951} 952 953/** 954 * @tc.name: resize03 955 * @tc.desc: test resize for PC with windowMode: 1, windowType: 1 956 * @tc.type: FUNC 957 */ 958HWTEST_F(WindowLayoutTest, resize03, Function | MediumTest | Level3) 959{ 960 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 961 option->SetWindowName("resize03"); 962 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 963 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 964 965 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 966 967 SessionInfo sessionInfo = { "bundleName_resize03", "moduleName_resize03", "abilityName_resize03" }; 968 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 969 970 WMError ret; 971 ret = window->Create(abilityContext_, sceneSession); 972 EXPECT_EQ(WMError::WM_OK, ret); 973 window->property_->SetPersistentId(100010); 974 ret = window->Show(); 975 EXPECT_EQ(WMError::WM_OK, ret); 976 977 ret = window->Resize(500, 500); 978 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 979 980 ret = window->Resize(20000, 20000); 981 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 982 983 ret = window->Resize(0, 0); 984 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first 985} 986 987/** 988 * @tc.name: resize04 989 * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1 990 * @tc.type: FUNC 991 */ 992HWTEST_F(WindowLayoutTest, resize04, Function | MediumTest | Level3) 993{ 994 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 995 option->SetWindowName("resize04"); 996 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 997 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); 998 999 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 1000 1001 SessionInfo sessionInfo = { "bundleName_resize04", "moduleName_resize04", "abilityName_resize04" }; 1002 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 1003 1004 WMError ret; 1005 ret = window->Create(abilityContext_, sceneSession); 1006 EXPECT_EQ(WMError::WM_OK, ret); 1007 window->property_->SetPersistentId(100011); 1008 ret = window->Show(); 1009 EXPECT_EQ(WMError::WM_OK, ret); 1010 1011 ret = window->Resize(500, 500); 1012 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1013 1014 ret = window->Resize(20000, 20000); 1015 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1016 1017 ret = window->Resize(0, 0); 1018 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first 1019} 1020 1021/** 1022 * @tc.name: resize05 1023 * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2106 1024 * @tc.type: FUNC 1025 */ 1026HWTEST_F(WindowLayoutTest, resize05, Function | MediumTest | Level3) 1027{ 1028 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 1029 option->SetWindowName("resize05"); 1030 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT); 1031 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); 1032 1033 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 1034 1035 Rect rect; 1036 WMError ret; 1037 ret = window->Create(abilityContext_, nullptr); 1038 EXPECT_EQ(WMError::WM_OK, ret); 1039 window->property_->SetPersistentId(10012); 1040 ret = window->Show(); 1041 EXPECT_EQ(WMError::WM_OK, ret); 1042 1043 WindowLimits windowLimits; 1044 ret = window->GetWindowLimits(windowLimits); 1045 1046 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100); 1047 EXPECT_EQ(WMError::WM_OK, ret); 1048 usleep(WAIT_SERVERAL_FRAMES); 1049 rect = window->property_->GetWindowRect(); 1050 EXPECT_EQ(windowLimits.maxWidth_ - 100, rect.width_); 1051 EXPECT_EQ(windowLimits.maxHeight_ - 100, rect.height_); 1052 1053 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100); 1054 EXPECT_EQ(WMError::WM_OK, ret); 1055 usleep(WAIT_SERVERAL_FRAMES); 1056 rect = window->property_->GetWindowRect(); 1057 EXPECT_EQ(windowLimits.maxWidth_, rect.width_); 1058 EXPECT_EQ(windowLimits.maxHeight_, rect.height_); 1059} 1060 1061/** 1062 * @tc.name: resize06 1063 * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1 1064 * @tc.type: FUNC 1065 */ 1066HWTEST_F(WindowLayoutTest, resize06, Function | MediumTest | Level3) 1067{ 1068 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 1069 option->SetWindowName("resize06"); 1070 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1071 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 1072 1073 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 1074 1075 SessionInfo sessionInfo = { "bundleName_resize06", "moduleName_resize06", "abilityName_resize06" }; 1076 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 1077 1078 WMError ret; 1079 ret = window->Create(abilityContext_, sceneSession); 1080 EXPECT_EQ(WMError::WM_OK, ret); 1081 window->property_->SetPersistentId(100013); 1082 ret = window->Show(); 1083 EXPECT_EQ(WMError::WM_OK, ret); 1084 1085 WindowLimits windowLimits; 1086 ret = window->GetWindowLimits(windowLimits); 1087 1088 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100); 1089 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1090 1091 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100); 1092 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1093} 1094 1095/** 1096 * @tc.name: resize07 1097 * @tc.desc: test resize for PC with windowMode: 1, windowType: 1 1098 * @tc.type: FUNC 1099 */ 1100HWTEST_F(WindowLayoutTest, resize07, Function | MediumTest | Level3) 1101{ 1102 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 1103 option->SetWindowName("resize07"); 1104 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1105 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); 1106 1107 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 1108 1109 SessionInfo sessionInfo = { "bundleName_resize07", "moduleName_resize07", "abilityName_resize07" }; 1110 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 1111 1112 WMError ret; 1113 ret = window->Create(abilityContext_, sceneSession); 1114 EXPECT_EQ(WMError::WM_OK, ret); 1115 window->property_->SetPersistentId(100014); 1116 ret = window->Show(); 1117 EXPECT_EQ(WMError::WM_OK, ret); 1118 1119 WindowLimits windowLimits; 1120 ret = window->GetWindowLimits(windowLimits); 1121 1122 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100); 1123 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1124 1125 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100); 1126 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1127} 1128 1129/** 1130 * @tc.name: resize08 1131 * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1 1132 * @tc.type: FUNC 1133 */ 1134HWTEST_F(WindowLayoutTest, resize08, Function | MediumTest | Level3) 1135{ 1136 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr(); 1137 option->SetWindowName("resize08"); 1138 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW); 1139 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY); 1140 1141 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option); 1142 1143 SessionInfo sessionInfo = { "bundleName_resize08", "moduleName_resize08", "abilityName_resize08" }; 1144 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr); 1145 1146 WMError ret; 1147 ret = window->Create(abilityContext_, sceneSession); 1148 EXPECT_EQ(WMError::WM_OK, ret); 1149 window->property_->SetPersistentId(100015); 1150 ret = window->Show(); 1151 EXPECT_EQ(WMError::WM_OK, ret); 1152 1153 WindowLimits windowLimits; 1154 ret = window->GetWindowLimits(windowLimits); 1155 1156 ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100); 1157 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1158 ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100); 1159 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret); 1160} 1161} 1162} // namespace Rosen 1163} // namespace OHOS 1164