1 /*
2  * Copyright (c) 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 #include <gtest/gtest.h>
17 
18 #include "display_manager.h"
19 #include "display_manager_config.h"
20 #include "window_node_container.h"
21 #include "future.h"
22 #include "window_node.h"
23 #include "wm_common.h"
24 #include "window_transition_info.h"
25 #include "starting_window.h"
26 #include "minimize_app.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Rosen {
33 namespace {
34 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowNodeContainerTest"};
35 }
36 
37 class WindowNodeContainerTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     virtual void SetUp() override;
42     virtual void TearDown() override;
43     static sptr<Display> defaultDisplay_;
44     static sptr<WindowNodeContainer> container_;
45     static Rect windowRect_;
46 };
47 
48 sptr<Display> WindowNodeContainerTest::defaultDisplay_ = nullptr;
49 sptr<WindowNodeContainer> WindowNodeContainerTest::container_ = nullptr;
50 Rect WindowNodeContainerTest::windowRect_;
51 
SetUpTestCase()52 void WindowNodeContainerTest::SetUpTestCase()
53 {
54     defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
55     ASSERT_TRUE((defaultDisplay_ != nullptr));
56     WLOGI("GetDefaultDisplay: id %{public}" PRIu64", w %{public}d, h %{public}d, fps %{public}u",
57         defaultDisplay_->GetId(), defaultDisplay_->GetWidth(), defaultDisplay_->GetHeight(),
58         defaultDisplay_->GetRefreshRate());
59 
60     container_ = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(), defaultDisplay_->GetScreenId());
61     windowRect_ = {0, 0, 100, 200};
62 }
63 
TearDownTestCase()64 void WindowNodeContainerTest::TearDownTestCase()
65 {
66     container_ = nullptr;
67 }
68 
SetUp()69 void WindowNodeContainerTest::SetUp()
70 {
71 }
72 
TearDown()73 void WindowNodeContainerTest::TearDown()
74 {
75 }
76 
CreateWindowProperty(uint32_t windowId,const std::string & windowName,WindowType type,WindowMode mode,const Rect & screenRect)77 sptr<WindowProperty> CreateWindowProperty(uint32_t windowId, const std::string& windowName,
78     WindowType type, WindowMode mode, const Rect& screenRect)
79 {
80     sptr<WindowProperty> property = new WindowProperty();
81     property->SetWindowId(windowId);
82     property->SetWindowName(windowName);
83     property->SetWindowType(type);
84     property->SetWindowMode(mode);
85     property->SetWindowRect(screenRect);
86     return property;
87 }
88 
CreateSFNode(const std::string & nodeName)89 RSSurfaceNode::SharedPtr CreateSFNode(const std::string& nodeName)
90 {
91     struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
92     rsSurfaceNodeConfig.SurfaceNodeName = "name1";
93     RSSurfaceNodeType rsSurfaceNodeType = RSSurfaceNodeType::DEFAULT;
94 
95     return RSSurfaceNode::Create(rsSurfaceNodeConfig, rsSurfaceNodeType);
96 }
97 
98 namespace {
99 /**
100  * @tc.name: AddWindowNodeOnWindowTree01
101  * @tc.desc: add system sub window to system window
102  * @tc.type: FUNC
103  */
104 HWTEST_F(WindowNodeContainerTest, AddWindowNodeOnWindowTree01, Function | SmallTest | Level2)
105 {
106     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
107         WindowType::WINDOW_TYPE_APP_LAUNCHING, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
108     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
109     ASSERT_NE(nullptr, parentNode);
110     parentNode->SetWindowProperty(parentProperty);
111     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
112         WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
113     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
114     ASSERT_NE(nullptr, subNode);
115     subNode->SetWindowProperty(subProperty);
116     ASSERT_EQ(WMError::WM_OK, container_->AddWindowNodeOnWindowTree(subNode, parentNode));
117 }
118 
119 /**
120  * @tc.name: AddWindowNodeOnWindowTree02
121  * @tc.desc: add system sub window to system sub window
122  * @tc.type: FUNC
123  */
124 HWTEST_F(WindowNodeContainerTest, AddWindowNodeOnWindowTree02, Function | SmallTest | Level2)
125 {
126     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
127         WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
128     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
129     parentNode->SetWindowProperty(parentProperty);
130     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
131         WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
132     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
133     subNode->SetWindowProperty(subProperty);
134     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, container_->AddWindowNodeOnWindowTree(subNode, parentNode));
135 }
136 
137 /**
138  * @tc.name: AddWindowNodeOnWindowTree03
139  * @tc.desc: add system sub window without parent
140  * @tc.type: FUNC
141  */
142 HWTEST_F(WindowNodeContainerTest, AddWindowNodeOnWindowTree03, Function | SmallTest | Level2)
143 {
144     sptr<WindowProperty> subProperty = CreateWindowProperty(110u, "test1",
145         WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
146     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
147     subNode->SetWindowProperty(subProperty);
148     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container_->AddWindowNodeOnWindowTree(subNode, nullptr));
149 }
150 /**
151  * @tc.name: MinimizeAppNodeExceptOptions
152  * @tc.desc: minimize app node
153  * @tc.type: FUNC
154  */
155 HWTEST_F(WindowNodeContainerTest, MinimizeAppNodeExceptOptions, Function | SmallTest | Level2)
156 {
157     std::vector<uint32_t> exceptionalIds;
158     std::vector<WindowMode> exceptionalModes;
159     ASSERT_EQ(WMError::WM_OK, container_->MinimizeAppNodeExceptOptions(MinimizeReason::OTHER_WINDOW,
160         exceptionalIds, exceptionalModes));
161 
162     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
163         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
164     sptr<WindowNode> node1 = new WindowNode(property1, nullptr, nullptr);
165     node1->SetWindowProperty(property1);
166     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
167         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
168     sptr<WindowNode> node2 = new WindowNode(property2, nullptr, nullptr);
169     node2->SetWindowProperty(property2);
170     ASSERT_EQ(WMError::WM_OK, container_->AddWindowNodeOnWindowTree(node1, nullptr));
171     ASSERT_EQ(WMError::WM_OK, container_->AddWindowNodeOnWindowTree(node2, nullptr));
172     ASSERT_EQ(WMError::WM_OK, container_->MinimizeAppNodeExceptOptions(MinimizeReason::OTHER_WINDOW,
173         exceptionalIds, exceptionalModes));
174 }
175 /**
176  * @tc.name: DropShowWhenLockedWindowIfNeeded
177  * @tc.desc: drop show when locken window
178  * @tc.type: FUNC
179  */
180 HWTEST_F(WindowNodeContainerTest, DropShowWhenLockedWindowIfNeeded, Function | SmallTest | Level2)
181 {
182     sptr<WindowProperty> property = CreateWindowProperty(110u, "test1",
183         WindowType::WINDOW_TYPE_KEYGUARD, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
184     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
185     ASSERT_NE(nullptr, node);
186     node->SetWindowProperty(property);
187     container_->DropShowWhenLockedWindowIfNeeded(node);
188 }
189 /**
190  * @tc.name: GetModeChangeHotZones
191  * @tc.desc: get mode change hot zones
192  * @tc.type: FUNC
193  */
194 HWTEST_F(WindowNodeContainerTest, GetModeChangeHotZones, Function | SmallTest | Level2)
195 {
196     ModeChangeHotZonesConfig hotZonesConfig { true, 10, 20, 30 };
197     ModeChangeHotZones hotZones;
198     container_->GetModeChangeHotZones(0, hotZones, hotZonesConfig);
199     ASSERT_EQ(hotZones.fullscreen_.height_, 10);
200     ASSERT_EQ(hotZones.primary_.width_, 20);
201     ASSERT_EQ(hotZones.secondary_.width_, 30);
202 }
203 /**
204  * @tc.name: UpdateCameraFloatWindowStatus
205  * @tc.desc: update camera float window status
206  * @tc.type: FUNC
207  */
208 HWTEST_F(WindowNodeContainerTest, UpdateCameraFloatWindowStatus, Function | SmallTest | Level2)
209 {
210     sptr<WindowProperty> property = CreateWindowProperty(110u, "test1",
211         WindowType::WINDOW_TYPE_FLOAT_CAMERA, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
212     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
213     ASSERT_NE(nullptr, node);
214     node->SetWindowProperty(property);
215     container_->UpdateCameraFloatWindowStatus(node, true);
216 }
217 /**
218  * @tc.name: UpdateWindowNode
219  * @tc.desc: preprocess node and update RSTree
220  * @tc.type: FUNC
221  */
222 HWTEST_F(WindowNodeContainerTest, UpdateWindowNode, Function | SmallTest | Level2)
223 {
224     sptr<WindowProperty> property = CreateWindowProperty(110u, "test1",
225         WindowType::SYSTEM_WINDOW_BASE, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
226     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
227     node->SetWindowProperty(property);
228     ASSERT_EQ(WMError::WM_OK, container_->UpdateWindowNode(node, WindowUpdateReason::UPDATE_ALL));
229     ASSERT_EQ(WMError::WM_OK, container_->UpdateWindowNode(node, WindowUpdateReason::UPDATE_MODE));
230 }
231 
232 /**
233  * @tc.name: ShowStartingWindow
234  * @tc.desc: show starting window
235  * @tc.type: FUNC
236  */
237 HWTEST_F(WindowNodeContainerTest, ShowStartingWindow, Function | SmallTest | Level2)
238 {
239     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
240         defaultDisplay_->GetScreenId());
241     sptr<WindowTransitionInfo> transitionInfo = new WindowTransitionInfo();
242     sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo, 101); // 101 is windowId
243     node->SetWindowRect({0, 0, 100, 100});
244     node->currentVisibility_ = true;
245     ASSERT_EQ(WMError::WM_OK, container->ShowStartingWindow(node));
246     ASSERT_EQ(WMError::WM_OK, container->AddWindowNodeOnWindowTree(node, nullptr));
247     node->currentVisibility_ = false;
248     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, container->ShowStartingWindow(node));
249     WindowType invalidType = static_cast<WindowType>(0);
250     sptr<WindowProperty> invalidProperty = CreateWindowProperty(110u, "test1", invalidType,
251         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
252     sptr<WindowNode> invalidNode = new WindowNode(invalidProperty, nullptr, nullptr);
253     invalidNode->SetWindowProperty(invalidProperty);
254     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->AddWindowNodeOnWindowTree(invalidNode, nullptr));
255     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->ShowStartingWindow(invalidNode));
256 }
257 
258 /**
259  * @tc.name: IsForbidDockSliceMove
260  * @tc.desc: forbid dock slice move
261  * @tc.type: FUNC
262  */
263 HWTEST_F(WindowNodeContainerTest, IsForbidDockSliceMove, Function | SmallTest | Level2)
264 {
265     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
266         defaultDisplay_->GetScreenId());
267     ASSERT_NE(nullptr, container->displayGroupController_);
268     ASSERT_NE(nullptr, container->displayGroupController_->GetWindowPairByDisplayId(defaultDisplay_->GetId()));
269     ASSERT_TRUE(!container->IsForbidDockSliceMove(defaultDisplay_->GetId()));
270 }
271 
272 /**
273  * @tc.name: GetWindowCountByType01
274  * @tc.desc: get window count
275  * @tc.type: FUNC
276  */
277 HWTEST_F(WindowNodeContainerTest, GetWindowCountByType01, Function | SmallTest | Level2)
278 {
279     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
280         defaultDisplay_->GetScreenId());
281     ASSERT_EQ(0, container->GetWindowCountByType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE));
282     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1", WindowType::BELOW_APP_SYSTEM_WINDOW_BASE,
283         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
284     sptr<WindowNode> node1 = new WindowNode(property1, nullptr, nullptr);
285     node1->SetWindowProperty(property1);
286     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
287         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
288     sptr<WindowNode> node2 = new WindowNode(property2, nullptr, nullptr);
289     node2->SetWindowProperty(property2);
290     sptr<WindowProperty> property3 = CreateWindowProperty(112u, "test3", WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE,
291         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
292     sptr<WindowNode> node3 = new WindowNode(property3, nullptr, nullptr);
293     node3->SetWindowProperty(property3);
294     container->belowAppWindowNode_->children_.insert(container->belowAppWindowNode_->children_.end(), node1);
295     container->appWindowNode_->children_.insert(container->appWindowNode_->children_.end(), node2);
296     container->aboveAppWindowNode_->children_.insert(container->aboveAppWindowNode_->children_.end(), node3);
297     ASSERT_EQ(0, container->GetWindowCountByType(WindowType::WINDOW_TYPE_KEYGUARD));
298     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
299     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE));
300     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE));
301     node1->startingWindowShown_ = true;
302     node2->startingWindowShown_ = true;
303     node3->startingWindowShown_ = true;
304     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
305     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE));
306     ASSERT_EQ(1, container->GetWindowCountByType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE));
307 }
308 
309 /**
310  * @tc.name: IsTileRectSatisfiedWithSizeLimits
311  * @tc.desc: judge tile rect satisfied with size limits
312  * @tc.type: FUNC
313  */
314 HWTEST_F(WindowNodeContainerTest, IsTileRectSatisfiedWithSizeLimits, Function | SmallTest | Level2)
315 {
316     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
317         defaultDisplay_->GetScreenId());
318     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE,
319         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
320     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
321     node->SetWindowProperty(property);
322     node->SetDisplayId(defaultDisplay_->GetId());
323     ASSERT_EQ(defaultDisplay_->GetId(), node->GetDisplayId());
324     ASSERT_EQ(WMError::WM_OK, container->IsTileRectSatisfiedWithSizeLimits(node));
325     ASSERT_EQ(WMError::WM_OK, container->SwitchLayoutPolicy(WindowLayoutMode::TILE, node->GetDisplayId()));
326     ASSERT_EQ(WMError::WM_OK, container->IsTileRectSatisfiedWithSizeLimits(node));
327 }
328 
329 /**
330  * @tc.name: AddWindowNode01
331  * @tc.desc: add main window
332  * @tc.type: FUNC
333  */
334 HWTEST_F(WindowNodeContainerTest, AddWindowNode01, Function | SmallTest | Level2)
335 {
336     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
337         defaultDisplay_->GetScreenId());
338     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
339         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
340     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
341     node->SetWindowProperty(property);
342     node->GetWindowProperty()->SetPrivacyMode(true);
343     sptr<WindowNode> parentNode = nullptr;
344     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
345     node->startingWindowShown_ = true;
346     node->GetWindowProperty()->SetPrivacyMode(false);
347     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
348 }
349 
350 /**
351  * @tc.name: AddWindowNode02
352  * @tc.desc: add sub window
353  * @tc.type: FUNC
354  */
355 HWTEST_F(WindowNodeContainerTest, AddWindowNode02, Function | SmallTest | Level2)
356 {
357     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
358         defaultDisplay_->GetScreenId());
359     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
360         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
361     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
362     parentNode->SetWindowProperty(parentProperty);
363     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
364         WindowType::WINDOW_TYPE_APP_SUB_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
365     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
366     subNode->SetWindowProperty(subProperty);
367     sptr<WindowNode> rootNode = nullptr;
368     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(parentNode, rootNode));
369     ASSERT_EQ(WMError::WM_OK, container->AddWindowNodeOnWindowTree(subNode, parentNode));
370     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(subNode, parentNode));
371 }
372 
373 /**
374  * @tc.name: AddWindowNode03
375  * @tc.desc: add system window
376  * @tc.type: FUNC
377  */
378 HWTEST_F(WindowNodeContainerTest, AddWindowNode03, Function | SmallTest | Level2)
379 {
380     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
381         defaultDisplay_->GetScreenId());
382     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE,
383         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
384     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
385     node->SetWindowProperty(property);
386     sptr<WindowNode> parentNode = nullptr;
387     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
388 }
389 
390 /**
391  * @tc.name: RemoveWindowNodeFromWindowTree
392  * @tc.desc: remove sub window from window tree
393  * @tc.type: FUNC
394  */
395 HWTEST_F(WindowNodeContainerTest, RemoveWindowNodeFromWindowTree, Function | SmallTest | Level2)
396 {
397     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
398         defaultDisplay_->GetScreenId());
399     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
400         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
401     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
402     parentNode->SetWindowProperty(parentProperty);
403     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
404         WindowType::WINDOW_TYPE_APP_SUB_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
405     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
406     subNode->SetWindowProperty(subProperty);
407     sptr<WindowNode> rootNode = nullptr;
408     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(parentNode, rootNode));
409     ASSERT_EQ(WMError::WM_OK, container->AddWindowNodeOnWindowTree(subNode, parentNode));
410     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(subNode, parentNode));
411     ASSERT_EQ(1, parentNode->children_.size());
412     container->RemoveWindowNodeFromWindowTree(subNode);
413     ASSERT_EQ(0, parentNode->children_.size());
414 }
415 
416 /**
417  * @tc.name: RemoveWindowNode01
418  * @tc.desc: remove main window
419  * @tc.type: FUNC
420  */
421 HWTEST_F(WindowNodeContainerTest, RemoveWindowNode01, Function | SmallTest | Level2)
422 {
423     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
424         defaultDisplay_->GetScreenId());
425     sptr<WindowNode> node = nullptr;
426     ASSERT_EQ(WMError::WM_ERROR_DESTROYED_OBJECT, container->RemoveWindowNode(node));
427     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
428         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
429     node = new WindowNode(property, nullptr, nullptr);
430     node->SetWindowProperty(property);
431     sptr<WindowNode> parentNode = nullptr;
432     node->GetWindowProperty()->SetPrivacyMode(true);
433     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
434     node->GetWindowProperty()->SetPrivacyMode(false);
435     ASSERT_EQ(WMError::WM_OK, container->RemoveWindowNode(node));
436 }
437 
438 /**
439  * @tc.name: RemoveWindowNode02
440  * @tc.desc: remove sub window
441  * @tc.type: FUNC
442  */
443 HWTEST_F(WindowNodeContainerTest, RemoveWindowNode02, Function | SmallTest | Level2)
444 {
445     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
446         defaultDisplay_->GetScreenId());
447     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
448         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
449     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
450     parentNode->SetWindowProperty(parentProperty);
451     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
452         WindowType::WINDOW_TYPE_APP_SUB_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
453     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
454     subNode->SetWindowProperty(subProperty);
455 
456     sptr<WindowNode> rootNode = nullptr;
457     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(parentNode, rootNode));
458     ASSERT_EQ(WMError::WM_OK, container->AddWindowNodeOnWindowTree(subNode, parentNode));
459     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(subNode, parentNode));
460     ASSERT_EQ(WMError::WM_OK, container->RemoveWindowNode(subNode));
461 }
462 
463 /**
464  * @tc.name: RemoveWindowNode03
465  * @tc.desc: remove keyguard window
466  * @tc.type: FUNC
467  */
468 HWTEST_F(WindowNodeContainerTest, RemoveWindowNode03, Function | SmallTest | Level2)
469 {
470     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
471         defaultDisplay_->GetScreenId());
472     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
473         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
474     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
475     node->SetWindowProperty(property);
476     sptr<WindowNode> parentNode = nullptr;
477     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
478     ASSERT_EQ(WMError::WM_OK, container->RemoveWindowNode(node));
479 }
480 
481 /**
482  * @tc.name: RemoveWindowNode04
483  * @tc.desc: remove boot animation window
484  * @tc.type: FUNC
485  */
486 HWTEST_F(WindowNodeContainerTest, RemoveWindowNode04, Function | SmallTest | Level2)
487 {
488     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
489         defaultDisplay_->GetScreenId());
490     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
491         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
492     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
493     node->SetWindowProperty(property);
494     sptr<WindowNode> parentNode = nullptr;
495     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
496     ASSERT_EQ(WMError::WM_OK, container->RemoveWindowNode(node));
497 }
498 
499 /**
500  * @tc.name: HandleRemoveWindow01
501  * @tc.desc: remove status bar
502  * @tc.type: FUNC
503  */
504 HWTEST_F(WindowNodeContainerTest, HandleRemoveWindow01, Function | SmallTest | Level2)
505 {
506     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
507         defaultDisplay_->GetScreenId());
508     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_STATUS_BAR,
509         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
510     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
511     node->SetWindowProperty(property);
512     sptr<WindowNode> parentNode = nullptr;
513     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
514     ASSERT_EQ(WMError::WM_OK, container->HandleRemoveWindow(node));
515 }
516 
517 /**
518  * @tc.name: HandleRemoveWindow02
519  * @tc.desc: remove navigation bar
520  * @tc.type: FUNC
521  */
522 HWTEST_F(WindowNodeContainerTest, HandleRemoveWindow02, Function | SmallTest | Level2)
523 {
524     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
525         defaultDisplay_->GetScreenId());
526     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_NAVIGATION_BAR,
527         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
528     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
529     node->SetWindowProperty(property);
530     sptr<WindowNode> parentNode = nullptr;
531     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
532     ASSERT_EQ(WMError::WM_OK, container->HandleRemoveWindow(node));
533 }
534 
535 /**
536  * @tc.name: FindDividerNode
537  * @tc.desc: find divider node
538  * @tc.type: FUNC
539  */
540 HWTEST_F(WindowNodeContainerTest, FindDividerNode, Function | SmallTest | Level2)
541 {
542     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
543         defaultDisplay_->GetScreenId());
544     ASSERT_EQ(nullptr, container->FindDividerNode());
545     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
546         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
547     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
548     node->SetWindowProperty(property);
549     sptr<WindowNode> parentNode = nullptr;
550     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
551     ASSERT_EQ(1, container->appWindowNode_->children_.size());
552     ASSERT_EQ(nullptr, container->FindDividerNode());
553     sptr<WindowProperty> dividerProperty = CreateWindowProperty(112u, "test2", WindowType::WINDOW_TYPE_DOCK_SLICE,
554         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
555     sptr<WindowNode> dividerNode = new WindowNode(dividerProperty, nullptr, nullptr);
556     dividerNode->SetWindowProperty(dividerProperty);
557     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(dividerNode, parentNode));
558     ASSERT_EQ(2, container->appWindowNode_->children_.size());
559     ASSERT_EQ(dividerNode, container->FindDividerNode());
560 }
561 
562 /**
563  * @tc.name: RaiseZOrderForAppWindow01
564  * @tc.desc: raise main window z order
565  * @tc.type: FUNC
566  */
567 HWTEST_F(WindowNodeContainerTest, RaiseZOrderForAppWindow01, Function | SmallTest | Level2)
568 {
569     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
570         defaultDisplay_->GetScreenId());
571     sptr<WindowProperty> property1 = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
572         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
573     sptr<WindowNode> node1 = nullptr;
574     sptr<WindowNode> parentNode = nullptr;
575     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->RaiseZOrderForAppWindow(node1, parentNode));
576     node1 = new WindowNode(property1, nullptr, nullptr);
577     node1->SetWindowProperty(property1);
578     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node1, parentNode));
579     sptr<WindowProperty> property2 = CreateWindowProperty(112u, "test2", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
580         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
581     sptr<WindowNode> node2 = new WindowNode(property2, nullptr, nullptr);
582     node2->SetWindowProperty(property2);
583     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node2, parentNode));
584     ASSERT_EQ(WMError::WM_OK, container->RaiseZOrderForAppWindow(node1, parentNode));
585 }
586 
587 /**
588  * @tc.name: RaiseZOrderForAppWindow02
589  * @tc.desc: raise sub window z order
590  * @tc.type: FUNC
591  */
592 HWTEST_F(WindowNodeContainerTest, RaiseZOrderForAppWindow02, Function | SmallTest | Level2)
593 {
594     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
595         defaultDisplay_->GetScreenId());
596     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
597         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
598     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
599     parentNode->SetWindowProperty(parentProperty);
600     sptr<WindowProperty> subProperty = CreateWindowProperty(111u, "test2",
601         WindowType::WINDOW_TYPE_APP_SUB_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
602     sptr<WindowNode> subNode = new WindowNode(subProperty, nullptr, nullptr);
603     subNode->SetWindowProperty(subProperty);
604     sptr<WindowNode> rootNode = nullptr;
605     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->RaiseZOrderForAppWindow(subNode, rootNode));
606     ASSERT_EQ(WMError::WM_OK, container->RaiseZOrderForAppWindow(subNode, parentNode));
607 }
608 
609 /**
610  * @tc.name: RaiseZOrderForAppWindow03
611  * @tc.desc: raise dialog z order
612  * @tc.type: FUNC
613  */
614 HWTEST_F(WindowNodeContainerTest, RaiseZOrderForAppWindow03, Function | SmallTest | Level2)
615 {
616     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
617         defaultDisplay_->GetScreenId());
618     sptr<WindowProperty> parentProperty = CreateWindowProperty(110u, "test1",
619         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
620     sptr<WindowNode> parentNode = new WindowNode(parentProperty, nullptr, nullptr);
621     parentNode->SetWindowProperty(parentProperty);
622     sptr<WindowProperty> dialogProperty = CreateWindowProperty(111u, "test2",
623         WindowType::WINDOW_TYPE_DIALOG, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
624     sptr<WindowNode> dialog = new WindowNode(dialogProperty, nullptr, nullptr);
625     dialog->SetWindowProperty(dialogProperty);
626     sptr<WindowNode> rootNode = nullptr;
627     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->RaiseZOrderForAppWindow(dialog, rootNode));
628     ASSERT_EQ(WMError::WM_OK, container->RaiseZOrderForAppWindow(dialog, parentNode));
629 }
630 
631 /**
632  * @tc.name: IsDockSliceInExitSplitModeArea
633  * @tc.desc: if dock slice in exit split mode area
634  * @tc.type: FUNC
635  */
636 HWTEST_F(WindowNodeContainerTest, IsDockSliceInExitSplitModeArea, Function | SmallTest | Level2)
637 {
638     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
639         defaultDisplay_->GetScreenId());
640     ASSERT_NE(nullptr, container->displayGroupController_);
641     ASSERT_NE(nullptr, container->displayGroupController_->GetWindowPairByDisplayId(defaultDisplay_->GetId()));
642     ASSERT_TRUE(!container->IsDockSliceInExitSplitModeArea(defaultDisplay_->GetId()));
643 }
644 
645 /**
646  * @tc.name: ExitSplitMode
647  * @tc.desc: exit split mode
648  * @tc.type: FUNC
649  */
650 HWTEST_F(WindowNodeContainerTest, ExitSplitMode, Function | SmallTest | Level2)
651 {
652     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
653         defaultDisplay_->GetScreenId());
654     ASSERT_NE(nullptr, container->displayGroupController_);
655     ASSERT_NE(nullptr, container->displayGroupController_->GetWindowPairByDisplayId(defaultDisplay_->GetId()));
656     container->ExitSplitMode(defaultDisplay_->GetId());
657 }
658 
659 /**
660  * @tc.name: MinimizeOldestAppWindow01
661  * @tc.desc: minimize main window
662  * @tc.type: FUNC
663  */
664 HWTEST_F(WindowNodeContainerTest, MinimizeOldestAppWindow01, Function | SmallTest | Level2)
665 {
666     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
667         defaultDisplay_->GetScreenId());
668     container->MinimizeOldestAppWindow();
669     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
670         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
671     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
672     node->SetWindowProperty(property);
673     sptr<WindowNode> parentNode = nullptr;
674     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
675     ASSERT_EQ(1, container->appWindowNode_->children_.size());
676     container->MinimizeOldestAppWindow();
677     ASSERT_EQ(1, MinimizeApp::needMinimizeAppNodes_.size());
678     MinimizeApp::needMinimizeAppNodes_.clear();
679 }
680 
681 /**
682  * @tc.name: MinimizeOldestAppWindow02
683  * @tc.desc: minimize above main window
684  * @tc.type: FUNC
685  */
686 HWTEST_F(WindowNodeContainerTest, MinimizeOldestAppWindow02, Function | SmallTest | Level2)
687 {
688     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
689         defaultDisplay_->GetScreenId());
690     sptr<WindowProperty> property = CreateWindowProperty(111u, "test2",
691         WindowType::WINDOW_TYPE_STATUS_BAR, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
692     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
693     node->SetWindowProperty(property);
694     sptr<WindowNode> parentNode = nullptr;
695     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
696     ASSERT_EQ(1, container->aboveAppWindowNode_->children_.size());
697     size_t size = MinimizeApp::needMinimizeAppNodes_.size();
698     container->MinimizeOldestAppWindow();
699     ASSERT_EQ(size, MinimizeApp::needMinimizeAppNodes_.size());
700     MinimizeApp::needMinimizeAppNodes_.clear();
701 }
702 
703 /**
704  * @tc.name: ToggleShownStateForAllAppWindows01
705  * @tc.desc: toggle shown state for status bar
706  * @tc.type: FUNC
707  */
708 HWTEST_F(WindowNodeContainerTest, ToggleShownStateForAllAppWindows01, Function | SmallTest | Level2)
709 {
710     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
711         defaultDisplay_->GetScreenId());
712     sptr<WindowProperty> property = CreateWindowProperty(111u, "test2",
713         WindowType::WINDOW_TYPE_STATUS_BAR, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
714     sptr<WindowNode> statusBar = new WindowNode(property, nullptr, nullptr);
715     statusBar->SetWindowProperty(property);
716     sptr<WindowNode> parentNode = nullptr;
717     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(statusBar, parentNode));
718     ASSERT_EQ(1, container->aboveAppWindowNode_->children_.size());
__anona37d80c60302(uint32_t windowId, WindowMode mode) 719     auto restoreFunc = [](uint32_t windowId, WindowMode mode) {
720         return false;
721     };
722     ASSERT_EQ(WMError::WM_OK, container->ToggleShownStateForAllAppWindows(restoreFunc, true));
723 }
724 
725 /**
726  * @tc.name: ToggleShownStateForAllAppWindows02
727  * @tc.desc: toggle shown state for launcher recent
728  * @tc.type: FUNC
729  */
730 HWTEST_F(WindowNodeContainerTest, ToggleShownStateForAllAppWindows02, Function | SmallTest | Level2)
731 {
732     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
733         defaultDisplay_->GetScreenId());
734     sptr<WindowProperty> property = CreateWindowProperty(111u, "test2",
735         WindowType::WINDOW_TYPE_LAUNCHER_RECENT, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
736     sptr<WindowNode> statusBar = new WindowNode(property, nullptr, nullptr);
737     statusBar->SetWindowProperty(property);
738     sptr<WindowNode> parentNode = nullptr;
739     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(statusBar, parentNode));
740     ASSERT_EQ(1, container->aboveAppWindowNode_->children_.size());
__anona37d80c60402(uint32_t windowId, WindowMode mode) 741     auto restoreFunc = [](uint32_t windowId, WindowMode mode) {
742         return false;
743     };
744     ASSERT_EQ(WMError::WM_DO_NOTHING, container->ToggleShownStateForAllAppWindows(restoreFunc, true));
745 }
746 
747 /**
748  * @tc.name: SetWindowMode01
749  * @tc.desc: set main window mode
750  * @tc.type: FUNC
751  */
752 HWTEST_F(WindowNodeContainerTest, SetWindowMode01, Function | SmallTest | Level2)
753 {
754     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
755         defaultDisplay_->GetScreenId());
756     sptr<WindowNode> node = nullptr;
757     WindowMode dstMode = WindowMode::WINDOW_MODE_FLOATING;
758     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, container->SetWindowMode(node, dstMode));
759     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
760         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
761     node = new WindowNode(property, nullptr, nullptr);
762     node->SetWindowProperty(property);
763     sptr<WindowNode> parentNode = nullptr;
764     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
765     ASSERT_EQ(1, container->appWindowNode_->children_.size());
766     dstMode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY;
767     container->isScreenLocked_ = false;
768     ASSERT_EQ(WMError::WM_OK, container->SetWindowMode(node, dstMode));
769 }
770 
771 /**
772  * @tc.name: SetWindowMode02
773  * @tc.desc: set main window mode with show when locked
774  * @tc.type: FUNC
775  */
776 HWTEST_F(WindowNodeContainerTest, SetWindowMode02, Function | SmallTest | Level2)
777 {
778     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
779         defaultDisplay_->GetScreenId());
780     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
781         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
782     property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
783     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
784     node->SetWindowProperty(property);
785     sptr<WindowNode> parentNode = nullptr;
786     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
787     ASSERT_EQ(1, container->appWindowNode_->children_.size());
788     WindowMode dstMode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY;
789     container->isScreenLocked_ = true;
790     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, container->SetWindowMode(node, dstMode));
791 }
792 
793 /**
794  * @tc.name: RemoveSingleUserWindowNodes
795  * @tc.desc: remove single user window node
796  * @tc.type: FUNC
797  */
798 HWTEST_F(WindowNodeContainerTest, RemoveSingleUserWindowNodes, Function | SmallTest | Level2)
799 {
800     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
801         defaultDisplay_->GetScreenId());
802     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
803         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
804     property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
805     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
806     node->SetWindowProperty(property);
807     sptr<WindowNode> parentNode = nullptr;
808     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
809     ASSERT_EQ(1, container->appWindowNode_->children_.size());
810     int accountId = 0;
811     container->RemoveSingleUserWindowNodes(accountId);
812 }
813 
814 /**
815  * @tc.name: TakeWindowPairSnapshot
816  * @tc.desc: take window pair snapshot
817  * @tc.type: FUNC
818  */
819 HWTEST_F(WindowNodeContainerTest, TakeWindowPairSnapshot, Function | SmallTest | Level2)
820 {
821     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
822         defaultDisplay_->GetScreenId());
823     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
824         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
825     property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
826     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
827     node->SetWindowProperty(property);
828     sptr<WindowNode> parentNode = nullptr;
829     ASSERT_EQ(WMError::WM_OK, container->AddWindowNode(node, parentNode));
830     ASSERT_EQ(1, container->appWindowNode_->children_.size());
831     ASSERT_NE(nullptr, container->displayGroupController_);
832     ASSERT_NE(nullptr, container->displayGroupController_->GetWindowPairByDisplayId(defaultDisplay_->GetId()));
833     ASSERT_TRUE(!container->TakeWindowPairSnapshot(defaultDisplay_->GetId()));
834     container->ClearWindowPairSnapshot(defaultDisplay_->GetId());
835 }
836 /**
837  * @tc.name: Destroy
838  * @tc.desc: clear vector cache completely, swap with empty vector
839  * @tc.type: FUNC
840  */
841 HWTEST_F(WindowNodeContainerTest, Destroy, Function | SmallTest | Level2)
842 {
843     ASSERT_EQ(0, container_->Destroy().size());
844 }
845 /**
846  * @tc.name: UpdatePrivateStateAndNotify
847  * @tc.desc: update private window count
848  * @tc.type: FUNC
849  */
850 HWTEST_F(WindowNodeContainerTest, UpdatePrivateStateAndNotify, Function | SmallTest | Level2)
851 {
852     container_->belowAppWindowNode_->children_.clear();
853     container_->appWindowNode_->children_.clear();
854     container_->aboveAppWindowNode_->children_.clear();
855     container_->privateWindowCount_ = 0;
856     // private window count : from 0 to 1
857     sptr<WindowProperty> property = CreateWindowProperty(111u, "test1", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
858         WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
859     sptr<WindowNode> node = new WindowNode(property, nullptr, nullptr);
860     node->SetWindowProperty(property);
861     node->GetWindowProperty()->SetPrivacyMode(true);
862     container_->appWindowNode_->children_.emplace_back(node);
863     container_->UpdatePrivateStateAndNotify();
864     ASSERT_EQ(1, container_->privateWindowCount_);
865     // private window count : from 1 to 0
866     container_->appWindowNode_->children_.clear();
867     container_->UpdatePrivateStateAndNotify();
868     ASSERT_EQ(0, container_->privateWindowCount_);
869 }
870 /**
871  * @tc.name: MinimizeOldestMainFloatingWindow
872  * @tc.desc: check function MinimizeOldestMainFloatingWindow
873  * @tc.type: FUNC
874  */
875 HWTEST_F(WindowNodeContainerTest, MinimizeOldestMainFloatingWindow, Function | SmallTest | Level2)
876 {
877     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
878         defaultDisplay_->GetScreenId());
879 
880     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
881         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
882     sptr<WindowNode> window1 = new WindowNode(property1, nullptr, nullptr);
883     window1->SetWindowProperty(property1);
884     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
885         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
886     sptr<WindowNode> window2 = new WindowNode(property2, nullptr, nullptr);
887     window2->SetWindowProperty(property2);
888 
889     container->appWindowNode_->children_.push_back(window1);
890     container->appWindowNode_->children_.push_back(window2);
891 
892     window1->parent_ = container->appWindowNode_;
893     window2->parent_ = container->appWindowNode_;
894 
895     auto oldInfo = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::MAX_APP_COUNT];
896     MinimizeApp::ClearNodesWithReason(MinimizeReason::MAX_APP_COUNT);
897 
898     container->maxMainFloatingWindowNumber_ = -1;
899     container->MinimizeOldestMainFloatingWindow(110u);
900     auto needMinimizeNum = MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MAX_APP_COUNT);
901     ASSERT_EQ(needMinimizeNum.size(), 0);
902     MinimizeApp::ClearNodesWithReason(MinimizeReason::MAX_APP_COUNT);
903 
904     container->maxMainFloatingWindowNumber_ = 3;
905     container->MinimizeOldestMainFloatingWindow(110u);
906     needMinimizeNum = MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MAX_APP_COUNT);
907     ASSERT_EQ(needMinimizeNum.size(), 0);
908     MinimizeApp::ClearNodesWithReason(MinimizeReason::MAX_APP_COUNT);
909 
910     container->maxMainFloatingWindowNumber_ = 1;
911     container->MinimizeOldestMainFloatingWindow(110u);
912     needMinimizeNum = MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MAX_APP_COUNT);
913     ASSERT_EQ(needMinimizeNum.size(), 1);
914     MinimizeApp::ClearNodesWithReason(MinimizeReason::MAX_APP_COUNT);
915 
916     sptr<WindowProperty> property3 = CreateWindowProperty(112u, "test3",
917         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
918     sptr<WindowNode> window3 = new WindowNode(property3, nullptr, nullptr);
919     window3->SetWindowProperty(property3);
920     container->appWindowNode_->children_.push_back(window3);
921     window3->parent_ = container->appWindowNode_;
922 
923     container->maxMainFloatingWindowNumber_ = 1;
924     container->MinimizeOldestMainFloatingWindow(110u);
925     needMinimizeNum = MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MAX_APP_COUNT);
926     ASSERT_EQ(needMinimizeNum.size(), 1);
927     MinimizeApp::ClearNodesWithReason(MinimizeReason::MAX_APP_COUNT);
928 
929     auto headItor = MinimizeApp::needMinimizeAppNodes_[MinimizeReason::MAX_APP_COUNT].end();
930     MinimizeApp::needMinimizeAppNodes_[MinimizeReason::MAX_APP_COUNT].insert(headItor, oldInfo.begin(), oldInfo.end());
931 }
932 
933 /**
934  * @tc.name: GetMainFloatingWindowCount
935  * @tc.desc: check GetMainFloatingWindowCount
936  * @tc.type: FUNC
937  */
938 HWTEST_F(WindowNodeContainerTest, GetMainFloatingWindowCount, Function | SmallTest | Level2)
939 {
940     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
941         defaultDisplay_->GetScreenId());
942 
943     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
944         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
945     sptr<WindowNode> window1 = new WindowNode(property1, nullptr, nullptr);
946     window1->SetWindowProperty(property1);
947 
948     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
949         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
950     sptr<WindowNode> window2 = new WindowNode(property2, nullptr, nullptr);
951     window2->SetWindowProperty(property2);
952     window2->startingWindowShown_ = true;
953 
954     sptr<WindowProperty> property3 = CreateWindowProperty(112u, "test3",
955         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
956     sptr<WindowNode> window3 = new WindowNode(property3, nullptr, nullptr);
957     window3->SetWindowProperty(property3);
958 
959     sptr<WindowProperty> property4 = CreateWindowProperty(112u, "test3",
960         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
961     sptr<WindowNode> window4 = new WindowNode(property4, nullptr, nullptr);
962     window4->SetWindowProperty(property4);
963 
964     container->appWindowNode_->children_.push_back(window1);
965     container->aboveAppWindowNode_->children_.push_back(window2);
966     container->appWindowNode_->children_.push_back(window3);
967     container->aboveAppWindowNode_->children_.push_back(window4);
968 
969     auto result = container->GetMainFloatingWindowCount();
970     ASSERT_EQ(result, 3);
971 }
972 
973 /**
974  * @tc.name: ResetWindowZOrderPriorityWhenSetMode
975  * @tc.desc: check function ResetWindowZOrderPriorityWhenSetMode
976  * @tc.type: FUNC
977  */
978 HWTEST_F(WindowNodeContainerTest, ResetWindowZOrderPriorityWhenSetMode, Function | SmallTest | Level2)
979 {
980     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
981         defaultDisplay_->GetScreenId());
982 
983     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
984         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
985     sptr<WindowNode> window1 = new WindowNode(property1, nullptr, nullptr);
986     window1->SetWindowProperty(property1);
987     window1->parent_ = container->appWindowNode_;
988 
989     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
990         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
991     sptr<WindowNode> window2 = new WindowNode(property2, nullptr, nullptr);
992     window2->SetWindowProperty(property2);
993     window2->parent_ = container->appWindowNode_;
994 
995     container->appWindowNode_->children_.push_back(window1);
996     container->appWindowNode_->children_.push_back(window2);
997 
998     container->isFloatWindowAboveFullWindow_ = false;
999     container->ResetWindowZOrderPriorityWhenSetMode(window1, WindowMode::WINDOW_MODE_FLOATING,
1000         WindowMode::WINDOW_MODE_FULLSCREEN);
1001     ASSERT_EQ(window1->priority_, 0);
1002 
1003     container->isFloatWindowAboveFullWindow_ = true;
1004     std::map<std::pair<WindowMode, WindowMode>, uint32_t> pairMode = {
1005         {{WindowMode::WINDOW_MODE_FLOATING, WindowMode::WINDOW_MODE_FULLSCREEN}, 2},
1006         {{WindowMode::WINDOW_MODE_FULLSCREEN, WindowMode::WINDOW_MODE_FLOATING}, 2},
1007         {{WindowMode::WINDOW_MODE_UNDEFINED, WindowMode::WINDOW_MODE_FULLSCREEN}, 0},
1008         {{WindowMode::WINDOW_MODE_FULLSCREEN, WindowMode::WINDOW_MODE_SPLIT_PRIMARY}, 2},
1009         {{WindowMode::WINDOW_MODE_SPLIT_PRIMARY, WindowMode::WINDOW_MODE_SPLIT_SECONDARY}, 2},
1010         {{WindowMode::WINDOW_MODE_SPLIT_SECONDARY, WindowMode::WINDOW_MODE_SPLIT_PRIMARY}, 2},
1011     };
1012     container->focusedWindow_ = 111u;
1013     for (auto itor = pairMode.begin(); itor != pairMode.end(); itor++) {
1014         auto pair = itor->first;
1015         container->ResetWindowZOrderPriorityWhenSetMode(window1, pair.first, pair.second);
1016         window1->priority_ = 0;
1017     }
1018 
1019     window1->zOrder_ = 0;
1020     window1->surfaceNode_ = CreateSFNode("sfNode1");
1021     window2->surfaceNode_ = CreateSFNode("sfNode2");
1022     container->focusedWindow_ = window1->GetWindowId();
1023     container->ResetWindowZOrderPriorityWhenSetMode(window1, WindowMode::WINDOW_MODE_FLOATING,
1024         WindowMode::WINDOW_MODE_FULLSCREEN);
1025     ASSERT_EQ(window1->zOrder_, 0);
1026 }
1027 
1028 /**
1029  * @tc.name: ResetMainFloatingWindowPriorityIfNeeded
1030  * @tc.desc: check function ResetMainFloatingWindowPriorityIfNeeded
1031  * @tc.type: FUNC
1032  */
1033 HWTEST_F(WindowNodeContainerTest, ResetMainFloatingWindowPriorityIfNeeded, Function | SmallTest | Level2)
1034 {
1035     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
1036         defaultDisplay_->GetScreenId());
1037 
1038     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
1039         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
1040     sptr<WindowNode> window1 = new WindowNode(property1, nullptr, nullptr);
1041     window1->SetWindowProperty(property1);
1042     window1->parent_ = container->appWindowNode_;
1043 
1044     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
1045         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
1046     sptr<WindowNode> window2 = new WindowNode(property2, nullptr, nullptr);
1047     window2->SetWindowProperty(property2);
1048     window2->parent_ = container->appWindowNode_;
1049 
1050     container->appWindowNode_->children_.push_back(window1);
1051     container->appWindowNode_->children_.push_back(window2);
1052 
1053     container->isFloatWindowAboveFullWindow_ = false;
1054     auto zorderPolicy = container->zorderPolicy_;
1055     const auto baseZOrderPolicy = zorderPolicy->GetWindowPriority(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1056     container->ResetMainFloatingWindowPriorityIfNeeded(window1);
1057     ASSERT_EQ(window1->priority_, 0);
1058 
1059     container->isFloatWindowAboveFullWindow_ = true;
1060     container->ResetMainFloatingWindowPriorityIfNeeded(window1);
1061     ASSERT_EQ(window1->priority_, 0);
1062 
1063     container->ResetMainFloatingWindowPriorityIfNeeded(window2);
1064     ASSERT_EQ(window2->priority_, 0);
1065 
1066     auto displayGroupControl = container->displayGroupController_;
1067     auto defaultDisplayId = defaultDisplay_->GetId();
1068     sptr<WindowPair> windowPair = displayGroupControl->GetWindowPairByDisplayId(defaultDisplayId);
1069     windowPair->status_ = WindowPairStatus::SINGLE_PRIMARY;
1070     window1->SetDisplayId(defaultDisplayId);
1071     container->ResetMainFloatingWindowPriorityIfNeeded(window1);
1072     ASSERT_EQ(window1->priority_, baseZOrderPolicy - 1);
1073 }
1074 
1075 /**
1076  * @tc.name: Destroy
1077  * @tc.desc: check function ResetAllMainFloatingWindowZOrder
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(WindowNodeContainerTest, ResetAllMainFloatingWindowZOrder, Function | SmallTest | Level2)
1081 {
1082     sptr<WindowNodeContainer> container = new WindowNodeContainer(defaultDisplay_->GetDisplayInfo(),
1083         defaultDisplay_->GetScreenId());
1084 
1085     sptr<WindowProperty> property1 = CreateWindowProperty(110u, "test1",
1086         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FLOATING, windowRect_);
1087     sptr<WindowNode> window1 = new WindowNode(property1, nullptr, nullptr);
1088     window1->SetWindowProperty(property1);
1089     window1->parent_ = container->appWindowNode_;
1090 
1091     sptr<WindowProperty> property2 = CreateWindowProperty(111u, "test2",
1092         WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, WindowMode::WINDOW_MODE_FULLSCREEN, windowRect_);
1093     sptr<WindowNode> window2 = new WindowNode(property2, nullptr, nullptr);
1094     window2->SetWindowProperty(property2);
1095     window2->parent_ = container->appWindowNode_;
1096 
1097     container->appWindowNode_->children_.push_back(window1);
1098     container->appWindowNode_->children_.push_back(window2);
1099 
1100     container->isFloatWindowAboveFullWindow_ = false;
1101     container->ResetAllMainFloatingWindowZOrder(container->appWindowNode_);
1102     ASSERT_EQ(window1->priority_, 0);
1103 
1104     container->isFloatWindowAboveFullWindow_ = true;
1105     container->ResetAllMainFloatingWindowZOrder(container->appWindowNode_);
1106     ASSERT_EQ(window1->priority_, 0);
1107 }
1108 }
1109 }
1110 }