1 /*
2 * Copyright (c) 2024 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 "test/mock/core/pipeline/mock_pipeline_context.h"
18
19 #include "base/memory/referenced.h"
20 #include "core/components_ng/base/frame_node.h"
21 #include "core/components_ng/pattern/stage/page_pattern.h"
22 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
23 #include "frameworks/core/components_ng/manager/safe_area/safe_area_manager.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 namespace OHOS::Ace::NG {
28
29 namespace {
30 constexpr double DISPLAY_WIDTH = 720;
31 constexpr double DISPLAY_HEIGHT = 1280;
32
33 constexpr double SYSTEM_LEFT_START = 0.0f;
34 constexpr double SYSTEM_LEFT_END = 30.0f;
35 constexpr double SYSTEM_RIGHT_START = DISPLAY_WIDTH - 30.0f;
36 constexpr double SYSTEM_RIGHT_END = DISPLAY_WIDTH - 0.0f;
37 constexpr double SYSTEM_TOP_START = 0.0f;
38 constexpr double SYSTEM_TOP_END = 30.0f;
39 constexpr double SYSTEM_BOTTOM_START = DISPLAY_HEIGHT - 30.0f;
40 constexpr double SYSTEM_BOTTOM_END = DISPLAY_HEIGHT - 0.0f;
41
42 constexpr double CUTOUT_LEFT_START = 10.0f;
43 constexpr double CUTOUT_LEFT_END = 40.0f;
44 constexpr double CUTOUT_RIGHT_START = DISPLAY_WIDTH - 40.0f;
45 constexpr double CUTOUT_RIGHT_END = DISPLAY_WIDTH - 10.0f;
46 constexpr double CUTOUT_TOP_START = 20.0f;
47 constexpr double CUTOUT_TOP_END = 50.0f;
48 constexpr double CUTOUT_BOTTOM_START = DISPLAY_HEIGHT - 50.0f;
49 constexpr double CUTOUT_BOTTOM_END = DISPLAY_HEIGHT - 20.0f;
50
51 constexpr double NAV_LEFT_START = 20.0f;
52 constexpr double NAV_LEFT_END = 50.0f;
53 constexpr double NAV_RIGHT_START = DISPLAY_WIDTH - 50.0f;
54 constexpr double NAV_RIGHT_END = DISPLAY_WIDTH - 20.0f;
55 constexpr double NAV_TOP_START = 40.0f;
56 constexpr double NAV_TOP_END = 70.0f;
57 constexpr double NAV_BOTTOM_START = DISPLAY_HEIGHT - 70.0f;
58 constexpr double NAV_BOTTOM_END = DISPLAY_HEIGHT - 40.0f;
59
60 constexpr double KEYBOARD_HEIGHT = 420.0f;
61 } // namespace
62
63 class SafeAreaManagerTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp() override;
68 void TearDown() override;
69
70 struct Rect {
71 float left;
72 float right;
73 float top;
74 float bottom;
75 };
76 void CommonExpectEQ(const Rect& s1, const Rect& s2);
77
78 RefPtr<SafeAreaManager> safeAreaManager_;
79 NG::SafeAreaInsets cutoutArea =
80 NG::SafeAreaInsets({ CUTOUT_LEFT_START, CUTOUT_LEFT_END }, { CUTOUT_TOP_START, CUTOUT_TOP_END },
81 { CUTOUT_RIGHT_START, CUTOUT_RIGHT_END }, { CUTOUT_BOTTOM_START, CUTOUT_BOTTOM_END });
82 NG::SafeAreaInsets systemArea =
83 NG::SafeAreaInsets({ SYSTEM_LEFT_START, SYSTEM_LEFT_END }, { SYSTEM_TOP_START, SYSTEM_TOP_END },
84 { SYSTEM_RIGHT_START, SYSTEM_RIGHT_END }, { SYSTEM_BOTTOM_START, SYSTEM_BOTTOM_END });
85 NG::SafeAreaInsets navArea =
86 NG::SafeAreaInsets({ NAV_LEFT_START, NAV_LEFT_END }, { NAV_TOP_START, NAV_TOP_END },
87 { NAV_RIGHT_START, NAV_RIGHT_END }, { NAV_BOTTOM_START, NAV_BOTTOM_END });
88 NG::SafeAreaInsets cutoutAreaNotValid =
89 NG::SafeAreaInsets({ CUTOUT_LEFT_END, CUTOUT_LEFT_START }, { CUTOUT_TOP_END, CUTOUT_TOP_START },
90 { CUTOUT_RIGHT_END, CUTOUT_RIGHT_START }, { CUTOUT_BOTTOM_END, CUTOUT_BOTTOM_START });
91 NG::SafeAreaInsets systemAreaNotValid =
92 NG::SafeAreaInsets({ SYSTEM_LEFT_END, SYSTEM_LEFT_START }, { SYSTEM_TOP_END, SYSTEM_TOP_START },
93 { SYSTEM_RIGHT_END, SYSTEM_RIGHT_START }, { SYSTEM_BOTTOM_END, SYSTEM_BOTTOM_START });
94 NG::SafeAreaInsets navAreaNotValid =
95 NG::SafeAreaInsets({ NAV_LEFT_END, NAV_LEFT_START }, { NAV_TOP_END, NAV_TOP_START },
96 { NAV_RIGHT_END, NAV_RIGHT_START }, { NAV_BOTTOM_END, NAV_BOTTOM_START });
97 };
98
SetUpTestCase()99 void SafeAreaManagerTest::SetUpTestCase()
100 {
101 MockPipelineContext::SetUp();
102 }
103
TearDownTestCase()104 void SafeAreaManagerTest::TearDownTestCase()
105 {
106 MockPipelineContext::TearDown();
107 }
108
SetUp()109 void SafeAreaManagerTest::SetUp()
110 {
111 safeAreaManager_ = Referenced::MakeRefPtr<SafeAreaManager>();
112 auto pipeline = PipelineContext::GetCurrentContext();
113 CHECK_NULL_VOID(pipeline);
114 pipeline->SetUseCutout(true);
115 }
116
TearDown()117 void SafeAreaManagerTest::TearDown()
118 {
119 safeAreaManager_ = nullptr;
120 }
121
CommonExpectEQ(const Rect & s1,const Rect & s2)122 void SafeAreaManagerTest::CommonExpectEQ(const Rect& s1, const Rect& s2)
123 {
124 EXPECT_EQ(s1.left, s2.left);
125 EXPECT_EQ(s1.right, s2.right);
126 EXPECT_EQ(s1.top, s2.top);
127 EXPECT_EQ(s1.bottom, s2.bottom);
128 }
129
130 /**
131 * @tc.name: IsSafeAreaValidTest
132 * @tc.desc: Use IsSafeAreaValid and test.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(SafeAreaManagerTest, IsSafeAreaValidTest, TestSize.Level1)
136 {
137 EXPECT_EQ(safeAreaManager_->IsIgnoreAsfeArea(), false);
138 EXPECT_EQ(safeAreaManager_->IsFullScreen(), false);
139 EXPECT_EQ(safeAreaManager_->IsNeedAvoidWindow(), false);
140 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
141
142 auto res = safeAreaManager_->GetCutoutSafeArea();
143 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
144 Rect{0.0f, 0.0f, 0.0f, 0.0f});
145 res = safeAreaManager_->GetSafeArea();
146 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
147 Rect{0.0f, 0.0f, 0.0f, 0.0f});
148 res = safeAreaManager_->GetSafeAreaWithoutCutout();
149 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
150 Rect{0.0f, 0.0f, 0.0f, 0.0f});
151 res = safeAreaManager_->GetCombinedSafeArea(SafeAreaExpandOpts());
152 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
153 Rect{0.0f, 0.0f, 0.0f, 0.0f});
154
155 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), true);
156 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), false);
157 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
158 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(false), true);
159
160 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
161 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), false);
162 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
163 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(false), true);
164
165 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
166 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), false);
167 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
168 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(false), true);
169
170 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
171 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
172 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
173
174 EXPECT_EQ(safeAreaManager_->IsAtomicService(), false);
175 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), true);
176 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), false);
177 EXPECT_EQ(safeAreaManager_->IsAtomicService(), true);
178 }
179
180 /**
181 * @tc.name: UpdateCutoutTest
182 * @tc.desc: Use UpdateCutoutSafeArea and test.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(SafeAreaManagerTest, UpdateCutoutTest, TestSize.Level1)
186 {
187 /**
188 * @tc.steps: step1 call UpdateCutoutSafeArea no rootSize params
189 * @tc.expected: cutout regions need to adjacent to edges.
190 */
191 safeAreaManager_->SetIsFullScreen(true);
192 auto ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
193 EXPECT_EQ(ret, true);
194 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
195 EXPECT_EQ(ret, false);
196
197 auto csa = safeAreaManager_->GetCutoutSafeArea();
198 auto sa = safeAreaManager_->GetSafeArea();
199 EXPECT_EQ(csa, sa);
200 CommonExpectEQ(Rect{sa.left_.start, sa.right_.end, sa.top_.start, sa.bottom_.end},
201 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
202 /**
203 * @tc.steps: step2 call UpdateCutoutSafeArea has rootSize params
204 * @tc.expected: cutout regions need to adjacent to edges.
205 */
206 NG::OptionalSize<uint32_t> rootSize;
207 rootSize.SetWidth(DISPLAY_WIDTH-20);
208 rootSize.SetHeight(DISPLAY_HEIGHT-25);
209 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea, rootSize);
210 EXPECT_EQ(ret, true);
211 sa = safeAreaManager_->GetSafeArea();
212 CommonExpectEQ(Rect{sa.left_.start, sa.right_.end, sa.top_.start, sa.bottom_.end},
213 Rect{0.0f, DISPLAY_WIDTH-20, 0.0f, DISPLAY_HEIGHT-25});
214 /**
215 * @tc.steps: step3 call UpdateCutoutSafeArea SafeAreaInsets is not valid params
216 * @tc.expected: cutout regions need to adjacent to edges.
217 */
218 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
219 EXPECT_EQ(ret, true);
220 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
221 EXPECT_EQ(ret, false);
222 }
223
224 /**
225 * @tc.name: UpdateSystemSafeAreaTest
226 * @tc.desc: Use UpdateSystemSafeArea and test.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(SafeAreaManagerTest, UpdateSystemSafeAreaTest, TestSize.Level1)
230 {
231 /**
232 * @tc.steps: call UpdateSystemSafeAreaTest
233 */
234 safeAreaManager_->SetIsFullScreen(true);
235 auto ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
236 EXPECT_EQ(ret, true);
237 ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
238 EXPECT_EQ(ret, false);
239
240 auto ssa = safeAreaManager_->GetSystemSafeArea();
241 EXPECT_EQ(ssa, systemArea);
242
243 auto sas = safeAreaManager_->GetSafeArea();
244 CommonExpectEQ(Rect{sas.left_.start, sas.right_.end, sas.top_.start, sas.bottom_.end},
245 Rect{SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END});
246 }
247
248 /**
249 * @tc.name: UpdateNavAreaTest
250 * @tc.desc: Use UpdateNavArea and test.
251 * @tc.type: FUNC
252 */
253 HWTEST_F(SafeAreaManagerTest, UpdateNavAreaTest, TestSize.Level1)
254 {
255 /**
256 * @tc.steps: call UpdateNavAreaTest
257 */
258 safeAreaManager_->SetIsFullScreen(true);
259 auto ret = safeAreaManager_->UpdateNavArea(navArea);
260 EXPECT_EQ(ret, true);
261 ret = safeAreaManager_->UpdateNavArea(navArea);
262 EXPECT_EQ(ret, false);
263 auto san = safeAreaManager_->GetSafeArea();
264 CommonExpectEQ(Rect{san.left_.start, san.right_.end, san.top_.start, san.bottom_.end},
265 Rect{NAV_LEFT_START, NAV_RIGHT_END, NAV_TOP_START, NAV_BOTTOM_END});
266 }
267
268 /**
269 * @tc.name: UpdateKeyboardSafeAreaTest
270 * @tc.desc: Use UpdateKeyboardSafeArea and test.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(SafeAreaManagerTest, UpdateKeyboardSafeAreaTest, TestSize.Level1)
274 {
275 /**
276 * @tc.steps: step1 call UpdateKeyboardSafeAreaTest systemArea is valid
277 */
278 safeAreaManager_->SetIsFullScreen(true);
279 safeAreaManager_->UpdateSystemSafeArea(systemArea);
280 auto ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
281 EXPECT_EQ(ret, true);
282 ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
283 EXPECT_EQ(ret, false);
284 auto retKbi = safeAreaManager_->GetKeyboardInset();
285 EXPECT_EQ(retKbi.start, systemArea.bottom_.start-KEYBOARD_HEIGHT);
286 EXPECT_EQ(retKbi.end, systemArea.bottom_.start);
287 /**
288 * @tc.steps: step2 call UpdateKeyboardSafeAreaTest systemArea not valid
289 */
290 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
291 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
292 retKbi = safeAreaManager_->GetKeyboardInset();
293 auto tmpBottom = PipelineContext::GetCurrentRootHeight();
294 EXPECT_EQ(retKbi.start, tmpBottom-KEYBOARD_HEIGHT);
295 EXPECT_EQ(retKbi.end, tmpBottom);
296 /**
297 * @tc.steps: step3 call UpdateKeyboardSafeAreaTest systemArea not valid and has rootHeight
298 */
299 uint32_t rootHeight = SYSTEM_BOTTOM_START;
300 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
301 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT, rootHeight);
302 retKbi = safeAreaManager_->GetKeyboardInset();
303 EXPECT_EQ(retKbi.start, rootHeight-KEYBOARD_HEIGHT);
304 EXPECT_EQ(retKbi.end, rootHeight);
305 }
306
307 /**
308 * @tc.name: GetCombinedSafeAreaTest
309 * @tc.desc: Use GetCombinedSafeArea GetSafeAreaWithoutCutout GetSafeAreaWithoutProcess and test.
310 * @tc.type: FUNC
311 */
312 HWTEST_F(SafeAreaManagerTest, GetCombinedSafeAreaTest, TestSize.Level1)
313 {
__anon6027f3d40202(SafeAreaExpandOpts saeo, float l, float r, float t, float b) 314 auto funExPect = [this](SafeAreaExpandOpts saeo, float l, float r, float t, float b) {
315 auto res = safeAreaManager_->GetCombinedSafeArea(saeo);
316 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
317 Rect{l, r, t, b});
318 };
319 safeAreaManager_->SetIsFullScreen(true);
320 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
321 safeAreaManager_->UpdateSystemSafeArea(systemArea);
322 safeAreaManager_->UpdateNavArea(navArea);
323 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
324 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
325 SafeAreaExpandOpts opt;
326 /*@tc.steps: step1 call GetCombinedSafeArea ignore SafeArea*/
327 safeAreaManager_->SetIgnoreSafeArea(true);
328 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
329 /*@tc.steps: step2 call GetCombinedSafeArea opt is null*/
330 safeAreaManager_->SetIgnoreSafeArea(false);
331 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
332 /*@tc.steps: step3 call GetCombinedSafeArea not ignore SafeArea and SAFE_AREA_TYPE_CUTOUT*/
333 opt.type |= SAFE_AREA_TYPE_CUTOUT;
334 funExPect(opt, 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT);
335 /*@tc.steps: step4 call GetCombinedSafeArea not ignore SafeArea and SAFE_AREA_TYPE_SYSTEM*/
336 opt.type |= SAFE_AREA_TYPE_SYSTEM;
337 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
338 /**@tc.steps: step5 call GetCombinedSafeArea not ignore SafeArea and keyboardSafeAreaEnabled_
339 and SAFE_AREA_TYPE_KEYBOARD*/
340 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
341 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
342
343 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
344 opt.type |= SAFE_AREA_TYPE_KEYBOARD;
345 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
346
347 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
348 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
349 /*@tc.steps: step6 call GetSafeAreaWithoutCutout*/
350 auto res = safeAreaManager_->GetSafeAreaWithoutCutout();
351 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
352 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
353 /*@tc.steps: step7 call GetSafeAreaWithoutProcess*/
354 res = safeAreaManager_->GetSafeAreaWithoutProcess();
355 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
356 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
357 }
358
359 /**
360 * @tc.name: KeyboardOffsetTest
361 * @tc.desc: Use UpdateKeyboardOffset GetKeyboardOffset KeyboardSafeAreaEnabled
362 * SetKeyBoardAvoidMode and test.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(SafeAreaManagerTest, KeyboardOffsetTest, TestSize.Level1)
366 {
367 float offset = 20.0f;
368 safeAreaManager_->UpdateKeyboardOffset(offset);
369 /**
370 * @tc.steps: step1 keyboardSafeAreaEnabled_ is true
371 */
372 auto kbam = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
373 EXPECT_EQ(kbam, true);
374 kbam = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
375 EXPECT_EQ(kbam, false);
376 auto ret = safeAreaManager_->KeyboardSafeAreaEnabled();
377 EXPECT_EQ(ret, true);
378 auto kbo = safeAreaManager_->GetKeyboardOffset();
379 EXPECT_EQ(kbo, 0.0f);
380 /**
381 * @tc.steps: step2 keyboardSafeAreaEnabled_ is false
382 */
383 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
384 ret = safeAreaManager_->KeyboardSafeAreaEnabled();
385 EXPECT_EQ(ret, false);
386 kbo = safeAreaManager_->GetKeyboardOffset();
387 EXPECT_EQ(kbo, offset);
388 }
389
390 /**
391 * @tc.name: LastKeyboardPoistionTest
392 * @tc.desc: Use SetLastKeyboardPoistion GetLastKeyboardPoistion and test.
393 * @tc.type: FUNC
394 */
395 HWTEST_F(SafeAreaManagerTest, LastKeyboardPoistionTest, TestSize.Level1)
396 {
397 float lastKeyPos = 10.0f;
398 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
399 safeAreaManager_->SetLastKeyboardPoistion(lastKeyPos);
400 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), lastKeyPos);
401 safeAreaManager_->SetLastKeyboardPoistion(0.0f);
402 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
403 }
404
405 /**
406 * @tc.name: WindowWrapperOffsetTest
407 * @tc.desc: Use GetWindowWrapperOffset and test.
408 * @tc.type: FUNC
409 */
410 HWTEST_F(SafeAreaManagerTest, WindowWrapperOffsetTest, TestSize.Level1)
411 {
__anon6027f3d40302() 412 auto windowModeCallback1 = []() { return WindowMode::WINDOW_MODE_FLOATING; };
__anon6027f3d40402() 413 auto windowModeCallback2 = []() { return WindowMode::WINDOW_MODE_FULLSCREEN; };
414 auto pipeline = PipelineContext::GetCurrentContext();
415 auto manager = pipeline->GetSafeAreaManager();
416 auto windowManager = pipeline->GetWindowManager();
417
418 pipeline->SetWindowModal(WindowModal::NORMAL);
419 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
420 auto ret = manager->GetWindowWrapperOffset();
421 EXPECT_EQ(ret, OffsetF());
422
423 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
424 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
425 ret = manager->GetWindowWrapperOffset();
426 EXPECT_EQ(ret, OffsetF(5.0f, 1.0f));
427
428 pipeline->SetWindowModal(WindowModal::NORMAL);
429 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
430 ret = manager->GetWindowWrapperOffset();
431 EXPECT_EQ(ret, OffsetF());
432
433 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
434 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
435 ret = manager->GetWindowWrapperOffset();
436 EXPECT_EQ(ret, OffsetF());
437 }
438
439 /**
440 * @tc.name: NodesTest
441 * @tc.desc: Use GetGeoRestoreNodes AddGeoRestoreNode RemoveRestoreNode
442 * AddNeedExpandNode ClearNeedExpandNode ExpandSafeArea AddNodeToExpandListIfNeeded and test.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(SafeAreaManagerTest, NodesTest, TestSize.Level1)
446 {
447 safeAreaManager_->ExpandSafeArea();
448 auto frameNode0 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 0,
449 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
450 frameNode0->SetRootNodeId(0);
451 auto pattern0 = frameNode0->GetPattern<PagePattern>();
452 pattern0->CreateOverlayManager(true);
453 auto frameNode1 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1,
454 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
455 frameNode1->SetRootNodeType(RootNodeType::PAGE_ETS_TAG);
456 frameNode1->SetRootNodeId(0);
457 auto frameNode2 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 2,
458 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
459 frameNode2->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
460 frameNode2->SetRootNodeId(0);
461 auto frameNode3 = FrameNode::CreateFrameNode(V2::NAVDESTINATION_VIEW_ETS_TAG, 3,
462 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
463 frameNode3->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
464 frameNode3->SetRootNodeId(0);
465 auto frameNode4 = FrameNode::CreateFrameNode(V2::CHECK_BOX_ETS_TAG, 4,
466 AceType::MakeRefPtr<CheckBoxPattern>());
467 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode0), true);
468 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode1), true);
469 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode2), true);
470 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode3), false);
471 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode4), false);
472
473 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
474 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
475 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
476 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
477 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
478
479 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), false);
480 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), false);
481 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), false);
482 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), false);
483 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), false);
484
485 safeAreaManager_->ExpandSafeArea();
486 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
487 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
488 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
489 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
490 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
491 auto pipeline = PipelineContext::GetCurrentContext();
492 auto manager = pipeline->GetSafeAreaManager();
493 EXPECT_EQ(manager->GetGeoRestoreNodes().size(), 5);
494 }
495 } // namespace OHOS::Ace::NG