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