1 /*
2 * Copyright (c) 2021-2024 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 "ability_context_impl.h"
19 #include "common_test_utils.h"
20 #include "mock_session.h"
21 #include "session/host/include/scene_session.h"
22 #include "window_test_utils.h"
23 #include "window_adapter.h"
24 #include "window_scene_session_impl.h"
25 #include "wm_common.h"
26
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 using Utils = WindowTestUtils;
34 class WindowLayoutTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 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;
44 private:
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 = 2; // second;
48 static void InitAvoidArea();
49 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
50 };
51
52 vector<Rect> WindowLayoutTest::fullScreenExpecteds_;
53
SetUpTestCase()54 void WindowLayoutTest::SetUpTestCase()
55 {
56 SingletonContainer::Get<WindowAdapter>().MinimizeAllAppWindows(0);
57 sleep(WAIT_SYANC_S);
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(WAIT_SYANC_S);
90 }
91
InitAvoidArea()92 void 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
TearDownTestCase()112 void WindowLayoutTest::TearDownTestCase()
113 {
114 }
115
SetUp()116 void WindowLayoutTest::SetUp()
117 {
118 activeWindows_.clear();
119 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
120 CommonTestUtils::GuaranteeFloatWindowPermission("wms_window_app_floating_window_test");
121 }
122
TearDown()123 void WindowLayoutTest::TearDown()
124 {
125 for (auto window: activeWindows_) {
126 window->Destroy();
127 }
128 sleep(WAIT_SYANC_S);
129 abilityContext_ = nullptr;
130 }
131
132 namespace {
133 /**
134 * @tc.name: LayoutWindow01
135 * @tc.desc: One FLOATING APP Window with on custom rect
136 * @tc.type: FUNC
137 */
138 HWTEST_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 */
170 HWTEST_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 */
201 HWTEST_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 */
249 HWTEST_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 */
303 HWTEST_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 */
359 HWTEST_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 */
388 HWTEST_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 */
423 HWTEST_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 */
459 HWTEST_F(WindowLayoutTest, LayoutTile01, Function | MediumTest | Level3)
460 {
461 Utils::TestWindowInfo info = {
462 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, .mode = WindowMode::WINDOW_MODE_FLOATING, .needAvoid = true,
463 .parentId = INVALID_WINDOW_ID, .parentLimit = false, .name = "mainTile1", .rect = {0, 0, 0, 0},
464 };
465 const sptr<Window>& window = Utils::CreateTestWindow(info);
466 ASSERT_NE(window, nullptr);
467 activeWindows_.push_back(window);
468 Rect expect = Utils::GetDefaultFloatingRect(window, true);
469 ASSERT_EQ(WMError::WM_OK, window->Show());
470 usleep(WAIT_SYANC_US);
471 // init tile window rects and get max tile window num
472 Utils::InitTileWindowRects(window, false);
473 uint32_t maxTileNum = Utils::GetMaxTileWinNum();
474 if (maxTileNum < 1) {
475 return;
476 }
477 usleep(WAIT_SYANC_US);
478 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
479 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
480 usleep(WAIT_SYANC_US);
481 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
482
483 info.name = "test1";
484 const sptr<Window>& test1 = Utils::CreateTestWindow(info);
485 ASSERT_NE(nullptr, test1);
486 activeWindows_.push_back(test1);
487 ASSERT_EQ(WMError::WM_OK, test1->Show());
488 usleep(WAIT_SYANC_US);
489 if (maxTileNum == 1) {
490 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_));
491 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
492 return;
493 }
494 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0]));
495 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1]));
496
497 info.name = "test2";
498 const sptr<Window>& test2 = Utils::CreateTestWindow(info);
499 ASSERT_NE(nullptr, test2);
500 activeWindows_.push_back(test2);
501 ASSERT_EQ(WMError::WM_OK, test2->Show());
502 usleep(WAIT_SYANC_US);
503 if (maxTileNum == 2) {
504 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
505 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
506 } else {
507 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
508 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
509 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
510 }
511 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
512 }
513
514 /**
515 * @tc.name: LayoutTileNegative01
516 * @tc.desc: negative test for tile window
517 * @tc.type: FUNC
518 */
519 HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3)
520 {
521 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
522 Utils::TestWindowInfo info = {
523 .name = "mainTileNegative1", .rect = {-1, -100, -1, -100}, // -1, -100, -1, -100 is typical negative case nums
524 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, .mode = WindowMode::WINDOW_MODE_FLOATING,
525 .needAvoid = true, .parentLimit = false, .parentId = INVALID_WINDOW_ID,
526 };
527 const sptr<Window>& window = Utils::CreateTestWindow(info);
528 ASSERT_NE(window, nullptr);
529
530 activeWindows_.push_back(window);
531 ASSERT_EQ(WMError::WM_OK, window->Show());
532 usleep(WAIT_SYANC_US);
533 // init tile window rects and get max tile window num
534 Utils::InitTileWindowRects(window, false);
535 uint32_t maxTileNum = Utils::GetMaxTileWinNum();
536 if (maxTileNum < 1) {
537 return;
538 }
539
540 usleep(WAIT_SYANC_US);
541 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
542 usleep(WAIT_SYANC_US);
543 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
544
545 info.name = "test1";
546 const sptr<Window>& test1 = Utils::CreateTestWindow(info);
547 ASSERT_NE(nullptr, test1);
548 activeWindows_.push_back(test1);
549 ASSERT_EQ(WMError::WM_OK, test1->Show());
550 usleep(WAIT_SYANC_US);
551 if (maxTileNum == 1) {
552 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_));
553 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
554 return;
555 }
556 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0]));
557 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1]));
558
559 info.name = "test2";
560 const sptr<Window>& test2 = Utils::CreateTestWindow(info);
561 ASSERT_NE(nullptr, test2);
562 activeWindows_.push_back(test2);
563 ASSERT_EQ(WMError::WM_OK, test2->Show());
564 usleep(WAIT_SYANC_US);
565 if (maxTileNum == 2) {
566 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
567 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
568 } else {
569 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
570 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
571 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
572 }
573 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
574 }
575
576 /**
577 * @tc.name: LayoutTileNegative01
578 * @tc.desc: move window out of the display
579 * @tc.type: FUNC
580 */
581 HWTEST_F(WindowLayoutTest, LayoutNegative01, Function | MediumTest | Level3)
582 {
583 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
584 Utils::TestWindowInfo info = {
585 .name = "mainNegative1",
586 .rect = {0, 0, 0, 0},
587 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
588 .mode = WindowMode::WINDOW_MODE_FLOATING,
589 .needAvoid = true,
590 .parentLimit = false,
591 .parentId = INVALID_WINDOW_ID,
592 };
593 const sptr<Window>& window = Utils::CreateTestWindow(info);
594 ASSERT_NE(window, nullptr);
595
596 activeWindows_.push_back(window);
597 Rect expect = Utils::GetDefaultFloatingRect(window, true);
598 ASSERT_EQ(WMError::WM_OK, window->Show());
599 usleep(WAIT_SYANC_US);
600 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
601 }
602
603 /**
604 * @tc.name: LayoutNegative02
605 * @tc.desc: resize window to negative size
606 * @tc.type: FUNC
607 */
608 HWTEST_F(WindowLayoutTest, LayoutNegative02, Function | MediumTest | Level3)
609 {
610 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
611 const uint32_t negativeW = 0;
612 const uint32_t negativeH = 0;
613 Utils::TestWindowInfo info = {
614 .name = "mainNegative2",
615 .rect = {0, 0, 0, 0},
616 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
617 .mode = WindowMode::WINDOW_MODE_FLOATING,
618 .needAvoid = true,
619 .parentLimit = false,
620 .parentId = INVALID_WINDOW_ID,
621 };
622 const sptr<Window>& window = Utils::CreateTestWindow(info);
623 ASSERT_NE(window, nullptr);
624
625 activeWindows_.push_back(window);
626 Rect expect = Utils::GetDefaultFloatingRect(window, true);
627 ASSERT_EQ(WMError::WM_OK, window->Show());
628 usleep(WAIT_SYANC_US);
629 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
630 window->Resize(negativeW, negativeH);
631 usleep(WAIT_SYANC_US);
632 Rect expect2 = {expect.posX_, expect.posY_, negativeW, negativeH};
633 expect2 = Utils::CalcLimitedRect(expect2, virtualPixelRatio_);
634 ASSERT_TRUE(Utils::RectEqualTo(window, expect2));
635 }
636
637 }
638 } // namespace Rosen
639 } // namespace OHOS
640