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