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