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 <iremote_object.h>
17 #include <gtest/gtest.h>
18 #include "iremote_object_mocker.h"
19 #include "window_root.h"
20 #include "window_manager.h"
21 #include "window_manager_service.h"
22 #include "display_manager.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace Rosen {
28
29 class WindowRootTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 static sptr<WindowRoot> windowRoot_;
36 };
37
38 sptr<WindowRoot> WindowRootTest::windowRoot_ = nullptr;
39
SetUpTestCase()40 void WindowRootTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void WindowRootTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void WindowRootTest::SetUp()
49 {
50 windowRoot_ = new WindowRoot(nullptr);
51 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
52 ASSERT_TRUE((display != nullptr));
53 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
54 ASSERT_TRUE((displayInfo != nullptr));
55 }
56
TearDown()57 void WindowRootTest::TearDown()
58 {
59 windowRoot_ = nullptr;
60 }
61
62 namespace {
63 /**
64 * @tc.name: WindowRootTest01
65 * @tc.desc: test WindowRoot GetTotalWindowNum
66 * @tc.type: FUNC
67 */
68 HWTEST_F(WindowRootTest, WindowRootTest01, Function | SmallTest | Level2)
69 {
70 uint32_t size = windowRoot_->GetTotalWindowNum();
71 ASSERT_EQ(size, 0);
72 }
73
74 /**
75 * @tc.name: WindowRootTest02
76 * @tc.desc: test WindowRoot GetWindowForDumpAceHelpInfo
77 * @tc.type: FUNC
78 */
79 HWTEST_F(WindowRootTest, WindowRootTest02, Function | SmallTest | Level2)
80 {
81 windowRoot_->GetWindowForDumpAceHelpInfo();
82 sptr<WindowProperty> property = new WindowProperty();
83 property->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
84 sptr<WindowNode> windowNode;
85 windowRoot_->DestroyWindowInner(windowNode);
86 windowNode = new WindowNode(property);
87 windowRoot_->SaveWindow(windowNode);
88 sptr<WindowNode> node = windowRoot_->GetWindowForDumpAceHelpInfo();
89 ASSERT_NE(node, nullptr);
90 windowRoot_->DestroyWindowInner(windowNode);
91
92 property = new WindowProperty();
93 property->SetWindowType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
94 windowNode = new WindowNode(property);
95 windowRoot_->SaveWindow(windowNode);
96 node = windowRoot_->GetWindowForDumpAceHelpInfo();
97 ASSERT_NE(node, nullptr);
98 windowRoot_->DestroyWindowInner(windowNode);
99
100 property = new WindowProperty();
101 property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
102 windowNode = new WindowNode(property);
103 windowRoot_->SaveWindow(windowNode);
104 node = windowRoot_->GetWindowForDumpAceHelpInfo();
105 ASSERT_NE(node, nullptr);
106 windowRoot_->DestroyWindowInner(windowNode);
107
108 property = new WindowProperty();
109 property->SetWindowType(WindowType::WINDOW_TYPE_KEYGUARD);
110 windowNode = new WindowNode(property);
111 windowRoot_->SaveWindow(windowNode);
112 node = windowRoot_->GetWindowForDumpAceHelpInfo();
113 ASSERT_NE(node, nullptr);
114 windowRoot_->DestroyWindowInner(windowNode);
115 windowNode->SetVisibilityState(WINDOW_VISIBILITY_STATE_NO_OCCLUSION);
116 windowRoot_->DestroyWindowInner(windowNode);
117 }
118
119 /**
120 * @tc.name: WindowRootTest03
121 * @tc.desc: test WindowRoot CreateWindowNodeContainer
122 * @tc.type: FUNC
123 */
124 HWTEST_F(WindowRootTest, WindowRootTest03, Function | SmallTest | Level2)
125 {
126 sptr<DisplayInfo> displayInfo = new DisplayInfo();
127
128 displayInfo->SetWidth(49);
129 auto container = windowRoot_->CreateWindowNodeContainer(0, displayInfo);
130 ASSERT_EQ(container, nullptr);
131
132 displayInfo->SetWidth(7681);
133 container = windowRoot_->CreateWindowNodeContainer(0, displayInfo);
134 ASSERT_EQ(container, nullptr);
135
136 displayInfo->SetWidth(50);
137 displayInfo->SetHeight(49);
138 container = windowRoot_->CreateWindowNodeContainer(0, displayInfo);
139 ASSERT_EQ(container, nullptr);
140
141 displayInfo->SetHeight(7681);
142 container = windowRoot_->CreateWindowNodeContainer(0, displayInfo);
143 ASSERT_EQ(container, nullptr);
144 }
145
146 /**
147 * @tc.name: WindowRootTest04
148 * @tc.desc: test WindowRoot GetWindowNodeContainer
149 * @tc.type: FUNC
150 */
151 HWTEST_F(WindowRootTest, WindowRootTest04, Function | SmallTest | Level2)
152 {
153 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
154 ASSERT_NE(display, nullptr);
155 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
156 ASSERT_NE(displayInfo, nullptr);
157 displayInfo->SetDisplayId(0);
158 displayInfo->SetScreenGroupId(SCREEN_ID_INVALID);
159 auto container = windowRoot_->CreateWindowNodeContainer(0, displayInfo);
160 ASSERT_NE(container, nullptr);
161
162 windowRoot_->GetWindowNodeContainer(DISPLAY_ID_INVALID);
163 }
164
165 /**
166 * @tc.name: WindowRootTest05
167 * @tc.desc: test WindowRoot GetBackgroundNodesByScreenId
168 * @tc.type: FUNC
169 */
170 HWTEST_F(WindowRootTest, WindowRootTest05, Function | SmallTest | Level2)
171 {
172 std::vector<sptr<WindowNode>> windowNodes;
173
174 sptr<WindowProperty> property = new WindowProperty();
175 property->SetDisplayId(DISPLAY_ID_INVALID);
176 sptr<WindowNode> windowNode1 = new WindowNode(property);
177 windowRoot_->SaveWindow(windowNode1);
178 property->SetDisplayId(0);
179 sptr<WindowNode> windowNode2 = new WindowNode(property);
180 windowRoot_->SaveWindow(windowNode2);
181
182 auto screenGroupId = DisplayManagerServiceInner::GetInstance().GetScreenGroupIdByDisplayId(DISPLAY_ID_INVALID);
183 windowRoot_->GetBackgroundNodesByScreenId(screenGroupId, windowNodes);
184 sptr<WindowNode> windowNode3 = new WindowNode();
185 windowRoot_->SaveWindow(windowNode3);
186 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode3->GetWindowId(), windowNode3));
187 windowNodes.push_back(windowNode1);
188 windowNodes.push_back(windowNode2);
189 windowNodes.push_back(windowNode3);
190 windowRoot_->GetBackgroundNodesByScreenId(screenGroupId, windowNodes);
191
192 windowRoot_->DestroyWindowInner(windowNode1);
193 windowRoot_->DestroyWindowInner(windowNode2);
194
195 ASSERT_EQ(true, true);
196 }
197
198 /**
199 * @tc.name: WindowRootTest06
200 * @tc.desc: test WindowRoot AddDeathRecipient
201 * @tc.type: FUNC
202 */
203 HWTEST_F(WindowRootTest, WindowRootTest06, Function | SmallTest | Level2)
204 {
205 windowRoot_->AddDeathRecipient(nullptr);
206
207 ASSERT_EQ(true, true);
208
209 sptr<WindowNode> windowNode = new WindowNode();
210 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
211 sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
212 windowNode->SetWindowToken(iWindow);
213 windowRoot_->windowDeath_ = nullptr;
214 ASSERT_TRUE((windowRoot_ != nullptr));
215 windowRoot_->AddDeathRecipient(windowNode);
216 }
217
218 /**
219 * @tc.name: WindowRootTest07
220 * @tc.desc: test WindowRoot SaveWindow
221 * @tc.type: FUNC
222 */
223 HWTEST_F(WindowRootTest, WindowRootTest07, Function | SmallTest | Level2)
224 {
225 windowRoot_->SaveWindow(nullptr);
226
227 ASSERT_EQ(true, true);
228 }
229
230 /**
231 * @tc.name: WindowRootTest08
232 * @tc.desc: test WindowRoot MinimizeStructuredAppWindowsExceptSelf
233 * @tc.type: FUNC
234 */
235 HWTEST_F(WindowRootTest, WindowRootTest08, Function | SmallTest | Level2)
236 {
237 sptr<WindowProperty> property = new WindowProperty();
238 property->SetDisplayId(DISPLAY_ID_INVALID);
239 sptr<WindowNode> windowNode = new WindowNode(property);
240
241 WMError ret = windowRoot_->MinimizeStructuredAppWindowsExceptSelf(windowNode);
242
243 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
244 }
245
246 /**
247 * @tc.name: WindowRootTest09
248 * @tc.desc: test WindowRoot MinimizeTargetWindows
249 * @tc.type: FUNC
250 */
251 HWTEST_F(WindowRootTest, WindowRootTest09, Function | SmallTest | Level2)
252 {
253 std::vector<uint32_t> windowIds;
254
255 windowRoot_->MinimizeTargetWindows(windowIds);
256
257 windowIds.push_back(INVALID_WINDOW_ID);
258 windowRoot_->MinimizeTargetWindows(windowIds);
259
260 sptr<WindowProperty> property = new WindowProperty();
261 property->SetWindowId(1);
262 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
263 auto windowNode = new WindowNode(property);
264 windowRoot_->SaveWindow(windowNode);
265 property = new WindowProperty();
266 property->SetWindowId(2);
267 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
268 windowNode = new WindowNode(property);
269 windowRoot_->SaveWindow(windowNode);
270 windowIds.push_back(1);
271 windowIds.push_back(2);
272 windowRoot_->MinimizeTargetWindows(windowIds);
273
274 ASSERT_EQ(true, true);
275 }
276
277 /**
278 * @tc.name: WindowRootTest10
279 * @tc.desc: test WindowRoot GetSplitScreenWindowNodes
280 * @tc.type: FUNC
281 */
282 HWTEST_F(WindowRootTest, WindowRootTest10, Function | SmallTest | Level2)
283 {
284 std::vector<sptr<WindowNode>> windowNodes = windowRoot_->GetSplitScreenWindowNodes(DISPLAY_ID_INVALID);
285 ASSERT_EQ(windowNodes.empty(), true);
286 DisplayId defaultDisplayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
287 windowNodes = windowRoot_->GetSplitScreenWindowNodes(defaultDisplayId);
288 ASSERT_EQ(windowNodes.empty(), true);
289 }
290
291 /**
292 * @tc.name: WindowRootTest11
293 * @tc.desc: test WindowRoot IsForbidDockSliceMove
294 * @tc.type: FUNC
295 */
296 HWTEST_F(WindowRootTest, WindowRootTest11, Function | SmallTest | Level2)
297 {
298 bool ret = windowRoot_->IsForbidDockSliceMove(DISPLAY_ID_INVALID);
299 ASSERT_EQ(ret, true);
300
301 ret = windowRoot_->IsForbidDockSliceMove(0);
302 ASSERT_EQ(ret, true);
303 }
304
305 /**
306 * @tc.name: WindowRootTest12
307 * @tc.desc: test WindowRoot IsDockSliceInExitSplitModeArea
308 * @tc.type: FUNC
309 */
310 HWTEST_F(WindowRootTest, WindowRootTest12, Function | SmallTest | Level2)
311 {
312 bool ret = windowRoot_->IsDockSliceInExitSplitModeArea(DISPLAY_ID_INVALID);
313 ASSERT_EQ(ret, false);
314
315 ret = windowRoot_->IsDockSliceInExitSplitModeArea(0);
316 ASSERT_EQ(ret, false);
317
318 DisplayId defaultDisplayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
319 ret = windowRoot_->IsDockSliceInExitSplitModeArea(defaultDisplayId);
320 ASSERT_EQ(ret, false);
321 }
322
323 /**
324 * @tc.name: WindowRootTest13
325 * @tc.desc: test WindowRoot ExitSplitMode
326 * @tc.type: FUNC
327 */
328 HWTEST_F(WindowRootTest, WindowRootTest13, Function | SmallTest | Level2)
329 {
330 windowRoot_->ExitSplitMode(DISPLAY_ID_INVALID);
331
332 windowRoot_->ExitSplitMode(0);
333 ASSERT_EQ(true, true);
334 DisplayId defaultDisplayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
335 ASSERT_TRUE((windowRoot_ != nullptr));
336 windowRoot_->ExitSplitMode(defaultDisplayId);
337 }
338
339 /**
340 * @tc.name: WindowRootTest14
341 * @tc.desc: test WindowRoot AddSurfaceNodeIdWindowNodePair
342 * @tc.type: FUNC
343 */
344 HWTEST_F(WindowRootTest, WindowRootTest14, Function | SmallTest | Level2)
345 {
346 windowRoot_->AddSurfaceNodeIdWindowNodePair(INVALID_WINDOW_ID, nullptr);
347
348 ASSERT_EQ(true, true);
349 }
350
351 /**
352 * @tc.name: WindowRootTest15
353 * @tc.desc: test WindowRoot GetVisibilityWindowInfo
354 * @tc.type: FUNC
355 */
356 HWTEST_F(WindowRootTest, WindowRootTest15, Function | SmallTest | Level2)
357 {
358 std::vector<sptr<WindowVisibilityInfo>> infos = {};
359
360 windowRoot_->GetVisibilityWindowInfo(infos);
361
362 ASSERT_EQ(true, true);
363
364 windowRoot_->lastVisibleData_.emplace_back(1, WINDOW_VISIBILITY_STATE_NO_OCCLUSION); // 1 is surafceId
365 windowRoot_->lastVisibleData_.emplace_back(2, WINDOW_VISIBILITY_STATE_NO_OCCLUSION); // 2 is surafceId
366 windowRoot_->lastVisibleData_.emplace_back(3, WINDOW_VISIBILITY_STATE_NO_OCCLUSION); // 3 is surafceId
367 windowRoot_->GetVisibilityWindowInfo(infos);
368 }
369
370 /**
371 * @tc.name: WindowRootTest16
372 * @tc.desc: test WindowRoot GetAvoidAreaByType
373 * @tc.type: FUNC
374 */
375 HWTEST_F(WindowRootTest, WindowRootTest16, Function | SmallTest | Level2)
376 {
377 AvoidArea emptyArea;
378 AvoidArea area;
379 sptr<WindowNode> node = new WindowNode();
380
381 area = windowRoot_->GetAvoidAreaByType(node->GetWindowId(), AvoidAreaType::TYPE_CUTOUT);
382 ASSERT_EQ(area, emptyArea);
383
384 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
385 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
386 ASSERT_TRUE((display != nullptr));
387 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
388 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
389 area = windowRoot_->GetAvoidAreaByType(node->GetWindowId(), AvoidAreaType::TYPE_CUTOUT);
390 ASSERT_EQ(area, emptyArea);
391 }
392
393 /**
394 * @tc.name: WindowRootTest17
395 * @tc.desc: test WindowRoot MinimizeAllAppWindows
396 * @tc.type: FUNC
397 */
398 HWTEST_F(WindowRootTest, WindowRootTest17, Function | SmallTest | Level2)
399 {
400 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
401 ASSERT_TRUE((display != nullptr));
402 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
403 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(DISPLAY_ID_INVALID, container));
404 windowRoot_->MinimizeAllAppWindows(DISPLAY_ID_INVALID);
405
406 ASSERT_EQ(true, true);
407 }
408
409 /**
410 * @tc.name: WindowRootTest18
411 * @tc.desc: test WindowRoot DestroyLeakStartingWindow
412 * @tc.type: FUNC
413 */
414 HWTEST_F(WindowRootTest, WindowRootTest18, Function | SmallTest | Level2)
415 {
416 windowRoot_->DestroyLeakStartingWindow();
417
418 ASSERT_EQ(true, true);
419 sptr<WindowNode> node = new WindowNode();
420 node->startingWindowShown_ = true;
421 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
422 ASSERT_TRUE((windowRoot_ != nullptr));
423 windowRoot_->DestroyLeakStartingWindow();
424 }
425
426 /**
427 * @tc.name: WindowRootTest20
428 * @tc.desc: test WindowRoot LayoutWhenAddWindowNode
429 * @tc.type: FUNC
430 */
431 HWTEST_F(WindowRootTest, WindowRootTest20, Function | SmallTest | Level2)
432 {
433 sptr<WindowNode> node = nullptr;
434 windowRoot_->LayoutWhenAddWindowNode(node, true);
435
436 node = new WindowNode();
437 windowRoot_->LayoutWhenAddWindowNode(node, true);
438
439 ASSERT_EQ(true, true);
440 }
441
442 /**
443 * @tc.name: WindowRootTest21
444 * @tc.desc: test WindowRoot AddWindowNode
445 * @tc.type: FUNC
446 */
447 HWTEST_F(WindowRootTest, WindowRootTest21, Function | SmallTest | Level2)
448 {
449 WMError ret;
450 sptr<WindowNode> node = nullptr;
451
452 ret = windowRoot_->AddWindowNode(INVALID_WINDOW_ID, node, true);
453 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
454 }
455
456 /**
457 * @tc.name: WindowRootTest22
458 * @tc.desc: test WindowRoot RemoveWindowNode
459 * @tc.type: FUNC
460 */
461 HWTEST_F(WindowRootTest, WindowRootTest22, Function | SmallTest | Level2)
462 {
463 WMError ret;
464 sptr<WindowNode> node = new WindowNode();
465
466 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
467 ret = windowRoot_->RemoveWindowNode(node->GetWindowId(), true);
468 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
469 sptr<WindowNode> node1 = new WindowNode();
470 node->children_.push_back(node1);
471 ret = windowRoot_->RemoveWindowNode(node->GetWindowId(), true);
472 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
473 }
474
475 /**
476 * @tc.name: WindowRootTest23
477 * @tc.desc: test WindowRoot UpdateWindowNode
478 * @tc.type: FUNC
479 */
480 HWTEST_F(WindowRootTest, WindowRootTest23, Function | SmallTest | Level2)
481 {
482 WMError ret;
483
484 ret = windowRoot_->UpdateWindowNode(INVALID_WINDOW_ID, WindowUpdateReason::UPDATE_MODE);
485 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
486
487 sptr<WindowNode> node = new WindowNode();
488 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
489 ret = windowRoot_->UpdateWindowNode(node->GetWindowId(), WindowUpdateReason::UPDATE_MODE);
490 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
491 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
492 ASSERT_TRUE((display != nullptr));
493 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
494 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
495 ret = windowRoot_->UpdateWindowNode(node->GetWindowId(), WindowUpdateReason::UPDATE_MODE);
496 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
497 }
498
499 /**
500 * @tc.name: WindowRootTest24
501 * @tc.desc: test WindowRoot UpdateSizeChangeReason
502 * @tc.type: FUNC
503 */
504 HWTEST_F(WindowRootTest, WindowRootTest24, Function | SmallTest | Level2)
505 {
506 WMError ret;
507
508 ret = windowRoot_->UpdateSizeChangeReason(INVALID_WINDOW_ID, WindowSizeChangeReason::UNDEFINED);
509 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
510
511 sptr<WindowNode> node = new WindowNode();
512 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
513 ret = windowRoot_->UpdateSizeChangeReason(node->GetWindowId(), WindowSizeChangeReason::UNDEFINED);
514 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
515 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
516 ASSERT_TRUE((display != nullptr));
517 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
518 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
519 ret = windowRoot_->UpdateSizeChangeReason(node->GetWindowId(), WindowSizeChangeReason::UNDEFINED);
520 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
521 }
522
523 /**
524 * @tc.name: WindowRootTest25
525 * @tc.desc: test WindowRoot SetBrightness
526 * @tc.type: FUNC
527 */
528 HWTEST_F(WindowRootTest, WindowRootTest25, Function | SmallTest | Level2)
529 {
530 windowRoot_->SetBrightness(INVALID_WINDOW_ID, 0);
531
532 sptr<WindowNode> node = new WindowNode();
533 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
534 windowRoot_->SetBrightness(node->GetWindowId(), 0);
535
536 ASSERT_EQ(true, true);
537 }
538
539 /**
540 * @tc.name: CheckAndNotifyWaterMarkChangedResult
541 * @tc.desc: test WindowRoot CheckAndNotifyWaterMarkChangedResult
542 * @tc.type: FUNC
543 */
544 HWTEST_F(WindowRootTest, CheckAndNotifyWaterMarkChangedResult, Function | SmallTest | Level2)
545 {
546 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
547 ASSERT_NE(display, nullptr);
548 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
549 auto container = windowRoot_->CreateWindowNodeContainer(display->GetId(), displayInfo);
550 ASSERT_NE(container, nullptr);
551
552 windowRoot_->lastWaterMarkShowStates_ = false;
553 windowRoot_->CheckAndNotifyWaterMarkChangedResult();
554 ASSERT_EQ(windowRoot_->lastWaterMarkShowStates_, false);
555
556 auto windowNode = new (std::nothrow)WindowNode();
557 ASSERT_NE(windowNode, nullptr);
558 windowNode->SetVisibilityState(WINDOW_VISIBILITY_STATE_NO_OCCLUSION);
559 windowNode->SetDisplayId(displayInfo->GetDisplayId());
560 windowNode->property_->flags_ |= static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
561 container->appWindowNode_->children_.push_back(windowNode);
562
563 windowRoot_->CheckAndNotifyWaterMarkChangedResult();
564 ASSERT_EQ(windowRoot_->lastWaterMarkShowStates_, true);
565
566 container->appWindowNode_->children_.clear();
567 windowRoot_->CheckAndNotifyWaterMarkChangedResult();
568 ASSERT_EQ(windowRoot_->lastWaterMarkShowStates_, false);
569 }
570
571 /**
572 * @tc.name: SetGestureNavigaionEnabled
573 * @tc.desc: test WindowRoot SetGestureNavigaionEnabled
574 * @tc.type: FUNC
575 */
576 HWTEST_F(WindowRootTest, SetGestureNavigaionEnabled, Function | SmallTest | Level2)
577 {
578 windowRoot_->lastGestureNativeEnabled_ = false;
579 auto ret = windowRoot_->SetGestureNavigaionEnabled(false);
580 ASSERT_EQ(ret, WMError::WM_DO_NOTHING);
581
582 ret = windowRoot_->SetGestureNavigaionEnabled(true);
583 ASSERT_EQ(ret, WMError::WM_OK);
584
585 windowRoot_->lastGestureNativeEnabled_ = false;
586 }
587
588 /**
589 * @tc.name: GetWindowVisibilityChangeInfo
590 * @tc.desc: test WindowRoot GetWindowVisibilityChangeInfo
591 * @tc.type: FUNC
592 */
593 HWTEST_F(WindowRootTest, GetWindowVisibilityChangeInfo, Function | SmallTest | Level2)
594 {
595 std::shared_ptr<RSOcclusionData> occlusionData = std::make_shared<RSOcclusionData>();
596 ASSERT_NE(occlusionData, nullptr);
597 windowRoot_->GetWindowVisibilityChangeInfo(occlusionData);
598 occlusionData->visibleData_.emplace_back(4, ALL_VISIBLE); // 4 is surfaceid
599 occlusionData->visibleData_.emplace_back(5, ALL_VISIBLE); // 5 is surfaceid
600 occlusionData->visibleData_.emplace_back(6, ALL_VISIBLE); // 6 is surfaceid
601 ASSERT_TRUE((windowRoot_ != nullptr));
602 windowRoot_->GetWindowVisibilityChangeInfo(occlusionData);
603 }
604
605 /**
606 * @tc.name: NotifyWindowVisibilityChange
607 * @tc.desc: test WindowRoot NotifyWindowVisibilityChange
608 * @tc.type: FUNC
609 */
610 HWTEST_F(WindowRootTest, NotifyWindowVisibilityChange, Function | SmallTest | Level2)
611 {
612 std::shared_ptr<RSOcclusionData> occlusionData = std::make_shared<RSOcclusionData>();
613 ASSERT_NE(occlusionData, nullptr);
614 windowRoot_->NotifyWindowVisibilityChange(occlusionData);
615 occlusionData->visibleData_.emplace_back(4, ALL_VISIBLE); // 4 is surfaceid
616 occlusionData->visibleData_.emplace_back(5, ALL_VISIBLE); // 5 is surfaceid
617 occlusionData->visibleData_.emplace_back(6, ALL_VISIBLE); // 6 is surfaceid
618 ASSERT_TRUE((windowRoot_ != nullptr));
619 windowRoot_->NotifyWindowVisibilityChange(occlusionData);
620 }
621
622 /**
623 * @tc.name: ToggleShownStateForAllAppWindows
624 * @tc.desc: test WindowRoot ToggleShownStateForAllAppWindows
625 * @tc.type: FUNC
626 */
627 HWTEST_F(WindowRootTest, ToggleShownStateForAllAppWindows, Function | SmallTest | Level2)
628 {
629 ScreenId displayGroupId = 1;
630 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
631 ASSERT_TRUE((display != nullptr));
632 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
633 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
634 auto ret = windowRoot_->ToggleShownStateForAllAppWindows();
635 ASSERT_EQ(ret, WMError::WM_OK);
636 }
637
638 /**
639 * @tc.name: PostProcessAddWindowNode01
640 * @tc.desc: test WindowRoot PostProcessAddWindowNode01
641 * @tc.type: FUNC
642 */
643 HWTEST_F(WindowRootTest, PostProcessAddWindowNode01, Function | SmallTest | Level2)
644 {
645 sptr<WindowNode> node = new WindowNode();
646 sptr<WindowNode> parentNode = new WindowNode();
647 sptr<WindowNodeContainer> container;
648 auto ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
649 ASSERT_EQ(ret, WMError::WM_DO_NOTHING);
650 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
651 node->property_->SetWindowId(1);
652 ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
653 ASSERT_EQ(ret, WMError::WM_DO_NOTHING);
654 }
655
656 /**
657 * @tc.name: PostProcessAddWindowNode02
658 * @tc.desc: test WindowRoot PostProcessAddWindowNode02
659 * @tc.type: FUNC
660 */
661 HWTEST_F(WindowRootTest, PostProcessAddWindowNode02, Function | SmallTest | Level2)
662 {
663 sptr<WindowNode> node = new WindowNode();
664 sptr<WindowNode> parentNode = nullptr;
665 sptr<DisplayInfo> displayInfo = new DisplayInfo();
666 sptr<WindowNodeContainer> container;
667 node->currentVisibility_ = false;
668 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
669 auto ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
670 ASSERT_EQ(ret, WMError::WM_DO_NOTHING);
671 }
672
673 /**
674 * @tc.name: PostProcessAddWindowNode03
675 * @tc.desc: test WindowRoot PostProcessAddWindowNode03
676 * @tc.type: FUNC
677 */
678 HWTEST_F(WindowRootTest, PostProcessAddWindowNode03, Function | SmallTest | Level2)
679 {
680 sptr<WindowNode> node = new WindowNode();
681 sptr<WindowNode> parentNode = new WindowNode();
682 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
683 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
684 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
685 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
686 node->property_->SetWindowId(1);
687 node->property_->SetFocusable(true);
688 node->currentVisibility_ = true;
689 auto ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
690 ASSERT_EQ(ret, WMError::WM_OK);
691 }
692
693 /**
694 * @tc.name: PostProcessAddWindowNode04
695 * @tc.desc: test WindowRoot PostProcessAddWindowNode04
696 * @tc.type: FUNC
697 */
698 HWTEST_F(WindowRootTest, PostProcessAddWindowNode04, Function | SmallTest | Level2)
699 {
700 sptr<WindowNode> node = new WindowNode();
701 sptr<WindowNode> parentNode = new WindowNode();
702 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
703 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
704 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
705 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
706 node->property_->SetWindowId(1);
707 node->property_->SetFocusable(true);
708 node->currentVisibility_ = true;
709 sptr<WindowNode> node1 = new WindowNode();
710 node->children_.push_back(node1);
711 auto ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
712 ASSERT_EQ(ret, WMError::WM_OK);
713 }
714
715 /**
716 * @tc.name: BindDialogToParent01
717 * @tc.desc: test WindowRoot BindDialogToParent01
718 * @tc.type: FUNC
719 */
720 HWTEST_F(WindowRootTest, BindDialogToParent01, Function | SmallTest | Level2)
721 {
722 sptr<WindowNode> node = new WindowNode();
723 node->dialogTargetToken_ = nullptr;
724 sptr<WindowNode> parentNode = new WindowNode();
725 auto ret = windowRoot_->BindDialogToParent(node, parentNode);
726 ASSERT_EQ(ret, WMError::WM_OK);
727 }
728
729 /**
730 * @tc.name: BindDialogToParent02
731 * @tc.desc: test WindowRoot BindDialogToParent02
732 * @tc.type: FUNC
733 */
734 HWTEST_F(WindowRootTest, BindDialogToParent02, Function | SmallTest | Level2)
735 {
736 sptr<WindowNode> node = new WindowNode();
737 sptr<WindowNode> parentNode = new WindowNode();
738 node->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
739 node->dialogTargetToken_ = new (std::nothrow) IRemoteObjectMocker();
740 sptr<WindowNode> windowNode3 = new WindowNode();
741 windowNode3->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
742 windowNode3->abilityToken_ = node->dialogTargetToken_;
743 windowRoot_->SaveWindow(windowNode3);
744 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode3->GetWindowId(), windowNode3));
745 auto ret = windowRoot_->BindDialogToParent(node, parentNode);
746 ASSERT_EQ(ret, WMError::WM_OK);
747 }
748
749 /**
750 * @tc.name: UpdateFocusableProperty
751 * @tc.desc: test WindowRoot UpdateFocusableProperty
752 * @tc.type: FUNC
753 */
754 HWTEST_F(WindowRootTest, UpdateFocusableProperty, Function | SmallTest | Level2)
755 {
756 uint32_t windowId = 1;
757 windowRoot_->UpdateFocusableProperty(windowId);
758 auto node = windowRoot_->GetWindowNode(windowId);
759 ASSERT_EQ(node, nullptr);
760 }
761
762 /**
763 * @tc.name: SetWindowMode
764 * @tc.desc: test WindowRoot SetWindowMode
765 * @tc.type: FUNC
766 */
767 HWTEST_F(WindowRootTest, SetWindowMode, Function | SmallTest | Level2)
768 {
769 sptr<WindowNode> node = new WindowNode();
770 WindowMode dstMode = WindowMode::WINDOW_MODE_UNDEFINED;
771 auto ret = windowRoot_->SetWindowMode(node, dstMode);
772 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
773 dstMode = WindowMode::WINDOW_MODE_FULLSCREEN;
774 ret = windowRoot_->SetWindowMode(node, dstMode);
775 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
776 }
777
778 /**
779 * @tc.name: DestroyWindowSelf
780 * @tc.desc: test WindowRoot DestroyWindowSelf
781 * @tc.type: FUNC
782 */
783 HWTEST_F(WindowRootTest, DestroyWindowSelf, Function | SmallTest | Level2)
784 {
785 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
786 ASSERT_TRUE((display != nullptr));
787 sptr<WindowNode> node = new WindowNode();
788 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
789 auto ret = windowRoot_->DestroyWindowSelf(node, container);
790 ASSERT_EQ(ret, WMError::WM_OK);
791 }
792
793 /**
794 * @tc.name: IsVerticalDisplay
795 * @tc.desc: test WindowRoot IsVerticalDisplay
796 * @tc.type: FUNC
797 */
798 HWTEST_F(WindowRootTest, IsVerticalDisplay, Function | SmallTest | Level2)
799 {
800 sptr<WindowNode> node = new WindowNode();
801 ASSERT_EQ(false, windowRoot_->IsVerticalDisplay(node));
802 }
803
804 /**
805 * @tc.name: RequestFocus
806 * @tc.desc: test WindowRoot RequestFocus
807 * @tc.type: FUNC
808 */
809 HWTEST_F(WindowRootTest, RequestFocus, Function | SmallTest | Level2)
810 {
811 uint32_t windowId = 1;
812 auto ret = windowRoot_->RequestFocus(windowId);
813 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
814 }
815
816 /**
817 * @tc.name: RequestActiveWindow
818 * @tc.desc: test WindowRoot RequestActiveWindow
819 * @tc.type: FUNC
820 */
821 HWTEST_F(WindowRootTest, RequestActiveWindow, Function | SmallTest | Level2)
822 {
823 uint32_t windowId = 1;
824 auto ret = windowRoot_->RequestActiveWindow(windowId);
825 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
826 }
827
828 /**
829 * @tc.name: ProcessWindowStateChange
830 * @tc.desc: test WindowRoot ProcessWindowStateChange
831 * @tc.type: FUNC
832 */
833 HWTEST_F(WindowRootTest, ProcessWindowStateChange, Function | SmallTest | Level2)
834 {
835 WindowState state = WindowState::STATE_INITIAL;
836 WindowStateChangeReason reason = WindowStateChangeReason::NORMAL;
837 windowRoot_->ProcessWindowStateChange(state, reason);
838 ASSERT_EQ(reason, WindowStateChangeReason::NORMAL);
839 }
840
841 /**
842 * @tc.name: NotifySystemBarTints
843 * @tc.desc: test WindowRoot NotifySystemBarTints
844 * @tc.type: FUNC
845 */
846 HWTEST_F(WindowRootTest, NotifySystemBarTints, Function | SmallTest | Level2)
847 {
848 ScreenId displayGroupId = 1;
849 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
850 ASSERT_TRUE((display != nullptr));
851 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
852 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
853 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
854 DisplayId displayId = displayInfo->GetDisplayId();
855 std::vector<DisplayId> displayVec = { displayId };
856 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
857 windowRoot_->NotifySystemBarTints();
858 }
859
860 /**
861 * @tc.name: NotifyDesktopUnfrozen
862 * @tc.desc: test WindowRoot NotifyDesktopUnfrozen
863 * @tc.type: FUNC
864 */
865 HWTEST_F(WindowRootTest, NotifyDesktopUnfrozen, Function | SmallTest | Level2)
866 {
867 sptr<WindowNode> windowNode3 = new WindowNode();
868 windowRoot_->SaveWindow(windowNode3);
869 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode3->GetWindowId(), windowNode3));
870 auto ret = windowRoot_->NotifyDesktopUnfrozen();
871 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
872 }
873
874 /**
875 * @tc.name: RaiseZOrderForAppWindow
876 * @tc.desc: test WindowRoot RaiseZOrderForAppWindow
877 * @tc.type: FUNC
878 */
879 HWTEST_F(WindowRootTest, RaiseZOrderForAppWindow, Function | SmallTest | Level2)
880 {
881 sptr<WindowNode> windowNode2 = nullptr;
882 auto ret = windowRoot_->RaiseZOrderForAppWindow(windowNode2);
883 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
884 sptr<WindowNode> windowNode3 = new WindowNode();
885 ret = windowRoot_->RaiseZOrderForAppWindow(windowNode3);
886 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
887 }
888
889 /**
890 * @tc.name: DispatchKeyEvent
891 * @tc.desc: test WindowRoot DispatchKeyEvent
892 * @tc.type: FUNC
893 */
894 HWTEST_F(WindowRootTest, DispatchKeyEvent, Function | SmallTest | Level2)
895 {
896 sptr<WindowNode> windowNode = new WindowNode();
897 std::shared_ptr<MMI::KeyEvent> event = nullptr;
898 ASSERT_TRUE((windowRoot_ != nullptr));
899 windowRoot_->DispatchKeyEvent(windowNode, event);
900 }
901
902 /**
903 * @tc.name: GetTopWindowId
904 * @tc.desc: test WindowRoot GetTopWindowId
905 * @tc.type: FUNC
906 */
907 HWTEST_F(WindowRootTest, GetTopWindowId, Function | SmallTest | Level2)
908 {
909 uint32_t mainWinId = 0;
910 uint32_t topWinId = 1;
911 auto ret = windowRoot_->GetTopWindowId(mainWinId, topWinId);
912 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
913 }
914
915 /**
916 * @tc.name: SetWindowLayoutMode
917 * @tc.desc: test WindowRoot SetWindowLayoutMode
918 * @tc.type: FUNC
919 */
920 HWTEST_F(WindowRootTest, SetWindowLayoutMode, Function | SmallTest | Level2)
921 {
922 DisplayId displayId = 1;
923 WindowLayoutMode mode = WindowLayoutMode::BASE;
924 auto ret = windowRoot_->SetWindowLayoutMode(displayId, mode);
925 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
926 }
927
928 /**
929 * @tc.name: GetAllDisplayIds
930 * @tc.desc: test WindowRoot GetAllDisplayIds,RemoveSingleUserWindowNodes
931 * @tc.type: FUNC
932 */
933 HWTEST_F(WindowRootTest, GetAllDisplayIds, Function | SmallTest | Level2)
934 {
935 ScreenId displayGroupId = 1;
936 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
937 ASSERT_TRUE((display != nullptr));
938 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
939 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
940 windowRoot_->GetAllDisplayIds();
941 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
942 DisplayId displayId = displayInfo->GetDisplayId();
943 std::vector<DisplayId> displayVec = { displayId };
944 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
945 ASSERT_TRUE((windowRoot_ != nullptr));
946 windowRoot_->GetAllDisplayIds();
947 ASSERT_TRUE((windowRoot_ != nullptr));
948 windowRoot_->RemoveSingleUserWindowNodes(displayGroupId);
949 }
950
951 /**
952 * @tc.name: GenAllWindowsLogInfo
953 * @tc.desc: test WindowRoot GenAllWindowsLogInfo
954 * @tc.type: FUNC
955 */
956 HWTEST_F(WindowRootTest, GenAllWindowsLogInfo, Function | SmallTest | Level2)
957 {
958 ScreenId displayGroupId = 1;
959 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
960 ASSERT_TRUE((display != nullptr));
961 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
962 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
963 windowRoot_->GenAllWindowsLogInfo();
964 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
965 DisplayId displayId = displayInfo->GetDisplayId();
966 std::vector<DisplayId> displayVec = { displayId };
967 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
968 ASSERT_TRUE((windowRoot_ != nullptr));
969 windowRoot_->GenAllWindowsLogInfo();
970 }
971
972 /**
973 * @tc.name: FocusFaultDetection
974 * @tc.desc: test WindowRoot FocusFaultDetection
975 * @tc.type: FUNC
976 */
977 HWTEST_F(WindowRootTest, FocusFaultDetection, Function | SmallTest | Level2)
978 {
979 ScreenId displayGroupId = 1;
980 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
981 ASSERT_TRUE((display != nullptr));
982 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
983 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
984 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
985 DisplayId displayId = displayInfo->GetDisplayId();
986 std::vector<DisplayId> displayVec = { displayId };
987 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
988 windowRoot_->needCheckFocusWindow = false;
989 windowRoot_->FocusFaultDetection();
990 windowRoot_->needCheckFocusWindow = true;
991 ASSERT_TRUE((windowRoot_ != nullptr));
992 windowRoot_->FocusFaultDetection();
993 }
994
995 /**
996 * @tc.name: ProcessExpandDisplayCreate
997 * @tc.desc: test WindowRoot ProcessExpandDisplayCreate
998 * @tc.type: FUNC
999 */
1000 HWTEST_F(WindowRootTest, ProcessExpandDisplayCreate, Function | SmallTest | Level2)
1001 {
1002 ScreenId displayGroupId = 1;
1003 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1004 ASSERT_TRUE((display != nullptr));
1005 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1006 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
1007 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1008 DisplayId displayId = displayInfo->GetDisplayId();
1009 std::vector<DisplayId> displayVec = { displayId };
1010 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
1011 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1012 ASSERT_NE(display, nullptr);
1013 displayInfo->SetWidth(100);
1014 displayInfo->SetHeight(100);
1015 std::map<DisplayId, Rect> displayRectMap = {};
1016 windowRoot_->ProcessExpandDisplayCreate(defaultDisplayId, displayInfo, displayRectMap);
1017 }
1018
1019 /**
1020 * @tc.name: GetAllDisplayRectsByDisplayInfo
1021 * @tc.desc: test WindowRoot GetAllDisplayRectsByDisplayInfo
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(WindowRootTest, GetAllDisplayRectsByDisplayInfo, Function | SmallTest | Level2)
1025 {
1026 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
1027 ASSERT_TRUE((windowRoot_ != nullptr));
1028 windowRoot_->GetAllDisplayRectsByDisplayInfo(displayInfoMap);
1029 }
1030
1031 /**
1032 * @tc.name: ProcessDisplayCreate
1033 * @tc.desc: test WindowRoot ProcessDisplayCreate
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(WindowRootTest, ProcessDisplayCreate, Function | SmallTest | Level2)
1037 {
1038 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1039 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1040 ASSERT_TRUE((display != nullptr));
1041 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1042 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
1043 windowRoot_->ProcessDisplayCreate(defaultDisplayId, displayInfo, displayInfoMap);
1044 }
1045
1046 /**
1047 * @tc.name: MoveNotShowingWindowToDefaultDisplay
1048 * @tc.desc: test WindowRoot MoveNotShowingWindowToDefaultDisplay
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(WindowRootTest, MoveNotShowingWindowToDefaultDisplay, Function | SmallTest | Level2)
1052 {
1053 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1054 ASSERT_TRUE((windowRoot_ != nullptr));
1055 DisplayId displayId = 1;
1056 sptr<WindowNode> node = new WindowNode();
1057 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
1058 windowRoot_->MoveNotShowingWindowToDefaultDisplay(defaultDisplayId, displayId);
1059 }
1060
1061 /**
1062 * @tc.name: ProcessDisplayDestroy
1063 * @tc.desc: test WindowRoot ProcessDisplayDestroy
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(WindowRootTest, ProcessDisplayDestroy, Function | SmallTest | Level2)
1067 {
1068 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1069 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1070 ASSERT_TRUE((display != nullptr));
1071 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1072 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
1073 windowRoot_->ProcessDisplayDestroy(defaultDisplayId, displayInfo, displayInfoMap);
1074 }
1075
1076 /**
1077 * @tc.name: ProcessDisplayChange
1078 * @tc.desc: test WindowRoot ProcessDisplayChange
1079 * @tc.type: FUNC
1080 */
1081 HWTEST_F(WindowRootTest, ProcessDisplayChange, Function | SmallTest | Level2)
1082 {
1083 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1084 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1085 ASSERT_TRUE((display != nullptr));
1086 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1087 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
1088 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
1089 windowRoot_->ProcessDisplayChange(defaultDisplayId, displayInfo, displayInfoMap, type);
1090 displayInfo = nullptr;
1091 ASSERT_TRUE((windowRoot_ != nullptr));
1092 windowRoot_->ProcessDisplayChange(defaultDisplayId, displayInfo, displayInfoMap, type);
1093 }
1094
1095 /**
1096 * @tc.name: GetDisplayGroupRect
1097 * @tc.desc: test WindowRoot GetDisplayGroupRect
1098 * @tc.type: FUNC
1099 */
1100 HWTEST_F(WindowRootTest, GetDisplayGroupRect, Function | SmallTest | Level2)
1101 {
1102 DisplayId displayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1103 ASSERT_TRUE((windowRoot_ != nullptr));
1104 windowRoot_->GetDisplayGroupRect(displayId);
1105 }
1106
1107 /**
1108 * @tc.name: RemoveSingleUserWindowNodes
1109 * @tc.desc: test WindowRoot RemoveSingleUserWindowNodes
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(WindowRootTest, RemoveSingleUserWindowNodes, Function | SmallTest | Level2)
1113 {
1114 int accountId = 1;
1115 ASSERT_TRUE((windowRoot_ != nullptr));
1116 windowRoot_->RemoveSingleUserWindowNodes(accountId);
1117 }
1118
1119 /**
1120 * @tc.name: TakeWindowPairSnapshot
1121 * @tc.desc: test WindowRoot TakeWindowPairSnapshot
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(WindowRootTest, TakeWindowPairSnapshot, Function | SmallTest | Level2)
1125 {
1126 DisplayId displayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1127 bool flag = windowRoot_->TakeWindowPairSnapshot(displayId);
1128 ASSERT_EQ(false, flag);
1129 }
1130
1131 /**
1132 * @tc.name: ClearWindowPairSnapshot
1133 * @tc.desc: test WindowRoot ClearWindowPairSnapshot
1134 * @tc.type: FUNC
1135 */
1136 HWTEST_F(WindowRootTest, ClearWindowPairSnapshot, Function | SmallTest | Level2)
1137 {
1138 DisplayId displayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1139 ASSERT_TRUE((windowRoot_ != nullptr));
1140 windowRoot_->ClearWindowPairSnapshot(displayId);
1141 }
1142
1143 /**
1144 * @tc.name: CheckAddingModeAndSize01
1145 * @tc.desc: test WindowRoot CheckAddingModeAndSize01
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(WindowRootTest, CheckAddingModeAndSize01, Function | SmallTest | Level2)
1149 {
1150 sptr<WindowNode> node = new WindowNode();
1151 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1152 sptr<WindowNodeContainer> container;
1153 ASSERT_TRUE((windowRoot_ != nullptr));
1154 windowRoot_->CheckAddingModeAndSize(node, container);
1155 }
1156
1157 /**
1158 * @tc.name: CheckAddingModeAndSize02
1159 * @tc.desc: test WindowRoot CheckAddingModeAndSize02
1160 * @tc.type: FUNC
1161 */
1162 HWTEST_F(WindowRootTest, CheckAddingModeAndSize02, Function | SmallTest | Level2)
1163 {
1164 sptr<WindowNode> node = new WindowNode();
1165 node->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1166 sptr<Display> defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
1167 sptr<WindowNodeContainer> container = new WindowNodeContainer(
1168 defaultDisplay_->GetDisplayInfo(), defaultDisplay_->GetScreenId());
1169 container->layoutMode_ = WindowLayoutMode::TILE;
1170 node->property_->SetWindowModeSupportType(0);
1171 ASSERT_TRUE((windowRoot_ != nullptr));
1172 windowRoot_->CheckAddingModeAndSize(node, container);
1173 }
1174
1175 /**
1176 * @tc.name: CheckAddingModeAndSize03
1177 * @tc.desc: test WindowRoot CheckAddingModeAndSize03
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(WindowRootTest, CheckAddingModeAndSize03, Function | SmallTest | Level2)
1181 {
1182 sptr<WindowNode> node = new WindowNode();
1183 node->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1184 sptr<Display> defaultDisplay_ = DisplayManager::GetInstance().GetDefaultDisplay();
1185 sptr<WindowNodeContainer> container = new WindowNodeContainer(
1186 defaultDisplay_->GetDisplayInfo(), defaultDisplay_->GetScreenId());
1187 ASSERT_TRUE((windowRoot_ != nullptr));
1188 windowRoot_->CheckAddingModeAndSize(node, container);
1189 }
1190
1191 /**
1192 * @tc.name: GetDisplayRectWithoutSystemBarAreas
1193 * @tc.desc: test WindowRoot GetDisplayRectWithoutSystemBarAreas
1194 * @tc.type: FUNC
1195 */
1196 HWTEST_F(WindowRootTest, GetDisplayRectWithoutSystemBarAreas, Function | SmallTest | Level2)
1197 {
1198 sptr<WindowNode> dstNode = new WindowNode();
1199 ASSERT_TRUE((windowRoot_ != nullptr));
1200 windowRoot_->GetDisplayRectWithoutSystemBarAreas(dstNode);
1201 }
1202
1203 /**
1204 * @tc.name: AddWindowNode01
1205 * @tc.desc: test WindowRoot AddWindowNode01
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(WindowRootTest, AddWindowNode01, Function | SmallTest | Level2)
1209 {
1210 WMError ret;
1211 sptr<WindowNode> node = new WindowNode();
1212 node->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1213
1214 ret = windowRoot_->AddWindowNode(INVALID_WINDOW_ID, node, true);
1215 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
1216 }
1217
1218 /**
1219 * @tc.name: RemoveWindowNode01
1220 * @tc.desc: test WindowRoot RemoveWindowNode01
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(WindowRootTest, RemoveWindowNode01, Function | SmallTest | Level2)
1224 {
1225 uint32_t windowId = 10;
1226 WMError ret = windowRoot_->RemoveWindowNode(windowId, true);
1227 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1228 }
1229
1230 /**
1231 * @tc.name: SetBrightness01
1232 * @tc.desc: test WindowRoot SetBrightness01
1233 * @tc.type: FUNC
1234 */
1235 HWTEST_F(WindowRootTest, SetBrightness01, Function | SmallTest | Level2)
1236 {
1237 windowRoot_->SetBrightness(INVALID_WINDOW_ID, 0);
1238 sptr<WindowNode> node = new WindowNode();
1239 node->SetDisplayId(0);
1240 node->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1241 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetDisplayId(), node));
1242 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1243 ASSERT_TRUE((display != nullptr));
1244 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1245 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
1246 ASSERT_TRUE((windowRoot_ != nullptr));
1247 windowRoot_->SetBrightness(node->GetDisplayId(), 0);
1248 }
1249
1250 /**
1251 * @tc.name: SetBrightness02
1252 * @tc.desc: test WindowRoot SetBrightness02
1253 * @tc.type: FUNC
1254 */
1255 HWTEST_F(WindowRootTest, SetBrightness02, Function | SmallTest | Level2)
1256 {
1257 windowRoot_->SetBrightness(INVALID_WINDOW_ID, 0);
1258 sptr<WindowNode> node = new WindowNode();
1259 node->SetDisplayId(0);
1260 node->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1261 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetDisplayId(), node));
1262 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1263 ASSERT_TRUE((display != nullptr));
1264 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1265 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
1266 ASSERT_TRUE((windowRoot_ != nullptr));
1267 windowRoot_->SetBrightness(node->GetDisplayId(), 0);
1268 }
1269
1270 /**
1271 * @tc.name: HandleKeepScreenOn01
1272 * @tc.desc: test WindowRoot HandleKeepScreenOn01
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(WindowRootTest, HandleKeepScreenOn01, Function | SmallTest | Level2)
1276 {
1277 uint32_t windowId = 1;
1278 bool requireLock = false;
1279 ASSERT_TRUE((windowRoot_ != nullptr));
1280 windowRoot_->HandleKeepScreenOn(windowId, requireLock);
1281 }
1282
1283 /**
1284 * @tc.name: UpdateFocusableProperty01
1285 * @tc.desc: test WindowRoot UpdateFocusableProperty01
1286 * @tc.type: FUNC
1287 */
1288 HWTEST_F(WindowRootTest, UpdateFocusableProperty01, Function | SmallTest | Level2)
1289 {
1290 sptr<WindowNode> windowNode = new WindowNode();
1291 windowNode->SetDisplayId(0);
1292 windowNode->property_->SetWindowId(0);
1293 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetDisplayId(), windowNode));
1294 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1295 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1296 ASSERT_TRUE((display != nullptr));
1297 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1298 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1299 ASSERT_TRUE((windowRoot_ != nullptr));
1300 windowRoot_->UpdateFocusableProperty(windowNode->GetWindowId());
1301 }
1302
1303 /**
1304 * @tc.name: SetWindowMode01
1305 * @tc.desc: test WindowRoot SetWindowMode01
1306 * @tc.type: FUNC
1307 */
1308 HWTEST_F(WindowRootTest, SetWindowMode01, Function | SmallTest | Level2)
1309 {
1310 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1311 ASSERT_TRUE((display != nullptr));
1312 sptr<WindowNode> node = new WindowNode();
1313 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1314 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
1315 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1316 DisplayId displayId = displayInfo->GetDisplayId();
1317 std::vector<DisplayId> displayVec = { displayId };
1318 windowRoot_->displayIdMap_.insert(std::make_pair(node->GetDisplayId(), displayVec));
1319 WindowMode dstMode = WindowMode::WINDOW_MODE_UNDEFINED;
1320 auto ret = windowRoot_->SetWindowMode(node, dstMode);
1321 ASSERT_EQ(ret, WMError::WM_OK);
1322 node->SetWindowMode(dstMode);
1323 ret = windowRoot_->SetWindowMode(node, dstMode);
1324 ASSERT_EQ(ret, WMError::WM_OK);
1325 }
1326
1327 /**
1328 * @tc.name: DestroyWindowSelf01
1329 * @tc.desc: test WindowRoot DestroyWindowSelf01
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(WindowRootTest, DestroyWindowSelf01, Function | SmallTest | Level2)
1333 {
1334 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1335 ASSERT_TRUE((display != nullptr));
1336 sptr<WindowNode> node = new WindowNode();
1337 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1338 node->property_->SetWindowId(0);
1339 sptr<WindowNode> node1 = new WindowNode();
1340 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
1341 sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
1342 node1->SetWindowToken(iWindow);
1343 node1->property_->SetWindowId(1);
1344 node->abilityToken_ = new (std::nothrow) IRemoteObjectMocker();
1345 node1->abilityToken_ = new (std::nothrow) IRemoteObjectMocker();
1346 node1->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1347 node->children_.push_back(node1);
1348 auto ret = windowRoot_->DestroyWindowSelf(node, container);
1349 ASSERT_EQ(ret, WMError::WM_OK);
1350 }
1351
1352 /**
1353 * @tc.name: DestroyWindow
1354 * @tc.desc: test WindowRoot DestroyWindow
1355 * @tc.type: FUNC
1356 */
1357 HWTEST_F(WindowRootTest, DestroyWindow, Function | SmallTest | Level2)
1358 {
1359 uint32_t windowId = 1;
1360 bool onlySelf = false;
1361 auto ret = windowRoot_->DestroyWindow(windowId, onlySelf);
1362 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1363 }
1364
1365 /**
1366 * @tc.name: UpdateFocusWindowWithWindowRemoved01
1367 * @tc.desc: test WindowRoot UpdateFocusWindowWithWindowRemoved01
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(WindowRootTest, UpdateFocusWindowWithWindowRemoved01, Function | SmallTest | Level2)
1371 {
1372 sptr<WindowNode> node = nullptr;
1373 sptr<WindowNodeContainer> container = nullptr;
1374 ASSERT_TRUE((windowRoot_ != nullptr));
1375 windowRoot_->UpdateFocusWindowWithWindowRemoved(node, container);
1376 }
1377
1378 /**
1379 * @tc.name: UpdateFocusWindowWithWindowRemoved02
1380 * @tc.desc: test WindowRoot UpdateFocusWindowWithWindowRemoved02
1381 * @tc.type: FUNC
1382 */
1383 HWTEST_F(WindowRootTest, UpdateFocusWindowWithWindowRemoved02, Function | SmallTest | Level2)
1384 {
1385 sptr<WindowNode> node = new WindowNode();
1386 node->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
1387 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1388 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1389 ASSERT_TRUE((windowRoot_ != nullptr));
1390 windowRoot_->UpdateFocusWindowWithWindowRemoved(node, container);
1391
1392 node->property_->SetWindowId(1);
1393 sptr<WindowNode> node1 = new WindowNode();
1394 node->children_.push_back(node1);
1395 container->SetFocusWindow(1);
1396 ASSERT_TRUE((windowRoot_ != nullptr));
1397 windowRoot_->UpdateFocusWindowWithWindowRemoved(node, container);
1398 }
1399
1400 /**
1401 * @tc.name: UpdateBrightnessWithWindowRemoved
1402 * @tc.desc: test WindowRoot UpdateBrightnessWithWindowRemoved
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(WindowRootTest, UpdateBrightnessWithWindowRemoved, Function | SmallTest | Level2)
1406 {
1407 uint32_t windowId = 1;
1408 sptr<WindowNodeContainer> container;
1409 ASSERT_TRUE((windowRoot_ != nullptr));
1410 windowRoot_->UpdateBrightnessWithWindowRemoved(windowId, container);
1411 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1412 container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1413 container->SetBrightnessWindow(windowId);
1414 ASSERT_TRUE((windowRoot_ != nullptr));
1415 windowRoot_->UpdateBrightnessWithWindowRemoved(windowId, container);
1416 }
1417
1418 /**
1419 * @tc.name: IsVerticalDisplay01
1420 * @tc.desc: test WindowRoot IsVerticalDisplay01
1421 * @tc.type: FUNC
1422 */
1423 HWTEST_F(WindowRootTest, IsVerticalDisplay01, Function | SmallTest | Level2)
1424 {
1425 sptr<WindowNode> node = new WindowNode();
1426 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1427 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1428 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
1429 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1430 DisplayId displayId = displayInfo->GetDisplayId();
1431 std::vector<DisplayId> displayVec = { displayId };
1432 windowRoot_->displayIdMap_.insert(std::make_pair(node->GetDisplayId(), displayVec));
1433 ASSERT_EQ(true, windowRoot_->IsVerticalDisplay(node));
1434 }
1435
1436 /**
1437 * @tc.name: RequestFocus01
1438 * @tc.desc: test WindowRoot RequestFocus01
1439 * @tc.type: FUNC
1440 */
1441 HWTEST_F(WindowRootTest, RequestFocus01, Function | SmallTest | Level2)
1442 {
1443 sptr<WindowNode> windowNode = new WindowNode();
1444 windowNode->currentVisibility_ = true;
1445 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1446 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1447 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1448 windowNode->property_->SetFocusable(true);
1449 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1450 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1451 DisplayId displayId = displayInfo->GetDisplayId();
1452 std::vector<DisplayId> displayVec = { displayId };
1453 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1454 auto ret = windowRoot_->RequestFocus(windowNode->GetWindowId());
1455 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
1456 windowNode->property_->SetFocusable(false);
1457 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1458 ret = windowRoot_->RequestFocus(windowNode->GetWindowId());
1459 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1460 }
1461
1462 /**
1463 * @tc.name: RequestActiveWindow01
1464 * @tc.desc: test WindowRoot RequestActiveWindow01
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(WindowRootTest, RequestActiveWindow01, Function | SmallTest | Level2)
1468 {
1469 sptr<WindowNode> windowNode = new WindowNode();
1470 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
1471 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1472 auto ret = windowRoot_->RequestActiveWindow(windowNode->GetWindowId());
1473 ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE, ret);
1474 }
1475
1476 /**
1477 * @tc.name: RequestActiveWindow02
1478 * @tc.desc: test WindowRoot RequestActiveWindow02
1479 * @tc.type: FUNC
1480 */
1481 HWTEST_F(WindowRootTest, RequestActiveWindow02, Function | SmallTest | Level2)
1482 {
1483 sptr<WindowNode> windowNode = new WindowNode();
1484 windowNode->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1485 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1486 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1487 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1488 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1489 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1490 DisplayId displayId = displayInfo->GetDisplayId();
1491 std::vector<DisplayId> displayVec = { displayId };
1492 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1493 auto ret = windowRoot_->RequestActiveWindow(windowNode->GetWindowId());
1494 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
1495 }
1496
1497 /**
1498 * @tc.name: ProcessWindowStateChange01
1499 * @tc.desc: test WindowRoot ProcessWindowStateChange01
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(WindowRootTest, ProcessWindowStateChange01, Function | SmallTest | Level2)
1503 {
1504 sptr<WindowNode> windowNode = new WindowNode();
1505 WindowState state = WindowState::STATE_INITIAL;
1506 WindowStateChangeReason reason = WindowStateChangeReason::NORMAL;
1507 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1508 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1509 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1510 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1511 DisplayId displayId = displayInfo->GetDisplayId();
1512 std::vector<DisplayId> displayVec = { displayId };
1513 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1514 windowRoot_->ProcessWindowStateChange(state, reason);
1515 ASSERT_EQ(reason, WindowStateChangeReason::NORMAL);
1516 }
1517
1518 /**
1519 * @tc.name: FindWallpaperWindow
1520 * @tc.desc: test WindowRoot FindWallpaperWindow
1521 * @tc.type: FUNC
1522 */
1523 HWTEST_F(WindowRootTest, FindWallpaperWindow, Function | SmallTest | Level2)
1524 {
1525 sptr<WindowNode> windowNode = new WindowNode();
1526 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_WALLPAPER);
1527 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1528 ASSERT_TRUE((windowRoot_ != nullptr));
1529 windowRoot_->FindWallpaperWindow();
1530 }
1531
1532 /**
1533 * @tc.name: RaiseZOrderForAppWindow01
1534 * @tc.desc: test WindowRoot RaiseZOrderForAppWindow01
1535 * @tc.type: FUNC
1536 */
1537 HWTEST_F(WindowRootTest, RaiseZOrderForAppWindow01, Function | SmallTest | Level2)
1538 {
1539 sptr<WindowNode> windowNode = new WindowNode();
1540 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
1541 auto ret = windowRoot_->RaiseZOrderForAppWindow(windowNode);
1542 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1543 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1544 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1545 windowNode->property_->SetFocusable(true);
1546 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1547 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1548 DisplayId displayId = displayInfo->GetDisplayId();
1549 std::vector<DisplayId> displayVec = { displayId };
1550 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1551 ret = windowRoot_->RaiseZOrderForAppWindow(windowNode);
1552 ASSERT_EQ(WMError::WM_OK, ret);
1553 }
1554
1555 /**
1556 * @tc.name: RaiseZOrderForAppWindow02
1557 * @tc.desc: test WindowRoot RaiseZOrderForAppWindow02
1558 * @tc.type: FUNC
1559 */
1560 HWTEST_F(WindowRootTest, RaiseZOrderForAppWindow02, Function | SmallTest | Level2)
1561 {
1562 sptr<WindowNode> windowNode = new WindowNode();
1563 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1564 auto ret = windowRoot_->RaiseZOrderForAppWindow(windowNode);
1565 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1566 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1567 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1568 windowNode->property_->SetFocusable(true);
1569 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1570 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1571 DisplayId displayId = displayInfo->GetDisplayId();
1572 std::vector<DisplayId> displayVec = { displayId };
1573 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1574 ret = windowRoot_->RaiseZOrderForAppWindow(windowNode);
1575 ASSERT_EQ(WMError::WM_OK, ret);
1576 }
1577
1578 /**
1579 * @tc.name: RaiseZOrderForAppWindow03
1580 * @tc.desc: test WindowRoot RaiseZOrderForAppWindow03
1581 * @tc.type: FUNC
1582 */
1583 HWTEST_F(WindowRootTest, RaiseZOrderForAppWindow03, Function | SmallTest | Level2)
1584 {
1585 sptr<WindowNode> windowNode = new WindowNode();
1586 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1587 auto ret = windowRoot_->RaiseZOrderForAppWindow(windowNode);
1588 ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE, ret);
1589 }
1590
1591 /**
1592 * @tc.name: DispatchKeyEvent01
1593 * @tc.desc: test WindowRoot DispatchKeyEvent01
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(WindowRootTest, DispatchKeyEvent01, Function | SmallTest | Level2)
1597 {
1598 sptr<WindowNode> windowNode = new WindowNode();
1599 std::shared_ptr<MMI::KeyEvent> event = nullptr;
1600 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1601 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1602 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1603 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1604 DisplayId displayId = displayInfo->GetDisplayId();
1605 std::vector<DisplayId> displayVec = { displayId };
1606 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1607 ASSERT_TRUE((windowRoot_ != nullptr));
1608 windowRoot_->DispatchKeyEvent(windowNode, event);
1609 }
1610
1611 /**
1612 * @tc.name: GetTopWindowId01
1613 * @tc.desc: test WindowRoot GetTopWindowId01
1614 * @tc.type: FUNC
1615 */
1616 HWTEST_F(WindowRootTest, GetTopWindowId01, Function | SmallTest | Level2)
1617 {
1618 sptr<WindowNode> windowNode1 = new WindowNode();
1619 windowNode1->currentVisibility_ = false;
1620 windowRoot_->SaveWindow(windowNode1);
1621 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode1->GetWindowId(), windowNode1));
1622 sptr<WindowNode> windowNode2 = new WindowNode();
1623 windowNode2->currentVisibility_ = true;
1624 windowRoot_->SaveWindow(windowNode2);
1625 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode2->GetWindowId(), windowNode2));
1626 sptr<WindowNode> windowNode3 = new WindowNode();
1627 windowNode3->currentVisibility_ = true;
1628 windowNode3->children_.push_back(windowNode2);
1629 windowRoot_->SaveWindow(windowNode3);
1630 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode3->GetWindowId(), windowNode3));
1631 uint32_t topWinId = windowNode1->GetWindowId();
1632 auto ret = windowRoot_->GetTopWindowId(windowNode3->GetWindowId(), topWinId);
1633 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1634 ret = windowRoot_->GetTopWindowId(windowNode1->GetWindowId(), topWinId);
1635 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1636 ret = windowRoot_->GetTopWindowId(windowNode2->GetWindowId(), topWinId);
1637 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1638 }
1639
1640 /**
1641 * @tc.name: SetWindowLayoutMode01
1642 * @tc.desc: test WindowRoot SetWindowLayoutMode01
1643 * @tc.type: FUNC
1644 */
1645 HWTEST_F(WindowRootTest, SetWindowLayoutMode01, Function | SmallTest | Level2)
1646 {
1647 WindowLayoutMode mode = WindowLayoutMode::BASE;
1648 sptr<WindowNode> windowNode = new WindowNode();
1649 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1650 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1651 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1652 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1653 DisplayId displayId = displayInfo->GetDisplayId();
1654 std::vector<DisplayId> displayVec = { displayId };
1655 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1656 auto ret = windowRoot_->SetWindowLayoutMode(windowNode->GetDisplayId(), mode);
1657 ASSERT_EQ(WMError::WM_OK, ret);
1658 }
1659
1660 /**
1661 * @tc.name: GetAllDisplayRectsByDMS
1662 * @tc.desc: test WindowRoot GetAllDisplayRectsByDMS
1663 * @tc.type: FUNC
1664 */
1665 HWTEST_F(WindowRootTest, GetAllDisplayRectsByDMS, Function | SmallTest | Level2)
1666 {
1667 ScreenId displayGroupId = 1;
1668 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1669 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1670 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
1671 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1672 DisplayId displayId = displayInfo->GetDisplayId();
1673 std::vector<DisplayId> displayVec = { displayId };
1674 windowRoot_->displayIdMap_.insert(std::make_pair(displayGroupId, displayVec));
1675 ASSERT_TRUE((windowRoot_ != nullptr));
1676 windowRoot_->GetAllDisplayRectsByDMS(displayInfo);
1677 }
1678
1679 /**
1680 * @tc.name: MoveNotShowingWindowToDefaultDisplay01
1681 * @tc.desc: test WindowRoot MoveNotShowingWindowToDefaultDisplay01
1682 * @tc.type: FUNC
1683 */
1684 HWTEST_F(WindowRootTest, MoveNotShowingWindowToDefaultDisplay01, Function | SmallTest | Level2)
1685 {
1686 DisplayId defaultDisplayId = DisplayGroupInfo::GetInstance().GetDefaultDisplayId();
1687 ASSERT_TRUE((windowRoot_ != nullptr));
1688 sptr<WindowNode> node = new WindowNode();
1689 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
1690 sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
1691 node->SetWindowToken(iWindow);
1692 node->currentVisibility_ = false;
1693 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
1694 windowRoot_->MoveNotShowingWindowToDefaultDisplay(defaultDisplayId, node->GetDisplayId());
1695 }
1696
1697 /**
1698 * @tc.name: ProcessDisplayDestroy01
1699 * @tc.desc: test WindowRoot ProcessDisplayDestroy01
1700 * @tc.type: FUNC
1701 */
1702 HWTEST_F(WindowRootTest, ProcessDisplayDestroy01, Function | SmallTest | Level2)
1703 {
1704 sptr<WindowNode> windowNode = new WindowNode();
1705 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1706 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1707 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1708 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1709 DisplayId displayId = displayInfo->GetDisplayId();
1710 std::vector<DisplayId> displayVec = { displayId };
1711 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1712 ASSERT_TRUE((display != nullptr));
1713 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
1714 displayInfoMap.insert(std::make_pair(windowNode->GetDisplayId(), display->GetDisplayInfo()));
1715 ASSERT_TRUE((windowRoot_ != nullptr));
1716 windowRoot_->ProcessDisplayDestroy(windowNode->GetDisplayId(), display->GetDisplayInfo(), displayInfoMap);
1717 }
1718
1719 /**
1720 * @tc.name: GetDisplayGroupRect
1721 * @tc.desc: test WindowRoot GetDisplayGroupRect,HasPrivateWindow,HasMainFullScreenWindowShown
1722 * @tc.type: FUNC
1723 */
1724 HWTEST_F(WindowRootTest, GetDisplayGroupRect01, Function | SmallTest | Level2)
1725 {
1726 sptr<WindowNode> windowNode = new WindowNode();
1727 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1728 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1729 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1730 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1731 DisplayId displayId = displayInfo->GetDisplayId();
1732 std::vector<DisplayId> displayVec = { displayId };
1733 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1734 ASSERT_TRUE((windowRoot_ != nullptr));
1735 windowRoot_->GetDisplayGroupRect(windowNode->GetDisplayId());
1736 ASSERT_TRUE((windowRoot_ != nullptr));
1737 windowRoot_->HasPrivateWindow(windowNode->GetDisplayId());
1738 ASSERT_TRUE((windowRoot_ != nullptr));
1739 windowRoot_->HasMainFullScreenWindowShown(windowNode->GetDisplayId());
1740 }
1741
1742 /**
1743 * @tc.name: UpdateRsTree
1744 * @tc.desc: test WindowRoot UpdateRsTree
1745 * @tc.type: FUNC
1746 */
1747 HWTEST_F(WindowRootTest, UpdateRsTree, Function | SmallTest | Level2)
1748 {
1749 sptr<WindowNode> windowNode = new WindowNode();
1750 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1751 ASSERT_TRUE((windowRoot_ != nullptr));
1752 auto res = windowRoot_->UpdateRsTree(windowNode->GetWindowId(), true);
1753 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res);
1754 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1755 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1756 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(windowNode->GetDisplayId(), container));
1757 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
1758 DisplayId displayId = displayInfo->GetDisplayId();
1759 std::vector<DisplayId> displayVec = { displayId };
1760 windowRoot_->displayIdMap_.insert(std::make_pair(windowNode->GetDisplayId(), displayVec));
1761 res = windowRoot_->UpdateRsTree(windowNode->GetWindowId(), true);
1762 ASSERT_EQ(WMError::WM_OK, res);
1763 }
1764
1765 /**
1766 * @tc.name: CheckMultiDialogWindows
1767 * @tc.desc: test WindowRoot CheckMultiDialogWindows
1768 * @tc.type: FUNC
1769 */
1770 HWTEST_F(WindowRootTest, CheckMultiDialogWindows, Function | SmallTest | Level2)
1771 {
1772 sptr<WindowNode> windowNode = new WindowNode();
1773 windowNode->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1774 windowNode->abilityToken_ = new IRemoteObjectMocker();
1775 auto res = windowRoot_->CheckMultiDialogWindows(WindowType::WINDOW_TYPE_DIALOG, windowNode->abilityToken_);
1776 ASSERT_EQ(false, res);
1777 windowRoot_->windowNodeMap_.insert(std::make_pair(windowNode->GetWindowId(), windowNode));
1778 res = windowRoot_->CheckMultiDialogWindows(WindowType::WINDOW_TYPE_DIALOG, windowNode->abilityToken_);
1779 ASSERT_EQ(false, res);
1780 }
1781
1782
1783 /**
1784 * @tc.name: GetSplitScreenWindowNodes
1785 * @tc.desc: test WindowRoot GetSplitScreenWindowNodes
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(WindowRootTest, GetSplitScreenWindowNodes, Function | SmallTest | Level2)
1789 {
1790 ScreenId displayGroupId = 1;
1791 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1792 ASSERT_TRUE((display != nullptr));
1793 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1794 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
1795 std::vector<sptr<WindowNode>> windowNodes = windowRoot_->GetSplitScreenWindowNodes(DISPLAY_ID_INVALID);
1796 ASSERT_EQ(windowNodes.empty(), true);
1797 windowNodes = windowRoot_->GetSplitScreenWindowNodes(displayGroupId);
1798 ASSERT_EQ(windowNodes.empty(), true);
1799 }
1800
1801 /**
1802 * @tc.name: IsForbidDockSliceMove01
1803 * @tc.desc: test WindowRoot IsForbidDockSliceMove01
1804 * @tc.type: FUNC
1805 */
1806 HWTEST_F(WindowRootTest, IsForbidDockSliceMove01, Function | SmallTest | Level2)
1807 {
1808 ScreenId displayGroupId = 1;
1809 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1810 ASSERT_TRUE((display != nullptr));
1811 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1812 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(displayGroupId, container));
1813 bool ret = windowRoot_->IsForbidDockSliceMove(displayGroupId);
1814 ASSERT_EQ(ret, true);
1815 ret = windowRoot_->IsDockSliceInExitSplitModeArea(displayGroupId);
1816 ASSERT_EQ(ret, false);
1817 windowRoot_->ExitSplitMode(displayGroupId);
1818 }
1819
1820 /**
1821 * @tc.name: GetVisibilityWindowInfo01
1822 * @tc.desc: test WindowRoot GetVisibilityWindowInfo01
1823 * @tc.type: FUNC
1824 */
1825 HWTEST_F(WindowRootTest, GetVisibilityWindowInfo01, Function | SmallTest | Level2)
1826 {
1827 sptr<WindowNode> node = new WindowNode();
1828 windowRoot_->AddSurfaceNodeIdWindowNodePair(node->GetDisplayId(), node);
1829 std::vector<sptr<WindowVisibilityInfo>> infos = {};
1830 windowRoot_->lastVisibleData_.clear();
1831 windowRoot_->lastVisibleData_.emplace_back(node->GetDisplayId(), WINDOW_VISIBILITY_STATE_NO_OCCLUSION);
1832 ASSERT_TRUE((windowRoot_ != nullptr));
1833 windowRoot_->GetVisibilityWindowInfo(infos);
1834 }
1835
1836 /**
1837 * @tc.name: GetUnreliableWindowInfo
1838 * @tc.desc: test WindowRoot GetUnreliableWindowInfo
1839 * @tc.type: FUNC
1840 */
1841 HWTEST_F(WindowRootTest, GetUnreliableWindowInfo, Function | SmallTest | Level2)
1842 {
1843 int32_t windowId = 0;
1844 sptr<WindowNode> windowNode = new WindowNode();
1845 ASSERT_NE(windowNode, nullptr);
1846 windowId = windowNode->GetWindowId();
1847 windowRoot_->windowNodeMap_.insert(std::make_pair(windowId, windowNode));
1848 ASSERT_NE(windowRoot_, nullptr);
1849 std::vector<sptr<UnreliableWindowInfo>> infos;
1850 windowRoot_->GetUnreliableWindowInfo(windowId, infos);
1851 }
1852
1853 /**
1854 * @tc.name: AddWindowNode05
1855 * @tc.desc: test WindowRoot AddWindowNode05
1856 * @tc.type: FUNC
1857 */
1858 HWTEST_F(WindowRootTest, AddWindowNode05, Function | SmallTest | Level2)
1859 {
1860 WMError ret;
1861 sptr<WindowNode> node = new WindowNode();
1862 node->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1863 node->property_->SetWindowModeSupportType(0);
1864
1865 ret = windowRoot_->AddWindowNode(INVALID_WINDOW_ID, node, false);
1866 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_DISPLAY);
1867 }
1868
1869 /**
1870 * @tc.name: UpdateDisplayOrientationWhenHideWindow
1871 * @tc.desc: test WindowRoot UpdateDisplayOrientationWhenHideWindow
1872 * @tc.type: FUNC
1873 */
1874 HWTEST_F(WindowRootTest, UpdateDisplayOrientationWhenHideWindow, Function | SmallTest | Level2)
1875 {
1876 sptr<WindowNode> node = new WindowNode();
1877 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
1878 ASSERT_TRUE((display != nullptr));
1879 sptr<WindowNodeContainer> container = new WindowNodeContainer(display->GetDisplayInfo(), display->GetScreenId());
1880 windowRoot_->windowNodeContainerMap_.insert(std::make_pair(node->GetDisplayId(), container));
1881 ASSERT_TRUE((windowRoot_ != nullptr));
1882 windowRoot_->UpdateDisplayOrientationWhenHideWindow(node);
1883 }
1884 }
1885 }
1886 }
1887