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 "display_manager_proxy.h"
19 #include "window_manager.h"
20 #include "window_test_utils.h"
21 #include "wm_common.h"
22 #include "window_adapter.h"
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 using Utils = WindowTestUtils;
29 class WindowLayoutTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 virtual void SetUp() override;
34 virtual void TearDown() override;
35 DisplayId displayId_ = 0;
36 std::vector<sptr<Window>> activeWindows_;
37 static vector<Rect> fullScreenExpecteds_;
38 static inline float virtualPixelRatio_ = 0.0;
39 private:
40 static constexpr uint32_t WAIT_SYANC_US = 100000;
41 static void InitAvoidArea();
42 };
43
44 vector<Rect> WindowLayoutTest::fullScreenExpecteds_;
45
SetUpTestCase()46 void WindowLayoutTest::SetUpTestCase()
47 {
48 SingletonContainer::Get<WindowAdapter>().MinimizeAllAppWindows(0);
49 sleep(2);
50 auto display = DisplayManager::GetInstance().GetDisplayById(0);
51 if (display == nullptr) {
52 return;
53 }
54 ASSERT_TRUE((display != nullptr));
55 Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()};
56 Utils::InitByDisplayRect(displayRect);
57
58 virtualPixelRatio_ = WindowTestUtils::GetVirtualPixelRatio(0);
59
60 // calc expected rects
61 Rect expected = { // 0. only statusBar
62 0,
63 Utils::statusBarRect_.height_,
64 Utils::displayRect_.width_,
65 Utils::displayRect_.height_ - Utils::statusBarRect_.height_,
66 };
67 fullScreenExpecteds_.push_back(expected);
68 expected = { // 1. both statusBar and naviBar
69 0,
70 Utils::statusBarRect_.height_,
71 Utils::displayRect_.width_,
72 Utils::displayRect_.height_ - Utils::statusBarRect_.height_ - Utils::naviBarRect_.height_,
73 };
74 fullScreenExpecteds_.push_back(expected);
75 expected = { // 2. only naviBar
76 0,
77 0,
78 Utils::displayRect_.width_,
79 Utils::displayRect_.height_ - Utils::naviBarRect_.height_,
80 };
81 fullScreenExpecteds_.push_back(expected);
82 InitAvoidArea();
83 sleep(2);
84 }
85
InitAvoidArea()86 void WindowLayoutTest::InitAvoidArea()
87 {
88 Utils::TestWindowInfo info = {
89 .name = "avoidArea",
90 .rect = {0, 0, 0, 0},
91 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
92 .mode = WindowMode::WINDOW_MODE_FLOATING,
93 .needAvoid = true,
94 .parentLimit = false,
95 .parentId = INVALID_WINDOW_ID,
96 };
97 const sptr<Window>& window = Utils::CreateTestWindow(info);
98 if (window == nullptr) {
99 return;
100 }
101 window->Show();
102 window->SetLayoutFullScreen(true);
103 window->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM, WindowTestUtils::systemAvoidArea_);
104 window->Hide();
105 window->Destroy();
106 }
107
TearDownTestCase()108 void WindowLayoutTest::TearDownTestCase()
109 {
110 }
111
SetUp()112 void WindowLayoutTest::SetUp()
113 {
114 activeWindows_.clear();
115 }
116
TearDown()117 void WindowLayoutTest::TearDown()
118 {
119 while (!activeWindows_.empty()) {
120 ASSERT_EQ(WMError::WM_OK, activeWindows_.back()->Destroy());
121 activeWindows_.pop_back();
122 }
123 }
124
125 namespace {
126 /**
127 * @tc.name: LayoutWindow01
128 * @tc.desc: One FLOATING APP Window with on custom rect
129 * @tc.type: FUNC
130 */
131 HWTEST_F(WindowLayoutTest, LayoutWindow01, Function | MediumTest | Level3)
132 {
133 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
134 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
135 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
136 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
137
138 Utils::TestWindowInfo info = {
139 .name = "main1",
140 .rect = {0, 0, 0, 0},
141 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
142 .mode = WindowMode::WINDOW_MODE_FLOATING,
143 .needAvoid = true,
144 .parentLimit = false,
145 .showWhenLocked = true,
146 .parentId = INVALID_WINDOW_ID,
147 };
148 const sptr<Window>& window = Utils::CreateTestWindow(info);
149 if (window == nullptr) {
150 return;
151 }
152 ASSERT_EQ(true, window != nullptr);
153 activeWindows_.push_back(window);
154 Rect expect = Utils::GetDefaultFloatingRect(window, true);
155 ASSERT_EQ(WMError::WM_OK, window->Show());
156 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::GetFloatingLimitedRect(expect, virtualPixelRatio_)));
157 ASSERT_EQ(WMError::WM_OK, window->Hide());
158 }
159
160 /**
161 * @tc.name: LayoutWindow02
162 * @tc.desc: One FLOATING APP Window
163 * @tc.type: FUNC
164 */
165 HWTEST_F(WindowLayoutTest, LayoutWindow02, Function | MediumTest | Level3)
166 {
167 Rect res = Utils::GetFloatingLimitedRect(Utils::customAppRect_, virtualPixelRatio_);
168 Utils::TestWindowInfo info = {
169 .name = "main2",
170 .rect = res,
171 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
172 .mode = WindowMode::WINDOW_MODE_FLOATING,
173 .needAvoid = true,
174 .parentLimit = false,
175 .showWhenLocked = true,
176 .parentId = INVALID_WINDOW_ID,
177 };
178 const sptr<Window>& window = Utils::CreateTestWindow(info);
179 if (window == nullptr) {
180 return;
181 }
182 activeWindows_.push_back(window);
183
184 ASSERT_EQ(WMError::WM_OK, window->Show());
185 if (window->IsDecorEnable()) {
186 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::GetDecorateRect(res, virtualPixelRatio_)));
187 } else {
188 ASSERT_TRUE(Utils::RectEqualTo(window, res));
189 }
190 ASSERT_EQ(WMError::WM_OK, window->Hide());
191 }
192
193 /**
194 * @tc.name: LayoutWindow04
195 * @tc.desc: One FLOATING APP Window & One StatusBar Window
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowLayoutTest, LayoutWindow04, Function | MediumTest | Level3)
199 {
200 // app window
201 Rect res = Utils::GetFloatingLimitedRect(Utils::customAppRect_, virtualPixelRatio_);
202 Utils::TestWindowInfo info = {
203 .name = "main4",
204 .rect = res,
205 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
206 .mode = WindowMode::WINDOW_MODE_FLOATING,
207 .needAvoid = true,
208 .parentLimit = false,
209 .showWhenLocked = true,
210 .parentId = INVALID_WINDOW_ID,
211 };
212 sptr<Window> appWin = Utils::CreateTestWindow(info);
213 if (appWin == nullptr) {
214 return;
215 }
216
217 activeWindows_.push_back(appWin);
218
219 // statusBar window
220 sptr<Window> statBar = Utils::CreateStatusBarWindow();
221 activeWindows_.push_back(statBar);
222
223 ASSERT_EQ(WMError::WM_OK, appWin->Show());
224 if (appWin->IsDecorEnable()) {
225 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
226 } else {
227 ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
228 }
229 ASSERT_EQ(WMError::WM_OK, statBar->Show());
230 if (appWin->IsDecorEnable()) {
231 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
232 } else {
233 ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
234 }
235 ASSERT_EQ(WMError::WM_OK, statBar->Hide());
236 if (appWin->IsDecorEnable()) {
237 ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
238 } else {
239 ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
240 }
241 }
242
243 /**
244 * @tc.name: LayoutWindow06
245 * @tc.desc: StatusBar Window and NaviBar & Sys Window FULLSCRENN,NOT NEEDVOID,PARENTLIMIT
246 * @tc.type: FUNC
247 */
248 HWTEST_F(WindowLayoutTest, LayoutWindow06, Function | MediumTest | Level3)
249 {
250 // statusBar window
251 sptr<Window> statBar = Utils::CreateStatusBarWindow();
252 if (statBar == nullptr) {
253 return;
254 }
255 activeWindows_.push_back(statBar);
256
257 // naviBar window
258 sptr<Window> naviBar = Utils::CreateNavigationBarWindow();
259 activeWindows_.push_back(naviBar);
260
261 // sys window
262 Utils::TestWindowInfo info = {
263 .name = "main6",
264 .rect = Utils::customAppRect_,
265 .type = WindowType::WINDOW_TYPE_PANEL,
266 .mode = WindowMode::WINDOW_MODE_FULLSCREEN,
267 .needAvoid = false,
268 .parentLimit = true,
269 .showWhenLocked = true,
270 .parentId = INVALID_WINDOW_ID,
271 };
272 sptr<Window> sysWin = Utils::CreateTestWindow(info);
273 activeWindows_.push_back(sysWin);
274 if (statBar->Show() == WMError::WM_OK) {
275 ASSERT_EQ(WMError::WM_OK, statBar->Show());
276 } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) {
277 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show());
278 }
279
280 ASSERT_EQ(WMError::WM_OK, sysWin->Show());
281
282 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
283 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
284 }
285 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
286 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
287 } else {
288 ASSERT_FALSE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
289 }
290
291 if (WMError::WM_OK == naviBar->Show()) {
292 ASSERT_EQ(WMError::WM_OK, naviBar->Show());
293 }
294
295 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
296 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
297 }
298
299 if (WMError::WM_OK == statBar->Hide()) {
300 ASSERT_EQ(WMError::WM_OK, statBar->Hide());
301 }
302 if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
303 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
304 }
305 }
306
307 /**
308 * @tc.name: LayoutWindow07
309 * @tc.desc: StatusBar Window and NaviBar & One Floating Sys Window
310 * @tc.type: FUNC
311 */
312 HWTEST_F(WindowLayoutTest, LayoutWindow07, Function | MediumTest | Level3)
313 {
314 // statusBar window
315 sptr<Window> statBar = Utils::CreateStatusBarWindow();
316 if (statBar == nullptr) {
317 return;
318 }
319 activeWindows_.push_back(statBar);
320
321 // naviBar window
322 sptr<Window> naviBar = Utils::CreateNavigationBarWindow();
323 activeWindows_.push_back(naviBar);
324 // sys window
325 Utils::TestWindowInfo info = {
326 .name = "main7",
327 .rect = Utils::customAppRect_,
328 .type = WindowType::WINDOW_TYPE_PANEL,
329 .mode = WindowMode::WINDOW_MODE_FLOATING,
330 .needAvoid = false,
331 .parentLimit = true,
332 .showWhenLocked = true,
333 .parentId = INVALID_WINDOW_ID,
334 };
335 sptr<Window> sysWin = Utils::CreateTestWindow(info);
336 activeWindows_.push_back(sysWin);
337 if (statBar->Show() == WMError::WM_OK) {
338 ASSERT_EQ(WMError::WM_OK, statBar->Show());
339 } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) {
340 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show());
341 }
342 ASSERT_EQ(WMError::WM_OK, sysWin->Show());
343
344 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
345
346 if (WMError::WM_OK == naviBar->Show()) {
347 ASSERT_EQ(WMError::WM_OK, naviBar->Show());
348 } else {
349 ASSERT_NE(WMError::WM_OK, naviBar->Show());
350 }
351
352 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
353 if (statBar->Hide() == WMError::WM_OK) {
354 ASSERT_EQ(WMError::WM_OK, statBar->Hide());
355 } else if (statBar->Hide() == WMError::WM_ERROR_INVALID_WINDOW) {
356 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Hide());
357 }
358 ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
359 }
360
361 /**
362 * @tc.name: LayoutWindow08
363 * @tc.desc: One FLOATING APP Window with on custom rect
364 * @tc.type: FUNC
365 */
366 HWTEST_F(WindowLayoutTest, LayoutWindow08, Function | MediumTest | Level3)
367 {
368 Utils::TestWindowInfo info = {
369 .name = "main8",
370 .rect = {0, 0, 0, 0},
371 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
372 .mode = WindowMode::WINDOW_MODE_FLOATING,
373 .needAvoid = true,
374 .parentLimit = false,
375 .showWhenLocked = true,
376 .parentId = INVALID_WINDOW_ID,
377 };
378 const sptr<Window>& window = Utils::CreateTestWindow(info);
379 if (window == nullptr) {
380 return;
381 }
382 activeWindows_.push_back(window);
383 Rect expect = Utils::GetDefaultFloatingRect(window, true);
384 ASSERT_EQ(WMError::WM_OK, window->Show());
385 usleep(WAIT_SYANC_US);
386 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
387 ASSERT_EQ(WMError::WM_OK, window->Hide());
388 usleep(WAIT_SYANC_US);
389 }
390
391 /**
392 * @tc.name: LayoutWindow09
393 * @tc.desc: Add a floating and resize(2, 2)
394 * @tc.type: FUNC
395 */
396 HWTEST_F(WindowLayoutTest, LayoutWindow09, Function | MediumTest | Level3)
397 {
398 Utils::TestWindowInfo info = {
399 .name = "main9",
400 .rect = {0, 0, 0, 0},
401 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
402 .mode = WindowMode::WINDOW_MODE_FLOATING,
403 .needAvoid = true,
404 .parentLimit = false,
405 .showWhenLocked = true,
406 .parentId = INVALID_WINDOW_ID,
407 };
408 const sptr<Window>& window = Utils::CreateTestWindow(info);
409 if (window == nullptr) {
410 return;
411 }
412 activeWindows_.push_back(window);
413 Rect expect = Utils::GetDefaultFloatingRect(window, true);
414
415 ASSERT_EQ(WMError::WM_OK, window->Show());
416 usleep(WAIT_SYANC_US);
417 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
418
419 ASSERT_EQ(WMError::WM_OK, window->Resize(2u, 2u)); // 2: custom min size
420 Rect finalExcept = { expect.posX_, expect.posY_, 2u, 2u}; // 2: custom min size
421 finalExcept = Utils::GetFloatingLimitedRect(finalExcept, virtualPixelRatio_);
422 ASSERT_TRUE(Utils::RectEqualTo(window, finalExcept));
423 ASSERT_EQ(WMError::WM_OK, window->Hide());
424 }
425
426 /**
427 * @tc.name: LayoutWindow10
428 * @tc.desc: One FLOATING APP Window do max and recovery
429 * @tc.type: FUNC
430 */
431 HWTEST_F(WindowLayoutTest, LayoutWindow10, Function | MediumTest | Level3)
432 {
433 Utils::TestWindowInfo info = {
434 .name = "main10",
435 .rect = {0, 0, 0, 0},
436 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
437 .mode = WindowMode::WINDOW_MODE_FLOATING,
438 .needAvoid = true,
439 .parentLimit = false,
440 .showWhenLocked = true,
441 .parentId = INVALID_WINDOW_ID,
442 };
443 const sptr<Window>& window = Utils::CreateTestWindow(info);
444 if (window == nullptr) {
445 return;
446 }
447 activeWindows_.push_back(window);
448 Rect expect = Utils::GetDefaultFloatingRect(window, true);
449 ASSERT_EQ(WMError::WM_OK, window->Show());
450 usleep(WAIT_SYANC_US);
451 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
452 ASSERT_EQ(WMError::WM_OK, window->Maximize());
453 usleep(WAIT_SYANC_US);
454 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::displayRect_));
455 ASSERT_EQ(WMError::WM_OK, window->Recover());
456 usleep(WAIT_SYANC_US);
457 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
458 ASSERT_EQ(WMError::WM_OK, window->Minimize());
459 usleep(WAIT_SYANC_US);
460 ASSERT_EQ(WMError::WM_OK, window->Close());
461 }
462
463 /**
464 * @tc.name: LayoutTile01
465 * @tc.desc: One FLOATING APP Window into tile mode, show 4 new window
466 * @tc.type: FUNC
467 */
468 HWTEST_F(WindowLayoutTest, LayoutTile01, Function | MediumTest | Level3)
469 {
470 Utils::TestWindowInfo info = {
471 .name = "mainTile1",
472 .rect = {0, 0, 0, 0},
473 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
474 .mode = WindowMode::WINDOW_MODE_FLOATING,
475 .needAvoid = true,
476 .parentLimit = false,
477 .parentId = INVALID_WINDOW_ID,
478 };
479
480 const sptr<Window>& window = Utils::CreateTestWindow(info);
481 if (window == nullptr) {
482 return;
483 }
484 activeWindows_.push_back(window);
485 Rect expect = Utils::GetDefaultFloatingRect(window, true);
486 ASSERT_EQ(WMError::WM_OK, window->Show());
487 usleep(WAIT_SYANC_US);
488 // init tile window rects and get max tile window num
489 Utils::InitTileWindowRects(window, false);
490 uint32_t maxTileNum = Utils::GetMaxTileWinNum();
491 if (maxTileNum < 1) {
492 return;
493 }
494
495 usleep(WAIT_SYANC_US);
496 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
497 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
498 usleep(WAIT_SYANC_US);
499 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
500
501 info.name = "test1";
502 const sptr<Window>& test1 = Utils::CreateTestWindow(info);
503 activeWindows_.push_back(test1);
504 ASSERT_EQ(WMError::WM_OK, test1->Show());
505 usleep(WAIT_SYANC_US);
506 if (maxTileNum == 1) {
507 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_));
508 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
509 return;
510 }
511 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0]));
512 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1]));
513
514 info.name = "test2";
515 const sptr<Window>& test2 = Utils::CreateTestWindow(info);
516 activeWindows_.push_back(test2);
517 ASSERT_EQ(WMError::WM_OK, test2->Show());
518 usleep(WAIT_SYANC_US);
519 if (maxTileNum == 2) {
520 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
521 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
522 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
523 return;
524 }
525 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
526 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
527 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
528 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
529 }
530
531 /**
532 * @tc.name: LayoutTileNegative01
533 * @tc.desc: negative test for tile window
534 * @tc.type: FUNC
535 */
536 HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3)
537 {
538 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
539 Utils::TestWindowInfo info = {
540 .name = "mainTileNegative1",
541 .rect = {-1, -100, -1, -100}, // -1, -100, -1, -100 is typical negative case nums
542 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
543 .mode = WindowMode::WINDOW_MODE_FLOATING,
544 .needAvoid = true,
545 .parentLimit = false,
546 .parentId = INVALID_WINDOW_ID,
547 };
548 const sptr<Window>& window = Utils::CreateTestWindow(info);
549 if (window == nullptr) {
550 return;
551 }
552 activeWindows_.push_back(window);
553 ASSERT_EQ(WMError::WM_OK, window->Show());
554 usleep(WAIT_SYANC_US);
555 // init tile window rects and get max tile window num
556 Utils::InitTileWindowRects(window, false);
557 uint32_t maxTileNum = Utils::GetMaxTileWinNum();
558 if (maxTileNum < 1) {
559 return;
560 }
561
562 usleep(WAIT_SYANC_US);
563 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
564 usleep(WAIT_SYANC_US);
565 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
566
567 info.name = "test1";
568 const sptr<Window>& test1 = Utils::CreateTestWindow(info);
569 activeWindows_.push_back(test1);
570 ASSERT_EQ(WMError::WM_OK, test1->Show());
571 usleep(WAIT_SYANC_US);
572 if (maxTileNum == 1) {
573 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_));
574 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
575 return;
576 }
577 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0]));
578 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1]));
579
580 info.name = "test2";
581 const sptr<Window>& test2 = Utils::CreateTestWindow(info);
582 activeWindows_.push_back(test2);
583 ASSERT_EQ(WMError::WM_OK, test2->Show());
584 usleep(WAIT_SYANC_US);
585 if (maxTileNum == 2) {
586 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
587 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
588 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
589 return;
590 }
591 ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
592 ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
593 ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
594 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
595 }
596
597 /**
598 * @tc.name: LayoutTileNegative01
599 * @tc.desc: move window out of the display
600 * @tc.type: FUNC
601 */
602 HWTEST_F(WindowLayoutTest, LayoutNegative01, Function | MediumTest | Level3)
603 {
604 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
605 Utils::TestWindowInfo info = {
606 .name = "mainNegative1",
607 .rect = {0, 0, 0, 0},
608 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
609 .mode = WindowMode::WINDOW_MODE_FLOATING,
610 .needAvoid = true,
611 .parentLimit = false,
612 .parentId = INVALID_WINDOW_ID,
613 };
614 const sptr<Window>& window = Utils::CreateTestWindow(info);
615 if (window == nullptr) {
616 return;
617 }
618 activeWindows_.push_back(window);
619 Rect expect = Utils::GetDefaultFloatingRect(window, true);
620 ASSERT_EQ(WMError::WM_OK, window->Show());
621 usleep(WAIT_SYANC_US);
622 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
623 }
624
625 /**
626 * @tc.name: LayoutNegative02
627 * @tc.desc: resize window to negative size
628 * @tc.type: FUNC
629 */
630 HWTEST_F(WindowLayoutTest, LayoutNegative02, Function | MediumTest | Level3)
631 {
632 WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
633 const uint32_t negativeW = 0;
634 const uint32_t negativeH = 0;
635 Utils::TestWindowInfo info = {
636 .name = "mainNegative2",
637 .rect = {0, 0, 0, 0},
638 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
639 .mode = WindowMode::WINDOW_MODE_FLOATING,
640 .needAvoid = true,
641 .parentLimit = false,
642 .parentId = INVALID_WINDOW_ID,
643 };
644 const sptr<Window>& window = Utils::CreateTestWindow(info);
645 if (window == nullptr) {
646 return;
647 }
648 activeWindows_.push_back(window);
649 Rect expect = Utils::GetDefaultFloatingRect(window, true);
650 ASSERT_EQ(WMError::WM_OK, window->Show());
651 usleep(WAIT_SYANC_US);
652 ASSERT_TRUE(Utils::RectEqualTo(window, expect));
653 window->Resize(negativeW, negativeH);
654 usleep(WAIT_SYANC_US);
655 Rect expect2 = {expect.posX_, expect.posY_, negativeW, negativeH};
656 expect2 = Utils::CalcLimitedRect(expect2, virtualPixelRatio_);
657 ASSERT_TRUE(Utils::RectEqualTo(window, expect2));
658 }
659 }
660 } // namespace Rosen
661 } // namespace OHOS
662