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_test_utils.h"
19 #include "wm_common.h"
20 #include "window_adapter.h"
21 #include "window_scene_session_impl.h"
22 #include "ability_context_impl.h"
23 #include "mock_session.h"
24 #include "session/host/include/scene_session.h"
25 
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 using Utils = WindowTestUtils;
33 class WindowLayoutTest : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     virtual void SetUp() override;
38     virtual void TearDown() override;
39     DisplayId displayId_ = 0;
40     std::vector<sptr<Window>> activeWindows_;
41     static vector<Rect> fullScreenExpecteds_;
42     static inline float virtualPixelRatio_ = 0.0;
43 private:
44     static constexpr uint32_t WAIT_SYANC_US = 100000;
45     static void InitAvoidArea();
46     std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
47 };
48 
49 vector<Rect> WindowLayoutTest::fullScreenExpecteds_;
50 
SetUpTestCase()51 void WindowLayoutTest::SetUpTestCase()
52 {
53     SingletonContainer::Get<WindowAdapter>().MinimizeAllAppWindows(0);
54     sleep(2);
55     auto display = DisplayManager::GetInstance().GetDisplayById(0);
56     if (display == nullptr) {
57         return;
58     }
59     ASSERT_TRUE((display != nullptr));
60     Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()};
61     Utils::InitByDisplayRect(displayRect);
62 
63     virtualPixelRatio_ = WindowTestUtils::GetVirtualPixelRatio(0);
64 
65     // calc expected rects
66     Rect expected = { // 0. only statusBar
67         0,
68         Utils::statusBarRect_.height_,
69         Utils::displayRect_.width_,
70         Utils::displayRect_.height_ - Utils::statusBarRect_.height_,
71     };
72     fullScreenExpecteds_.push_back(expected);
73     expected = { // 1. both statusBar and naviBar
74         0,
75         Utils::statusBarRect_.height_,
76         Utils::displayRect_.width_,
77         Utils::displayRect_.height_ - Utils::statusBarRect_.height_ - Utils::naviBarRect_.height_,
78     };
79     fullScreenExpecteds_.push_back(expected);
80     expected = { // 2. only naviBar
81         0,
82         0,
83         Utils::displayRect_.width_,
84         Utils::displayRect_.height_ - Utils::naviBarRect_.height_,
85     };
86     fullScreenExpecteds_.push_back(expected);
87     InitAvoidArea();
88     sleep(2);
89 }
90 
InitAvoidArea()91 void WindowLayoutTest::InitAvoidArea()
92 {
93     Utils::TestWindowInfo info = {
94         .name = "avoidArea",
95         .rect = {0, 0, 0, 0},
96         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
97         .mode = WindowMode::WINDOW_MODE_FLOATING,
98         .needAvoid = true,
99         .parentLimit = false,
100         .parentId = INVALID_WINDOW_ID,
101     };
102     const sptr<Window>& window = Utils::CreateTestWindow(info);
103     if (window == nullptr) {
104         return;
105     }
106     window->Show();
107     window->SetLayoutFullScreen(true);
108     window->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM, WindowTestUtils::systemAvoidArea_);
109     window->Hide();
110     window->Destroy();
111 }
112 
TearDownTestCase()113 void WindowLayoutTest::TearDownTestCase()
114 {
115 }
116 
SetUp()117 void WindowLayoutTest::SetUp()
118 {
119     activeWindows_.clear();
120     abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
121 }
122 
TearDown()123 void WindowLayoutTest::TearDown()
124 {
125     abilityContext_ = nullptr;
126 }
127 
128 namespace {
129 /**
130  * @tc.name: LayoutWindow01
131  * @tc.desc: One FLOATING APP Window with on custom rect
132  * @tc.type: FUNC
133  */
134 HWTEST_F(WindowLayoutTest, LayoutWindow01, Function | MediumTest | Level3)
135 {
136     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
137     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
138     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
139     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
140 
141     Utils::TestWindowInfo info = {
142         .name = "main1",
143         .rect = {0, 0, 0, 0},
144         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
145         .mode = WindowMode::WINDOW_MODE_FLOATING,
146         .needAvoid = true,
147         .parentLimit = false,
148         .showWhenLocked = true,
149         .parentId = INVALID_WINDOW_ID,
150     };
151     const sptr<Window>& window = Utils::CreateTestWindow(info);
152     if (window == nullptr) {
153         return;
154     }
155     ASSERT_EQ(true, window != nullptr);
156     activeWindows_.push_back(window);
157     Rect expect = Utils::GetDefaultFloatingRect(window, true);
158     ASSERT_EQ(WMError::WM_OK, window->Show());
159     ASSERT_TRUE(Utils::RectEqualTo(window, Utils::GetFloatingLimitedRect(expect, virtualPixelRatio_)));
160     ASSERT_EQ(WMError::WM_OK, window->Hide());
161 }
162 
163 /**
164  * @tc.name: LayoutWindow02
165  * @tc.desc: One FLOATING APP Window
166  * @tc.type: FUNC
167  */
168 HWTEST_F(WindowLayoutTest, LayoutWindow02, Function | MediumTest | Level3)
169 {
170     Rect res = Utils::GetFloatingLimitedRect(Utils::customAppRect_, virtualPixelRatio_);
171     Utils::TestWindowInfo info = {
172         .name = "main2",
173         .rect = res,
174         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
175         .mode = WindowMode::WINDOW_MODE_FLOATING,
176         .needAvoid = true,
177         .parentLimit = false,
178         .showWhenLocked = true,
179         .parentId = INVALID_WINDOW_ID,
180     };
181     const sptr<Window>& window = Utils::CreateTestWindow(info);
182     if (window == nullptr) {
183         return;
184     }
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     if (appWin == nullptr) {
217         return;
218     }
219 
220     activeWindows_.push_back(appWin);
221 
222     // statusBar window
223     sptr<Window> statBar = Utils::CreateStatusBarWindow();
224     activeWindows_.push_back(statBar);
225 
226     ASSERT_EQ(WMError::WM_OK, appWin->Show());
227     if (appWin->IsDecorEnable()) {
228         ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
229     } else {
230         ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
231     }
232     ASSERT_EQ(WMError::WM_OK, statBar->Show());
233     if (appWin->IsDecorEnable()) {
234         ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
235     } else {
236         ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
237     }
238     ASSERT_EQ(WMError::WM_OK, statBar->Hide());
239     if (appWin->IsDecorEnable()) {
240         ASSERT_TRUE(Utils::RectEqualTo(appWin, Utils::GetDecorateRect(res, virtualPixelRatio_)));
241     } else {
242         ASSERT_TRUE(Utils::RectEqualTo(appWin, res));
243     }
244 }
245 
246 /**
247  * @tc.name: LayoutWindow06
248  * @tc.desc: StatusBar Window and NaviBar & Sys Window FULLSCRENN,NOT NEEDVOID,PARENTLIMIT
249  * @tc.type: FUNC
250  */
251 HWTEST_F(WindowLayoutTest, LayoutWindow06, Function | MediumTest | Level3)
252 {
253     sptr<Window> statBar = Utils::CreateStatusBarWindow();
254     if (statBar == nullptr) {
255         return;
256     }
257     activeWindows_.push_back(statBar);
258     sptr<Window> naviBar = Utils::CreateNavigationBarWindow();
259     activeWindows_.push_back(naviBar);
260     Utils::TestWindowInfo info = {
261         .name = "main6",
262         .rect = Utils::customAppRect_,
263         .type = WindowType::WINDOW_TYPE_PANEL,
264         .mode = WindowMode::WINDOW_MODE_FULLSCREEN,
265         .needAvoid = false,
266         .parentLimit = true,
267         .showWhenLocked = true,
268         .parentId = INVALID_WINDOW_ID,
269     };
270     sptr<Window> sysWin = Utils::CreateTestWindow(info);
271     ASSERT_NE(sysWin, nullptr);
272     activeWindows_.push_back(sysWin);
273     if (statBar->Show() == WMError::WM_OK) {
274         ASSERT_EQ(WMError::WM_OK, statBar->Show());
275     } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) {
276         ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show());
277     }
278     sysWin->Show();
279     if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
280         ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
281     }
282     if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
283         ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
284     } else {
285         ASSERT_FALSE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
286     }
287     if (WMError::WM_OK == naviBar->Show()) {
288         ASSERT_EQ(WMError::WM_OK, naviBar->Show());
289     }
290     if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
291         ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
292     }
293     if (WMError::WM_OK == statBar->Hide()) {
294         ASSERT_EQ(WMError::WM_OK, statBar->Hide());
295     }
296     if (Utils::RectEqualTo(sysWin, Utils::displayRect_)) {
297         ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::displayRect_));
298     }
299 }
300 
301 /**
302  * @tc.name: LayoutWindow07
303  * @tc.desc: StatusBar Window and NaviBar & One Floating Sys Window
304  * @tc.type: FUNC
305  */
306 HWTEST_F(WindowLayoutTest, LayoutWindow07, Function | MediumTest | Level3)
307 {
308     // statusBar window
309     sptr<Window> statBar = Utils::CreateStatusBarWindow();
310     if (statBar == nullptr) {
311         return;
312     }
313     activeWindows_.push_back(statBar);
314 
315     // naviBar window
316     sptr<Window> naviBar = Utils::CreateNavigationBarWindow();
317     ASSERT_NE(naviBar, nullptr);
318     activeWindows_.push_back(naviBar);
319     // sys window
320     Utils::TestWindowInfo info = {
321         .name = "main7",
322         .rect = Utils::customAppRect_,
323         .type = WindowType::WINDOW_TYPE_PANEL,
324         .mode = WindowMode::WINDOW_MODE_FLOATING,
325         .needAvoid = false,
326         .parentLimit = true,
327         .showWhenLocked = true,
328         .parentId = INVALID_WINDOW_ID,
329     };
330     sptr<Window> sysWin = Utils::CreateTestWindow(info);
331     ASSERT_NE(sysWin, nullptr);
332     activeWindows_.push_back(sysWin);
333     if (statBar->Show() == WMError::WM_OK) {
334         ASSERT_EQ(WMError::WM_OK, statBar->Show());
335     } else if (statBar->Show() == WMError::WM_ERROR_INVALID_WINDOW) {
336         ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Show());
337     }
338     sysWin->Show();
339 
340     ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
341 
342     if (WMError::WM_OK == naviBar->Show()) {
343         ASSERT_EQ(WMError::WM_OK, naviBar->Show());
344     } else {
345         ASSERT_NE(WMError::WM_OK, naviBar->Show());
346     }
347 
348     ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
349     if (statBar->Hide() == WMError::WM_OK) {
350         ASSERT_EQ(WMError::WM_OK, statBar->Hide());
351     } else if (statBar->Hide() == WMError::WM_ERROR_INVALID_WINDOW) {
352         ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, statBar->Hide());
353     }
354     ASSERT_TRUE(Utils::RectEqualTo(sysWin, Utils::customAppRect_));
355 }
356 
357 /**
358  * @tc.name: LayoutWindow08
359  * @tc.desc: One FLOATING APP Window with on custom rect
360  * @tc.type: FUNC
361  */
362 HWTEST_F(WindowLayoutTest, LayoutWindow08, Function | MediumTest | Level3)
363 {
364     Utils::TestWindowInfo info = {
365         .name = "main8",
366         .rect = {0, 0, 0, 0},
367         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
368         .mode = WindowMode::WINDOW_MODE_FLOATING,
369         .needAvoid = true,
370         .parentLimit = false,
371         .showWhenLocked = true,
372         .parentId = INVALID_WINDOW_ID,
373     };
374     const sptr<Window>& window = Utils::CreateTestWindow(info);
375     if (window == nullptr) {
376         return;
377     }
378     activeWindows_.push_back(window);
379     Rect expect = Utils::GetDefaultFloatingRect(window, true);
380     ASSERT_EQ(WMError::WM_OK, window->Show());
381     usleep(WAIT_SYANC_US);
382     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
383     ASSERT_EQ(WMError::WM_OK, window->Hide());
384     usleep(WAIT_SYANC_US);
385 }
386 
387 /**
388  * @tc.name: LayoutWindow09
389  * @tc.desc: Add a floating and resize(2, 2)
390  * @tc.type: FUNC
391  */
392 HWTEST_F(WindowLayoutTest, LayoutWindow09, Function | MediumTest | Level3)
393 {
394     Utils::TestWindowInfo info = {
395         .name = "main9",
396         .rect = {0, 0, 0, 0},
397         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
398         .mode = WindowMode::WINDOW_MODE_FLOATING,
399         .needAvoid = true,
400         .parentLimit = false,
401         .showWhenLocked = true,
402         .parentId = INVALID_WINDOW_ID,
403     };
404     const sptr<Window>& window = Utils::CreateTestWindow(info);
405     if (window == nullptr) {
406         return;
407     }
408     activeWindows_.push_back(window);
409     Rect expect = Utils::GetDefaultFloatingRect(window, true);
410 
411     ASSERT_EQ(WMError::WM_OK, window->Show());
412     usleep(WAIT_SYANC_US);
413     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
414 
415     ASSERT_EQ(WMError::WM_OK, window->Resize(2u, 2u));        // 2: custom min size
416     Rect finalExcept = { expect.posX_, expect.posY_, 2u, 2u}; // 2: custom min size
417     finalExcept = Utils::GetFloatingLimitedRect(finalExcept, virtualPixelRatio_);
418     ASSERT_TRUE(Utils::RectEqualTo(window, finalExcept));
419     ASSERT_EQ(WMError::WM_OK, window->Hide());
420 }
421 
422 /**
423  * @tc.name: LayoutWindow10
424  * @tc.desc: One FLOATING APP Window do max and recovery
425  * @tc.type: FUNC
426  */
427 HWTEST_F(WindowLayoutTest, LayoutWindow10, Function | MediumTest | Level3)
428 {
429     Utils::TestWindowInfo info = {
430         .name = "main10",
431         .rect = {0, 0, 0, 0},
432         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
433         .mode = WindowMode::WINDOW_MODE_FLOATING,
434         .needAvoid = true,
435         .parentLimit = false,
436         .showWhenLocked = true,
437         .parentId = INVALID_WINDOW_ID,
438     };
439     const sptr<Window>& window = Utils::CreateTestWindow(info);
440     if (window == nullptr) {
441         return;
442     }
443     activeWindows_.push_back(window);
444     Rect expect = Utils::GetDefaultFloatingRect(window, true);
445     ASSERT_EQ(WMError::WM_OK, window->Show());
446     usleep(WAIT_SYANC_US);
447     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
448     ASSERT_EQ(WMError::WM_OK, window->Maximize());
449     usleep(WAIT_SYANC_US);
450     ASSERT_TRUE(Utils::RectEqualTo(window, Utils::displayRect_));
451     ASSERT_EQ(WMError::WM_OK, window->Recover());
452     usleep(WAIT_SYANC_US);
453     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
454     ASSERT_EQ(WMError::WM_OK, window->Minimize());
455     usleep(WAIT_SYANC_US);
456     ASSERT_EQ(WMError::WM_OK, window->Close());
457 }
458 
459 /**
460  * @tc.name: LayoutTile01
461  * @tc.desc: One FLOATING APP Window into tile mode, show 4 new window
462  * @tc.type: FUNC
463  */
464 HWTEST_F(WindowLayoutTest, LayoutTile01, Function | MediumTest | Level3)
465 {
466     Utils::TestWindowInfo info = {
467         .name = "mainTile1", .rect = {0, 0, 0, 0}, .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
468         .mode = WindowMode::WINDOW_MODE_FLOATING, .needAvoid = true, .parentLimit = false,
469         .parentId = INVALID_WINDOW_ID,
470     };
471 
472     const sptr<Window>& window = Utils::CreateTestWindow(info);
473     if (window == nullptr) {
474         return;
475     }
476     activeWindows_.push_back(window);
477     Rect expect = Utils::GetDefaultFloatingRect(window, true);
478     ASSERT_EQ(WMError::WM_OK, window->Show());
479     usleep(WAIT_SYANC_US);
480     // init tile window rects and get max tile window num
481     Utils::InitTileWindowRects(window, false);
482     uint32_t maxTileNum = Utils::GetMaxTileWinNum();
483     if (maxTileNum < 1) {
484         return;
485     }
486 
487     usleep(WAIT_SYANC_US);
488     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
489     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
490     usleep(WAIT_SYANC_US);
491     ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
492 
493     info.name = "test1";
494     const sptr<Window>& test1 = Utils::CreateTestWindow(info);
495     ASSERT_NE(nullptr, test1);
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     ASSERT_NE(nullptr, test2);
510     activeWindows_.push_back(test2);
511     ASSERT_EQ(WMError::WM_OK, test2->Show());
512     usleep(WAIT_SYANC_US);
513     if (maxTileNum == 2) {
514         ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
515         ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
516     } else {
517         ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
518         ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
519         ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
520     }
521     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
522 }
523 
524 /**
525  * @tc.name: LayoutTileNegative01
526  * @tc.desc: negative test for tile window
527  * @tc.type: FUNC
528  */
529 HWTEST_F(WindowLayoutTest, LayoutTileNegative01, Function | MediumTest | Level3)
530 {
531     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
532     Utils::TestWindowInfo info = {
533         .name = "mainTileNegative1", .rect = {-1, -100, -1, -100}, // -1, -100, -1, -100 is typical negative case nums
534         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, .mode = WindowMode::WINDOW_MODE_FLOATING,
535         .needAvoid = true, .parentLimit = false, .parentId = INVALID_WINDOW_ID,
536     };
537     const sptr<Window>& window = Utils::CreateTestWindow(info);
538     if (window == nullptr) {
539         return;
540     }
541     activeWindows_.push_back(window);
542     ASSERT_EQ(WMError::WM_OK, window->Show());
543     usleep(WAIT_SYANC_US);
544     // init tile window rects and get max tile window num
545     Utils::InitTileWindowRects(window, false);
546     uint32_t maxTileNum = Utils::GetMaxTileWinNum();
547     if (maxTileNum < 1) {
548         return;
549     }
550 
551     usleep(WAIT_SYANC_US);
552     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::TILE);
553     usleep(WAIT_SYANC_US);
554     ASSERT_TRUE(Utils::RectEqualTo(window, Utils::singleTileRect_));
555 
556     info.name = "test1";
557     const sptr<Window>& test1 = Utils::CreateTestWindow(info);
558     ASSERT_NE(nullptr, test1);
559     activeWindows_.push_back(test1);
560     ASSERT_EQ(WMError::WM_OK, test1->Show());
561     usleep(WAIT_SYANC_US);
562     if (maxTileNum == 1) {
563         ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::singleTileRect_));
564         WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
565         return;
566     }
567     ASSERT_TRUE(Utils::RectEqualTo(window, Utils::doubleTileRects_[0]));
568     ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[1]));
569 
570     info.name = "test2";
571     const sptr<Window>& test2 = Utils::CreateTestWindow(info);
572     ASSERT_NE(nullptr, test2);
573     activeWindows_.push_back(test2);
574     ASSERT_EQ(WMError::WM_OK, test2->Show());
575     usleep(WAIT_SYANC_US);
576     if (maxTileNum == 2) {
577         ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::doubleTileRects_[0]));
578         ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::doubleTileRects_[1]));
579     } else {
580         ASSERT_TRUE(Utils::RectEqualTo(window, Utils::tripleTileRects_[0]));
581         ASSERT_TRUE(Utils::RectEqualTo(test1, Utils::tripleTileRects_[1]));
582         ASSERT_TRUE(Utils::RectEqualTo(test2, Utils::tripleTileRects_[2])); // 2 is second rect idx
583     }
584     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
585 }
586 
587 /**
588  * @tc.name: LayoutTileNegative01
589  * @tc.desc: move window out of the display
590  * @tc.type: FUNC
591  */
592 HWTEST_F(WindowLayoutTest, LayoutNegative01, Function | MediumTest | Level3)
593 {
594     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
595     Utils::TestWindowInfo info = {
596         .name = "mainNegative1",
597         .rect = {0, 0, 0, 0},
598         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
599         .mode = WindowMode::WINDOW_MODE_FLOATING,
600         .needAvoid = true,
601         .parentLimit = false,
602         .parentId = INVALID_WINDOW_ID,
603     };
604     const sptr<Window>& window = Utils::CreateTestWindow(info);
605     if (window == nullptr) {
606         return;
607     }
608     activeWindows_.push_back(window);
609     Rect expect = Utils::GetDefaultFloatingRect(window, true);
610     ASSERT_EQ(WMError::WM_OK, window->Show());
611     usleep(WAIT_SYANC_US);
612     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
613 }
614 
615 /**
616  * @tc.name: LayoutNegative02
617  * @tc.desc: resize window to negative size
618  * @tc.type: FUNC
619  */
620 HWTEST_F(WindowLayoutTest, LayoutNegative02, Function | MediumTest | Level3)
621 {
622     WindowManager::GetInstance().SetWindowLayoutMode(WindowLayoutMode::CASCADE);
623     const uint32_t negativeW = 0;
624     const uint32_t negativeH = 0;
625     Utils::TestWindowInfo info = {
626         .name = "mainNegative2",
627         .rect = {0, 0, 0, 0},
628         .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
629         .mode = WindowMode::WINDOW_MODE_FLOATING,
630         .needAvoid = true,
631         .parentLimit = false,
632         .parentId = INVALID_WINDOW_ID,
633     };
634     const sptr<Window>& window = Utils::CreateTestWindow(info);
635     if (window == nullptr) {
636         return;
637     }
638     activeWindows_.push_back(window);
639     Rect expect = Utils::GetDefaultFloatingRect(window, true);
640     ASSERT_EQ(WMError::WM_OK, window->Show());
641     usleep(WAIT_SYANC_US);
642     ASSERT_TRUE(Utils::RectEqualTo(window, expect));
643     window->Resize(negativeW, negativeH);
644     usleep(WAIT_SYANC_US);
645     Rect expect2 = {expect.posX_, expect.posY_, negativeW, negativeH};
646     expect2 = Utils::CalcLimitedRect(expect2, virtualPixelRatio_);
647     ASSERT_TRUE(Utils::RectEqualTo(window, expect2));
648 }
649 
650 /**
651  * @tc.name: moveWindowTo01
652  * @tc.desc: test moveWindowTo for ALN/PC with windowMode: 102, windowType: 2106
653  * @tc.type: FUNC
654  */
655 HWTEST_F(WindowLayoutTest, moveWindowTo01, Function | MediumTest | Level3)
656 {
657     sptr<WindowOption> option = new (std::nothrow) WindowOption();
658     ASSERT_NE(option, nullptr);
659     option->SetWindowName("moveWindowTo01");
660     option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
661     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
662 
663     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
664     ASSERT_NE(window, nullptr);
665 
666     window->property_->SetPersistentId(10001);
667 
668     Rect rect;
669     WMError ret;
670     ret = window->Create(abilityContext_, nullptr);
671     EXPECT_EQ(WMError::WM_OK, ret);
672 
673     ret = window->Show();
674     EXPECT_EQ(WMError::WM_OK, ret);
675 
676     ret = window->MoveTo(-500, -500);
677     usleep(100000);
678     EXPECT_EQ(WMError::WM_OK, ret);
679     rect = window->property_->GetWindowRect();
680     EXPECT_EQ(-500, rect.posX_);
681     EXPECT_EQ(-500, rect.posY_);
682 
683     ret = window->MoveTo(0, 0);
684     usleep(100000);
685     EXPECT_EQ(WMError::WM_OK, ret);
686     rect = window->property_->GetWindowRect();
687     EXPECT_EQ(0, rect.posX_);
688     EXPECT_EQ(0, rect.posY_);
689 
690     ret = window->MoveTo(500, 500);
691     usleep(100000);
692     EXPECT_EQ(WMError::WM_OK, ret);
693     rect = window->property_->GetWindowRect();
694     EXPECT_EQ(500, rect.posX_);
695     EXPECT_EQ(500, rect.posY_);
696 
697     ret = window->MoveTo(20000, 20000);
698     usleep(100000);
699     EXPECT_EQ(WMError::WM_OK, ret);
700     rect = window->property_->GetWindowRect();
701     EXPECT_EQ(20000, rect.posX_);
702     EXPECT_EQ(20000, rect.posY_);
703 }
704 
705 /**
706  * @tc.name: moveWindowTo02
707  * @tc.desc: test moveWindowTo for ALN with windowMode: 102, windowType: 1001
708  * @tc.type: FUNC
709  */
710 HWTEST_F(WindowLayoutTest, moveWindowTo02, Function | MediumTest | Level3)
711 {
712     sptr<WindowOption> option = new (std::nothrow) WindowOption();
713     ASSERT_NE(option, nullptr);
714     option->SetWindowName("moveWindowTo02");
715     option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
716     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
717 
718     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
719     ASSERT_NE(window, nullptr);
720 
721     SessionInfo sessionInfo = { "bundleName_moveWindowTo02",
722         "moduleName_moveWindowTo02", "abilityName_moveWindowTo02" };
723     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
724     ASSERT_NE(sceneSession, nullptr);
725 
726     Rect rectOld;
727     Rect rectNow;
728     WMError ret;
729     ret = window->Create(abilityContext_, sceneSession);
730     EXPECT_EQ(WMError::WM_OK, ret);
731     ret = window->Show();
732     EXPECT_EQ(WMError::WM_OK, ret);
733     window->property_->SetPersistentId(10002);
734 
735     rectOld = window->property_->GetWindowRect();
736     ret = window->MoveTo(-500, -500);
737     usleep(100000);
738     EXPECT_EQ(WMError::WM_OK, ret);
739     rectNow = window->property_->GetWindowRect();
740     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
741     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
742 
743     rectOld = window->property_->GetWindowRect();
744     ret = window->MoveTo(0, 0);
745     usleep(100000);
746     EXPECT_EQ(WMError::WM_OK, ret);
747     rectNow = window->property_->GetWindowRect();
748     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
749     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
750 
751     rectOld = window->property_->GetWindowRect();
752     ret = window->MoveTo(500, 500);
753     usleep(100000);
754     EXPECT_EQ(WMError::WM_OK, ret);
755     rectNow = window->property_->GetWindowRect();
756     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
757     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
758 }
759 
760 /**
761  * @tc.name: moveWindowTo03
762  * @tc.desc: test moveWindowTo for ALN with windowMode: 1, windowType: 1
763  * @tc.type: FUNC
764  */
765 HWTEST_F(WindowLayoutTest, moveWindowTo03, Function | MediumTest | Level3)
766 {
767     sptr<WindowOption> option = new (std::nothrow) WindowOption();
768     ASSERT_NE(option, nullptr);
769     option->SetWindowName("moveWindowTo03");
770     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
771     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
772 
773     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
774     ASSERT_NE(window, nullptr);
775 
776     window->property_->SetPersistentId(10003);
777 
778     SessionInfo sessionInfo = { "bundleName_moveWindowTo03",
779         "moduleName_moveWindowTo03", "abilityName_moveWindowTo03" };
780     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
781     ASSERT_NE(sceneSession, nullptr);
782 
783     Rect rectOld;
784     Rect rectNow;
785     WMError ret;
786     ret = window->Create(abilityContext_, sceneSession);
787     EXPECT_EQ(WMError::WM_OK, ret);
788     ret = window->Show();
789     EXPECT_EQ(WMError::WM_OK, ret);
790 
791     rectOld = window->property_->GetWindowRect();
792     ret = window->MoveTo(-500, -500);
793     usleep(100000);
794     EXPECT_EQ(WMError::WM_OK, ret);
795     rectNow = window->property_->GetWindowRect();
796     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
797     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
798 
799     rectOld = window->property_->GetWindowRect();
800     ret = window->MoveTo(0, 0);
801     usleep(100000);
802     EXPECT_EQ(WMError::WM_OK, ret);
803     rectNow = window->property_->GetWindowRect();
804     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
805     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
806 
807     rectOld = window->property_->GetWindowRect();
808     ret = window->MoveTo(500, 500);
809     usleep(100000);
810     EXPECT_EQ(WMError::WM_OK, ret);
811     rectNow = window->property_->GetWindowRect();
812     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
813     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
814 
815     rectOld = window->property_->GetWindowRect();
816     ret = window->MoveTo(20000, 20000);
817     usleep(100000);
818     EXPECT_EQ(WMError::WM_OK, ret);
819     rectNow = window->property_->GetWindowRect();
820     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
821     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
822 }
823 
824 /**
825  * @tc.name: moveWindowTo04
826  * @tc.desc: test moveWindowTo for ALN with windowMode: 100, windowType: 1
827  * @tc.type: FUNC
828  */
829 HWTEST_F(WindowLayoutTest, moveWindowTo04, Function | MediumTest | Level3)
830 {
831     sptr<WindowOption> option = new (std::nothrow) WindowOption();
832     ASSERT_NE(option, nullptr);
833     option->SetWindowName("moveWindowTo04");
834     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
835     option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
836 
837     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
838     ASSERT_NE(window, nullptr);
839 
840     window->property_->SetPersistentId(10004);
841 
842     SessionInfo sessionInfo = { "bundleName_moveWindowTo04",
843         "moduleName_moveWindowTo04", "abilityName_moveWindowTo04" };
844     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
845     ASSERT_NE(sceneSession, nullptr);
846 
847     Rect rectOld;
848     Rect rectNow;
849     WMError ret;
850     ret = window->Create(abilityContext_, sceneSession);
851     EXPECT_EQ(WMError::WM_OK, ret);
852     ret = window->Show();
853     EXPECT_EQ(WMError::WM_OK, ret);
854 
855     rectOld = window->property_->GetWindowRect();
856     ret = window->MoveTo(-500, -500);
857     usleep(100000);
858     EXPECT_EQ(WMError::WM_OK, ret);
859     rectNow = window->property_->GetWindowRect();
860     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
861     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
862 
863     rectOld = window->property_->GetWindowRect();
864     ret = window->MoveTo(0, 0);
865     usleep(100000);
866     EXPECT_EQ(WMError::WM_OK, ret);
867     rectNow = window->property_->GetWindowRect();
868     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
869     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
870 
871     rectOld = window->property_->GetWindowRect();
872     ret = window->MoveTo(500, 500);
873     usleep(100000);
874     EXPECT_EQ(WMError::WM_OK, ret);
875     rectNow = window->property_->GetWindowRect();
876     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
877     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
878 
879     rectOld = window->property_->GetWindowRect();
880     ret = window->MoveTo(20000, 20000);
881     usleep(100000);
882     EXPECT_EQ(WMError::WM_OK, ret);
883     rectNow = window->property_->GetWindowRect();
884     EXPECT_EQ(rectOld.posX_, rectNow.posX_);
885     EXPECT_EQ(rectOld.posY_, rectNow.posY_);
886 }
887 
888 /**
889  * @tc.name: resize01
890  * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2106
891  * @tc.type: FUNC
892  */
893 HWTEST_F(WindowLayoutTest, resize01, Function | MediumTest | Level3)
894 {
895     sptr<WindowOption> option = new (std::nothrow) WindowOption();
896     ASSERT_NE(option, nullptr);
897     option->SetWindowName("resize01");
898     option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
899     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
900 
901     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
902     ASSERT_NE(window, nullptr);
903 
904     Rect rect;
905     WMError ret;
906     ret = window->Create(abilityContext_, nullptr);
907     EXPECT_EQ(WMError::WM_OK, ret);
908     window->property_->SetPersistentId(10008);
909     ret = window->Show();
910     EXPECT_EQ(WMError::WM_OK, ret);
911 
912     WindowLimits windowLimits;
913     ret = window->GetWindowLimits(windowLimits);
914     EXPECT_EQ(WMError::WM_OK, ret);
915 
916     ret = window->Resize(-500, -500);
917     EXPECT_EQ(WMError::WM_OK, ret);
918     usleep(100000);
919     rect = window->property_->GetWindowRect();
920     EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
921     EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
922 
923     ret = window->Resize(500, 500);
924     EXPECT_EQ(WMError::WM_OK, ret);
925     usleep(100000);
926     rect = window->property_->GetWindowRect();
927     EXPECT_EQ(500, rect.width_);
928     EXPECT_EQ(500, rect.height_);
929 
930     ret = window->Resize(20000, 20000);
931     EXPECT_EQ(WMError::WM_OK, ret);
932     usleep(100000);
933     rect = window->property_->GetWindowRect();
934     EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
935     EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
936 
937     ret = window->Resize(0, 0);
938     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
939 }
940 
941 /**
942  * @tc.name: resize02
943  * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
944  * @tc.type: FUNC
945  */
946 HWTEST_F(WindowLayoutTest, resize02, Function | MediumTest | Level3)
947 {
948     sptr<WindowOption> option = new (std::nothrow) WindowOption();
949     ASSERT_NE(option, nullptr);
950     option->SetWindowName("resize02");
951     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
952     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
953 
954     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
955     ASSERT_NE(window, nullptr);
956 
957     SessionInfo sessionInfo = { "bundleName_resize02", "moduleName_resize02", "abilityName_resize02" };
958     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
959     ASSERT_NE(sceneSession, nullptr);
960 
961     WMError ret;
962     ret = window->Create(abilityContext_, sceneSession);
963     EXPECT_EQ(WMError::WM_OK, ret);
964     window->property_->SetPersistentId(10009);
965     ret = window->Show();
966     EXPECT_EQ(WMError::WM_OK, ret);
967 
968     ret = window->Resize(500, 500);
969     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
970 
971     ret = window->Resize(20000, 20000);
972     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
973 
974     ret = window->Resize(0, 0);
975     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
976 }
977 
978 /**
979  * @tc.name: resize03
980  * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
981  * @tc.type: FUNC
982  */
983 HWTEST_F(WindowLayoutTest, resize03, Function | MediumTest | Level3)
984 {
985     sptr<WindowOption> option = new (std::nothrow) WindowOption();
986     ASSERT_NE(option, nullptr);
987     option->SetWindowName("resize03");
988     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
989     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
990 
991     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
992     ASSERT_NE(window, nullptr);
993 
994     SessionInfo sessionInfo = { "bundleName_resize03", "moduleName_resize03", "abilityName_resize03" };
995     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
996     ASSERT_NE(sceneSession, nullptr);
997 
998     WMError ret;
999     ret = window->Create(abilityContext_, sceneSession);
1000     EXPECT_EQ(WMError::WM_OK, ret);
1001     window->property_->SetPersistentId(100010);
1002     ret = window->Show();
1003     EXPECT_EQ(WMError::WM_OK, ret);
1004 
1005     ret = window->Resize(500, 500);
1006     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1007 
1008     ret = window->Resize(20000, 20000);
1009     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1010 
1011     ret = window->Resize(0, 0);
1012     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
1013 }
1014 
1015 /**
1016  * @tc.name: resize04
1017  * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
1018  * @tc.type: FUNC
1019  */
1020 HWTEST_F(WindowLayoutTest, resize04, Function | MediumTest | Level3)
1021 {
1022     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1023     ASSERT_NE(option, nullptr);
1024     option->SetWindowName("resize04");
1025     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1026     option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1027 
1028     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
1029     ASSERT_NE(window, nullptr);
1030 
1031     SessionInfo sessionInfo = { "bundleName_resize04", "moduleName_resize04", "abilityName_resize04" };
1032     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
1033     ASSERT_NE(sceneSession, nullptr);
1034 
1035     WMError ret;
1036     ret = window->Create(abilityContext_, sceneSession);
1037     EXPECT_EQ(WMError::WM_OK, ret);
1038     window->property_->SetPersistentId(100011);
1039     ret = window->Show();
1040     EXPECT_EQ(WMError::WM_OK, ret);
1041 
1042     ret = window->Resize(500, 500);
1043     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1044 
1045     ret = window->Resize(20000, 20000);
1046     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1047 
1048     ret = window->Resize(0, 0);
1049     EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret); // check parameter first
1050 }
1051 
1052 /**
1053  * @tc.name: resize05
1054  * @tc.desc: test resize for ALN/PC with windowMode: 102, windowType: 2106
1055  * @tc.type: FUNC
1056  */
1057 HWTEST_F(WindowLayoutTest, resize05, Function | MediumTest | Level3)
1058 {
1059     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1060     ASSERT_NE(option, nullptr);
1061     option->SetWindowName("resize05");
1062     option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1063     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1064 
1065     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
1066     ASSERT_NE(window, nullptr);
1067 
1068     Rect rect;
1069     WMError ret;
1070     ret = window->Create(abilityContext_, nullptr);
1071     EXPECT_EQ(WMError::WM_OK, ret);
1072     window->property_->SetPersistentId(10012);
1073     ret = window->Show();
1074     EXPECT_EQ(WMError::WM_OK, ret);
1075 
1076     WindowLimits windowLimits;
1077     ret = window->GetWindowLimits(windowLimits);
1078 
1079     ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
1080     EXPECT_EQ(WMError::WM_OK, ret);
1081     usleep(100000);
1082     rect = window->property_->GetWindowRect();
1083     EXPECT_EQ(windowLimits.maxWidth_ - 100, rect.width_);
1084     EXPECT_EQ(windowLimits.maxHeight_ - 100, rect.height_);
1085 
1086     ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
1087     EXPECT_EQ(WMError::WM_OK, ret);
1088     usleep(100000);
1089     rect = window->property_->GetWindowRect();
1090     EXPECT_EQ(windowLimits.maxWidth_, rect.width_);
1091     EXPECT_EQ(windowLimits.maxHeight_, rect.height_);
1092 }
1093 
1094 /**
1095  * @tc.name: resize06
1096  * @tc.desc: test resize for ALN with windowMode: 1, windowType: 1
1097  * @tc.type: FUNC
1098  */
1099 HWTEST_F(WindowLayoutTest, resize06, Function | MediumTest | Level3)
1100 {
1101     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1102     ASSERT_NE(option, nullptr);
1103     option->SetWindowName("resize06");
1104     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1105     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1106 
1107     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
1108     ASSERT_NE(window, nullptr);
1109 
1110     SessionInfo sessionInfo = { "bundleName_resize06", "moduleName_resize06", "abilityName_resize06" };
1111     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
1112     ASSERT_NE(sceneSession, nullptr);
1113 
1114     WMError ret;
1115     ret = window->Create(abilityContext_, sceneSession);
1116     EXPECT_EQ(WMError::WM_OK, ret);
1117     window->property_->SetPersistentId(100013);
1118     ret = window->Show();
1119     EXPECT_EQ(WMError::WM_OK, ret);
1120 
1121     WindowLimits windowLimits;
1122     ret = window->GetWindowLimits(windowLimits);
1123 
1124     ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
1125     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1126 
1127     ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
1128     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1129 }
1130 
1131 /**
1132  * @tc.name: resize07
1133  * @tc.desc: test resize for PC with windowMode: 1, windowType: 1
1134  * @tc.type: FUNC
1135  */
1136 HWTEST_F(WindowLayoutTest, resize07, Function | MediumTest | Level3)
1137 {
1138     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1139     ASSERT_NE(option, nullptr);
1140     option->SetWindowName("resize07");
1141     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1142     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1143 
1144     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
1145     ASSERT_NE(window, nullptr);
1146 
1147     SessionInfo sessionInfo = { "bundleName_resize07", "moduleName_resize07", "abilityName_resize07" };
1148     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
1149     ASSERT_NE(sceneSession, nullptr);
1150 
1151     WMError ret;
1152     ret = window->Create(abilityContext_, sceneSession);
1153     EXPECT_EQ(WMError::WM_OK, ret);
1154     window->property_->SetPersistentId(100014);
1155     ret = window->Show();
1156     EXPECT_EQ(WMError::WM_OK, ret);
1157 
1158     WindowLimits windowLimits;
1159     ret = window->GetWindowLimits(windowLimits);
1160 
1161     ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
1162     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1163 
1164     ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
1165     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1166 }
1167 
1168 /**
1169  * @tc.name: resize08
1170  * @tc.desc: test resize for ALN/PC with windowMode: 100, windowType: 1
1171  * @tc.type: FUNC
1172  */
1173 HWTEST_F(WindowLayoutTest, resize08, Function | MediumTest | Level3)
1174 {
1175     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1176     ASSERT_NE(option, nullptr);
1177     option->SetWindowName("resize08");
1178     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1179     option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1180 
1181     sptr<WindowSceneSessionImpl> window = new WindowSceneSessionImpl(option);
1182     ASSERT_NE(window, nullptr);
1183 
1184     SessionInfo sessionInfo = { "bundleName_resize08", "moduleName_resize08", "abilityName_resize08" };
1185     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(sessionInfo, nullptr);
1186     ASSERT_NE(sceneSession, nullptr);
1187 
1188     WMError ret;
1189     ret = window->Create(abilityContext_, sceneSession);
1190     EXPECT_EQ(WMError::WM_OK, ret);
1191     window->property_->SetPersistentId(100015);
1192     ret = window->Show();
1193     EXPECT_EQ(WMError::WM_OK, ret);
1194 
1195     WindowLimits windowLimits;
1196     ret = window->GetWindowLimits(windowLimits);
1197 
1198     ret = window->Resize(windowLimits.maxWidth_ - 100, windowLimits.maxHeight_ - 100);
1199     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1200     ret = window->Resize(windowLimits.maxWidth_ + 100, windowLimits.maxHeight_ + 100);
1201     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1202 }
1203 }
1204 } // namespace Rosen
1205 } // namespace OHOS
1206