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 #include "window_root.h"
18 #include "window_manager.h"
19 #include "display_manager.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23 namespace OHOS {
24 namespace Rosen {
25
26 class WindowRootTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 static sptr<WindowRoot> windowRoot_;
33 };
34
35 sptr<WindowRoot> WindowRootTest::windowRoot_ = nullptr;
36
SetUpTestCase()37 void WindowRootTest::SetUpTestCase()
38 {
39 }
40
TearDownTestCase()41 void WindowRootTest::TearDownTestCase()
42 {
43 }
44
SetUp()45 void WindowRootTest::SetUp()
46 {
47 windowRoot_ = new WindowRoot(nullptr);
48 }
49
TearDown()50 void WindowRootTest::TearDown()
51 {
52 windowRoot_ = nullptr;
53 }
54
55 namespace {
56 /**
57 * @tc.name: WindowRootTest01
58 * @tc.desc: test WindowRoot GetTotalWindowNum
59 * @tc.type: FUNC
60 */
61 HWTEST_F(WindowRootTest, WindowRootTest01, Function | SmallTest | Level2)
62 {
63 uint32_t size = windowRoot_->GetTotalWindowNum();
64 ASSERT_EQ(size, 0);
65 }
66
67 /**
68 * @tc.name: WindowRootTest02
69 * @tc.desc: test WindowRoot GetWindowForDumpAceHelpInfo
70 * @tc.type: FUNC
71 */
72 HWTEST_F(WindowRootTest, WindowRootTest02, Function | SmallTest | Level2)
73 {
74 sptr<WindowProperty> property = new WindowProperty();
75 property->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
76 sptr<WindowNode> windowNode = new WindowNode(property);
77 windowRoot_->SaveWindow(windowNode);
78 sptr<WindowNode> node = windowRoot_->GetWindowForDumpAceHelpInfo();
79 ASSERT_NE(node, nullptr);
80 windowRoot_->DestroyWindowInner(windowNode);
81
82 property = new WindowProperty();
83 property->SetWindowType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
84 windowNode = new WindowNode(property);
85 windowRoot_->SaveWindow(windowNode);
86 node = windowRoot_->GetWindowForDumpAceHelpInfo();
87 ASSERT_NE(node, nullptr);
88 windowRoot_->DestroyWindowInner(windowNode);
89
90 property = new WindowProperty();
91 property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
92 windowNode = new WindowNode(property);
93 windowRoot_->SaveWindow(windowNode);
94 node = windowRoot_->GetWindowForDumpAceHelpInfo();
95 ASSERT_NE(node, nullptr);
96 windowRoot_->DestroyWindowInner(windowNode);
97
98 property = new WindowProperty();
99 property->SetWindowType(WindowType::WINDOW_TYPE_KEYGUARD);
100 windowNode = new WindowNode(property);
101 windowRoot_->SaveWindow(windowNode);
102 node = windowRoot_->GetWindowForDumpAceHelpInfo();
103 ASSERT_NE(node, nullptr);
104 windowRoot_->DestroyWindowInner(windowNode);
105 }
106
107 /**
108 * @tc.name: WindowRootTest03
109 * @tc.desc: test WindowRoot CreateWindowNodeContainer
110 * @tc.type: FUNC
111 */
112 HWTEST_F(WindowRootTest, WindowRootTest03, Function | SmallTest | Level2)
113 {
114 sptr<DisplayInfo> displayInfo = new DisplayInfo();
115
116 displayInfo->SetWidth(49);
117 auto container = windowRoot_->CreateWindowNodeContainer(displayInfo);
118 ASSERT_EQ(container, nullptr);
119
120 displayInfo->SetWidth(7681);
121 container = windowRoot_->CreateWindowNodeContainer(displayInfo);
122 ASSERT_EQ(container, nullptr);
123
124 displayInfo->SetWidth(50);
125 displayInfo->SetHeight(49);
126 container = windowRoot_->CreateWindowNodeContainer(displayInfo);
127 ASSERT_EQ(container, nullptr);
128
129 displayInfo->SetHeight(7681);
130 container = windowRoot_->CreateWindowNodeContainer(displayInfo);
131 ASSERT_EQ(container, nullptr);
132 }
133
134 /**
135 * @tc.name: WindowRootTest04
136 * @tc.desc: test WindowRoot GetWindowNodeContainer
137 * @tc.type: FUNC
138 */
139 HWTEST_F(WindowRootTest, WindowRootTest04, Function | SmallTest | Level2)
140 {
141 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
142 ASSERT_NE(display, nullptr);
143 sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
144 ASSERT_NE(displayInfo, nullptr);
145 displayInfo->SetDisplayId(0);
146 displayInfo->SetScreenGroupId(SCREEN_ID_INVALID);
147 auto container = windowRoot_->CreateWindowNodeContainer(displayInfo);
148 ASSERT_NE(container, nullptr);
149
150 windowRoot_->GetWindowNodeContainer(DISPLAY_ID_INVALID);
151 }
152
153 /**
154 * @tc.name: WindowRootTest05
155 * @tc.desc: test WindowRoot GetBackgroundNodesByScreenId
156 * @tc.type: FUNC
157 */
158 HWTEST_F(WindowRootTest, WindowRootTest05, Function | SmallTest | Level2)
159 {
160 std::vector<sptr<WindowNode>> windowNodes;
161
162 sptr<WindowProperty> property = new WindowProperty();
163 property->SetDisplayId(DISPLAY_ID_INVALID);
164 sptr<WindowNode> windowNode1 = new WindowNode(property);
165 windowRoot_->SaveWindow(windowNode1);
166 property->SetDisplayId(0);
167 sptr<WindowNode> windowNode2 = new WindowNode(property);
168 windowRoot_->SaveWindow(windowNode2);
169
170 auto screenGroupId = DisplayManagerServiceInner::GetInstance().GetScreenGroupIdByDisplayId(DISPLAY_ID_INVALID);
171 windowRoot_->GetBackgroundNodesByScreenId(screenGroupId, windowNodes);
172
173 windowRoot_->DestroyWindowInner(windowNode1);
174 windowRoot_->DestroyWindowInner(windowNode2);
175
176 ASSERT_EQ(true, true);
177 }
178
179 /**
180 * @tc.name: WindowRootTest06
181 * @tc.desc: test WindowRoot AddDeathRecipient
182 * @tc.type: FUNC
183 */
184 HWTEST_F(WindowRootTest, WindowRootTest06, Function | SmallTest | Level2)
185 {
186 windowRoot_->AddDeathRecipient(nullptr);
187
188 ASSERT_EQ(true, true);
189 }
190
191 /**
192 * @tc.name: WindowRootTest07
193 * @tc.desc: test WindowRoot SaveWindow
194 * @tc.type: FUNC
195 */
196 HWTEST_F(WindowRootTest, WindowRootTest07, Function | SmallTest | Level2)
197 {
198 windowRoot_->SaveWindow(nullptr);
199
200 ASSERT_EQ(true, true);
201 }
202
203 /**
204 * @tc.name: WindowRootTest08
205 * @tc.desc: test WindowRoot MinimizeStructuredAppWindowsExceptSelf
206 * @tc.type: FUNC
207 */
208 HWTEST_F(WindowRootTest, WindowRootTest08, Function | SmallTest | Level2)
209 {
210 sptr<WindowProperty> property = new WindowProperty();
211 property->SetDisplayId(DISPLAY_ID_INVALID);
212 sptr<WindowNode> windowNode = new WindowNode(property);
213
214 WMError ret = windowRoot_->MinimizeStructuredAppWindowsExceptSelf(windowNode);
215
216 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
217 }
218
219 /**
220 * @tc.name: WindowRootTest09
221 * @tc.desc: test WindowRoot MinimizeTargetWindows
222 * @tc.type: FUNC
223 */
224 HWTEST_F(WindowRootTest, WindowRootTest09, Function | SmallTest | Level2)
225 {
226 std::vector<uint32_t> windowIds;
227
228 windowRoot_->MinimizeTargetWindows(windowIds);
229
230 windowIds.push_back(INVALID_WINDOW_ID);
231 windowRoot_->MinimizeTargetWindows(windowIds);
232
233 sptr<WindowProperty> property = new WindowProperty();
234 property->SetWindowId(1);
235 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
236 auto windowNode = new WindowNode(property);
237 windowRoot_->SaveWindow(windowNode);
238 property = new WindowProperty();
239 property->SetWindowId(2);
240 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
241 windowNode = new WindowNode(property);
242 windowRoot_->SaveWindow(windowNode);
243 windowIds.push_back(1);
244 windowIds.push_back(2);
245 windowRoot_->MinimizeTargetWindows(windowIds);
246
247 ASSERT_EQ(true, true);
248 }
249
250 /**
251 * @tc.name: WindowRootTest10
252 * @tc.desc: test WindowRoot GetSplitScreenWindowNodes
253 * @tc.type: FUNC
254 */
255 HWTEST_F(WindowRootTest, WindowRootTest10, Function | SmallTest | Level2)
256 {
257 std::vector<sptr<WindowNode>> windowNodes = windowRoot_->GetSplitScreenWindowNodes(DISPLAY_ID_INVALID);
258 ASSERT_EQ(windowNodes.empty(), true);
259 }
260
261 /**
262 * @tc.name: WindowRootTest11
263 * @tc.desc: test WindowRoot IsForbidDockSliceMove
264 * @tc.type: FUNC
265 */
266 HWTEST_F(WindowRootTest, WindowRootTest11, Function | SmallTest | Level2)
267 {
268 bool ret = windowRoot_->IsForbidDockSliceMove(DISPLAY_ID_INVALID);
269 ASSERT_EQ(ret, true);
270
271 ret = windowRoot_->IsForbidDockSliceMove(0);
272 ASSERT_EQ(ret, true);
273 }
274
275 /**
276 * @tc.name: WindowRootTest12
277 * @tc.desc: test WindowRoot IsDockSliceInExitSplitModeArea
278 * @tc.type: FUNC
279 */
280 HWTEST_F(WindowRootTest, WindowRootTest12, Function | SmallTest | Level2)
281 {
282 bool ret = windowRoot_->IsDockSliceInExitSplitModeArea(DISPLAY_ID_INVALID);
283 ASSERT_EQ(ret, false);
284
285 ret = windowRoot_->IsDockSliceInExitSplitModeArea(0);
286 ASSERT_EQ(ret, false);
287 }
288
289 /**
290 * @tc.name: WindowRootTest13
291 * @tc.desc: test WindowRoot ExitSplitMode
292 * @tc.type: FUNC
293 */
294 HWTEST_F(WindowRootTest, WindowRootTest13, Function | SmallTest | Level2)
295 {
296 windowRoot_->ExitSplitMode(DISPLAY_ID_INVALID);
297
298 windowRoot_->ExitSplitMode(0);
299 ASSERT_EQ(true, true);
300 }
301
302 /**
303 * @tc.name: WindowRootTest14
304 * @tc.desc: test WindowRoot AddSurfaceNodeIdWindowNodePair
305 * @tc.type: FUNC
306 */
307 HWTEST_F(WindowRootTest, WindowRootTest14, Function | SmallTest | Level2)
308 {
309 windowRoot_->AddSurfaceNodeIdWindowNodePair(INVALID_WINDOW_ID, nullptr);
310
311 ASSERT_EQ(true, true);
312 }
313
314 /**
315 * @tc.name: WindowRootTest15
316 * @tc.desc: test WindowRoot GetVisibilityWindowInfo
317 * @tc.type: FUNC
318 */
319 HWTEST_F(WindowRootTest, WindowRootTest15, Function | SmallTest | Level2)
320 {
321 std::vector<sptr<WindowVisibilityInfo>> infos = {};
322
323 windowRoot_->GetVisibilityWindowInfo(infos);
324
325 ASSERT_EQ(true, true);
326 }
327
328 /**
329 * @tc.name: WindowRootTest16
330 * @tc.desc: test WindowRoot GetAvoidAreaByType
331 * @tc.type: FUNC
332 */
333 HWTEST_F(WindowRootTest, WindowRootTest16, Function | SmallTest | Level2)
334 {
335 AvoidArea emptyArea;
336 AvoidArea area;
337 sptr<WindowNode> node = new WindowNode();
338
339 area = windowRoot_->GetAvoidAreaByType(node->GetWindowId(), AvoidAreaType::TYPE_CUTOUT);
340 ASSERT_EQ(area, emptyArea);
341
342 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
343 area = windowRoot_->GetAvoidAreaByType(node->GetWindowId(), AvoidAreaType::TYPE_CUTOUT);
344 ASSERT_EQ(area, emptyArea);
345 }
346
347 /**
348 * @tc.name: WindowRootTest17
349 * @tc.desc: test WindowRoot MinimizeAllAppWindows
350 * @tc.type: FUNC
351 */
352 HWTEST_F(WindowRootTest, WindowRootTest17, Function | SmallTest | Level2)
353 {
354 windowRoot_->MinimizeAllAppWindows(DISPLAY_ID_INVALID);
355
356 ASSERT_EQ(true, true);
357 }
358
359 /**
360 * @tc.name: WindowRootTest18
361 * @tc.desc: test WindowRoot DestroyLeakStartingWindow
362 * @tc.type: FUNC
363 */
364 HWTEST_F(WindowRootTest, WindowRootTest18, Function | SmallTest | Level2)
365 {
366 windowRoot_->DestroyLeakStartingWindow();
367
368 ASSERT_EQ(true, true);
369 }
370
371 /**
372 * @tc.name: WindowRootTest19
373 * @tc.desc: test WindowRoot PostProcessAddWindowNode
374 * @tc.type: FUNC
375 */
376 HWTEST_F(WindowRootTest, WindowRootTest19, Function | SmallTest | Level2)
377 {
378 WMError ret;
379 sptr<WindowNode> node = new WindowNode();
380 sptr<WindowNode> parentNode = nullptr;
381 sptr<DisplayInfo> displayInfo = new DisplayInfo();
382 sptr<WindowNodeContainer> container = new WindowNodeContainer(displayInfo, SCREEN_ID_INVALID);
383
384 ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
385 ASSERT_EQ(ret, WMError::WM_DO_NOTHING);
386
387 node->currentVisibility_ = true;
388 node->GetWindowProperty()->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
389 ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
390 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_TYPE);
391
392 node->currentVisibility_ = true;
393 node->property_->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
394 node->GetWindowProperty()->SetFocusable(false);
395 sptr<WindowNode> child = new WindowNode();
396 child->currentVisibility_ = true;
397 node->children_.push_back(child);
398 node->children_.push_back(nullptr);
399 ret = windowRoot_->PostProcessAddWindowNode(node, parentNode, container);
400 ASSERT_EQ(ret, WMError::WM_OK);
401 }
402
403 /**
404 * @tc.name: WindowRootTest20
405 * @tc.desc: test WindowRoot LayoutWhenAddWindowNode
406 * @tc.type: FUNC
407 */
408 HWTEST_F(WindowRootTest, WindowRootTest20, Function | SmallTest | Level2)
409 {
410 sptr<WindowNode> node = nullptr;
411 windowRoot_->LayoutWhenAddWindowNode(node, true);
412
413 node = new WindowNode();
414 windowRoot_->LayoutWhenAddWindowNode(node, true);
415
416 ASSERT_EQ(true, true);
417 }
418
419 /**
420 * @tc.name: WindowRootTest21
421 * @tc.desc: test WindowRoot AddWindowNode
422 * @tc.type: FUNC
423 */
424 HWTEST_F(WindowRootTest, WindowRootTest21, Function | SmallTest | Level2)
425 {
426 WMError ret;
427 sptr<WindowNode> node = nullptr;
428
429 ret = windowRoot_->AddWindowNode(INVALID_WINDOW_ID, node, true);
430 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
431 }
432
433 /**
434 * @tc.name: WindowRootTest22
435 * @tc.desc: test WindowRoot RemoveWindowNode
436 * @tc.type: FUNC
437 */
438 HWTEST_F(WindowRootTest, WindowRootTest22, Function | SmallTest | Level2)
439 {
440 WMError ret;
441 sptr<WindowNode> node = new WindowNode();
442
443 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
444 ret = windowRoot_->RemoveWindowNode(node->GetWindowId(), true);
445 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
446 }
447
448 /**
449 * @tc.name: WindowRootTest23
450 * @tc.desc: test WindowRoot UpdateWindowNode
451 * @tc.type: FUNC
452 */
453 HWTEST_F(WindowRootTest, WindowRootTest23, Function | SmallTest | Level2)
454 {
455 WMError ret;
456
457 ret = windowRoot_->UpdateWindowNode(INVALID_WINDOW_ID, WindowUpdateReason::UPDATE_MODE);
458 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
459
460 sptr<WindowNode> node = new WindowNode();
461 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
462 ret = windowRoot_->UpdateWindowNode(node->GetWindowId(), WindowUpdateReason::UPDATE_MODE);
463 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
464 }
465
466 /**
467 * @tc.name: WindowRootTest24
468 * @tc.desc: test WindowRoot UpdateSizeChangeReason
469 * @tc.type: FUNC
470 */
471 HWTEST_F(WindowRootTest, WindowRootTest24, Function | SmallTest | Level2)
472 {
473 WMError ret;
474
475 ret = windowRoot_->UpdateSizeChangeReason(INVALID_WINDOW_ID, WindowSizeChangeReason::UNDEFINED);
476 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
477
478 sptr<WindowNode> node = new WindowNode();
479 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
480 ret = windowRoot_->UpdateSizeChangeReason(node->GetWindowId(), WindowSizeChangeReason::UNDEFINED);
481 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
482 }
483
484 /**
485 * @tc.name: WindowRootTest25
486 * @tc.desc: test WindowRoot SetBrightness
487 * @tc.type: FUNC
488 */
489 HWTEST_F(WindowRootTest, WindowRootTest25, Function | SmallTest | Level2)
490 {
491 windowRoot_->SetBrightness(INVALID_WINDOW_ID, 0);
492
493 sptr<WindowNode> node = new WindowNode();
494 windowRoot_->windowNodeMap_.insert(std::make_pair(node->GetWindowId(), node));
495 windowRoot_->SetBrightness(node->GetWindowId(), 0);
496
497 ASSERT_EQ(true, true);
498 }
499 }
500 }
501 }
502