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
18 #define protected public
19 #define private public
20
21 #include "test/mock/core/pipeline/mock_pipeline_context.h"
22
23 #include "base/memory/referenced.h"
24 #include "core/components_ng/base/frame_node.h"
25 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
26 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
27 #include "core/components_ng/pattern/stage/page_pattern.h"
28 #include "frameworks/core/components_ng/manager/safe_area/safe_area_manager.h"
29 #include "frameworks/core/components_ng/pattern/navigation/navigation_pattern.h"
30 #include "frameworks/core/components_ng/pattern/navrouter/navdestination_pattern.h"
31 #include "test/mock/core/common/mock_container.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 namespace OHOS::Ace::NG {
36
37 namespace {
38 constexpr double DISPLAY_WIDTH = 720;
39 constexpr double DISPLAY_HEIGHT = 1280;
40
41 constexpr double SYSTEM_LEFT_START = 0.0f;
42 constexpr double SYSTEM_LEFT_END = 30.0f;
43 constexpr double SYSTEM_RIGHT_START = DISPLAY_WIDTH - 30.0f;
44 constexpr double SYSTEM_RIGHT_END = DISPLAY_WIDTH - 0.0f;
45 constexpr double SYSTEM_TOP_START = 0.0f;
46 constexpr double SYSTEM_TOP_END = 30.0f;
47 constexpr double SYSTEM_BOTTOM_START = DISPLAY_HEIGHT - 30.0f;
48 constexpr double SYSTEM_BOTTOM_END = DISPLAY_HEIGHT - 0.0f;
49
50 constexpr double CUTOUT_LEFT_START = 10.0f;
51 constexpr double CUTOUT_LEFT_END = 40.0f;
52 constexpr double CUTOUT_RIGHT_START = DISPLAY_WIDTH - 40.0f;
53 constexpr double CUTOUT_RIGHT_END = DISPLAY_WIDTH - 10.0f;
54 constexpr double CUTOUT_TOP_START = 20.0f;
55 constexpr double CUTOUT_TOP_END = 50.0f;
56 constexpr double CUTOUT_BOTTOM_START = DISPLAY_HEIGHT - 50.0f;
57 constexpr double CUTOUT_BOTTOM_END = DISPLAY_HEIGHT - 20.0f;
58
59 constexpr double CUTOUT_WITH_ROOT_LEFT_START = 0.0f;
60 constexpr double CUTOUT_WITH_ROOT_LEFT_END = CUTOUT_LEFT_END;
61 constexpr double CUTOUT_WITH_ROOT_RIGHT_START = CUTOUT_RIGHT_START;
62 constexpr double CUTOUT_WITH_ROOT_RIGHT_END = DISPLAY_WIDTH;
63 constexpr double CUTOUT_WITH_ROOT_TOP_START = 0.0f;
64 constexpr double CUTOUT_WITH_ROOT_TOP_END = CUTOUT_TOP_END;
65 constexpr double CUTOUT_WITH_ROOT_BOTTOM_START = CUTOUT_BOTTOM_START;
66 constexpr double CUTOUT_WITH_ROOT_BOTTOM_END = DISPLAY_HEIGHT;
67
68 constexpr double NAV_LEFT_START = 20.0f;
69 constexpr double NAV_LEFT_END = 50.0f;
70 constexpr double NAV_RIGHT_START = DISPLAY_WIDTH - 50.0f;
71 constexpr double NAV_RIGHT_END = DISPLAY_WIDTH - 20.0f;
72 constexpr double NAV_TOP_START = 40.0f;
73 constexpr double NAV_TOP_END = 70.0f;
74 constexpr double NAV_BOTTOM_START = DISPLAY_HEIGHT - 70.0f;
75 constexpr double NAV_BOTTOM_END = DISPLAY_HEIGHT - 40.0f;
76
77 constexpr double KEYBOARD_HEIGHT = 420.0f;
78 } // namespace
79
80 class SafeAreaManagerTest : public testing::Test {
81 public:
82 static void SetUpTestCase();
83 static void TearDownTestCase();
84 void SetUp() override;
85 void TearDown() override;
86
87 struct Rect {
88 float left;
89 float right;
90 float top;
91 float bottom;
92 };
93 void CommonExpectEQ(const Rect& s1, const Rect& s2);
94
95 RefPtr<SafeAreaManager> safeAreaManager_;
96 NG::SafeAreaInsets cutoutArea =
97 NG::SafeAreaInsets({ CUTOUT_LEFT_START, CUTOUT_LEFT_END }, { CUTOUT_TOP_START, CUTOUT_TOP_END },
98 { CUTOUT_RIGHT_START, CUTOUT_RIGHT_END }, { CUTOUT_BOTTOM_START, CUTOUT_BOTTOM_END });
99 NG::SafeAreaInsets systemArea =
100 NG::SafeAreaInsets({ SYSTEM_LEFT_START, SYSTEM_LEFT_END }, { SYSTEM_TOP_START, SYSTEM_TOP_END },
101 { SYSTEM_RIGHT_START, SYSTEM_RIGHT_END }, { SYSTEM_BOTTOM_START, SYSTEM_BOTTOM_END });
102 NG::SafeAreaInsets navArea = NG::SafeAreaInsets({ NAV_LEFT_START, NAV_LEFT_END }, { NAV_TOP_START, NAV_TOP_END },
103 { NAV_RIGHT_START, NAV_RIGHT_END }, { NAV_BOTTOM_START, NAV_BOTTOM_END });
104 NG::SafeAreaInsets cutoutAreaNotValid =
105 NG::SafeAreaInsets({ CUTOUT_LEFT_END, CUTOUT_LEFT_START }, { CUTOUT_TOP_END, CUTOUT_TOP_START },
106 { CUTOUT_RIGHT_END, CUTOUT_RIGHT_START }, { CUTOUT_BOTTOM_END, CUTOUT_BOTTOM_START });
107 NG::SafeAreaInsets systemAreaNotValid =
108 NG::SafeAreaInsets({ SYSTEM_LEFT_END, SYSTEM_LEFT_START }, { SYSTEM_TOP_END, SYSTEM_TOP_START },
109 { SYSTEM_RIGHT_END, SYSTEM_RIGHT_START }, { SYSTEM_BOTTOM_END, SYSTEM_BOTTOM_START });
110 NG::SafeAreaInsets navAreaNotValid = NG::SafeAreaInsets({ NAV_LEFT_END, NAV_LEFT_START },
111 { NAV_TOP_END, NAV_TOP_START }, { NAV_RIGHT_END, NAV_RIGHT_START }, { NAV_BOTTOM_END, NAV_BOTTOM_START });
112 NG::SafeAreaInsets cutoutAreaWithRoot =
113 NG::SafeAreaInsets({ CUTOUT_WITH_ROOT_LEFT_START, CUTOUT_WITH_ROOT_LEFT_END }, { CUTOUT_WITH_ROOT_TOP_START,
114 CUTOUT_WITH_ROOT_TOP_END }, { CUTOUT_WITH_ROOT_RIGHT_START, CUTOUT_WITH_ROOT_RIGHT_END },
115 { CUTOUT_WITH_ROOT_BOTTOM_START, CUTOUT_WITH_ROOT_BOTTOM_END });
116 };
117
SetUpTestCase()118 void SafeAreaManagerTest::SetUpTestCase()
119 {
120 MockPipelineContext::SetUp();
121 }
122
TearDownTestCase()123 void SafeAreaManagerTest::TearDownTestCase()
124 {
125 MockPipelineContext::TearDown();
126 }
127
SetUp()128 void SafeAreaManagerTest::SetUp()
129 {
130 safeAreaManager_ = Referenced::MakeRefPtr<SafeAreaManager>();
131 safeAreaManager_->SetUseCutout(true);
132 }
133
TearDown()134 void SafeAreaManagerTest::TearDown()
135 {
136 safeAreaManager_ = nullptr;
137 }
138
CommonExpectEQ(const Rect & s1,const Rect & s2)139 void SafeAreaManagerTest::CommonExpectEQ(const Rect& s1, const Rect& s2)
140 {
141 EXPECT_EQ(s1.left, s2.left);
142 EXPECT_EQ(s1.right, s2.right);
143 EXPECT_EQ(s1.top, s2.top);
144 EXPECT_EQ(s1.bottom, s2.bottom);
145 }
146
147 /**
148 * @tc.name: IsSafeAreaValidTest
149 * @tc.desc: Use IsSafeAreaValid and test.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(SafeAreaManagerTest, IsSafeAreaValidTest, TestSize.Level1)
153 {
154 EXPECT_EQ(safeAreaManager_->IsIgnoreSafeArea(), false);
155 EXPECT_EQ(safeAreaManager_->IsFullScreen(), false);
156 EXPECT_EQ(safeAreaManager_->IsNeedAvoidWindow(), false);
157 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
158
159 auto res = safeAreaManager_->GetCutoutSafeArea();
160 CommonExpectEQ(
161 Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end }, Rect { 0.0f, 0.0f, 0.0f, 0.0f });
162 res = safeAreaManager_->GetSafeArea();
163 CommonExpectEQ(
164 Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end }, Rect { 0.0f, 0.0f, 0.0f, 0.0f });
165 res = safeAreaManager_->GetSafeAreaWithoutCutout();
166 CommonExpectEQ(
167 Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end }, Rect { 0.0f, 0.0f, 0.0f, 0.0f });
168 res = safeAreaManager_->GetCombinedSafeArea(SafeAreaExpandOpts());
169 CommonExpectEQ(
170 Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end }, Rect { 0.0f, 0.0f, 0.0f, 0.0f });
171
172 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), true);
173 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), false);
174 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
175 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(false), true);
176
177 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
178 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), false);
179 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
180 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(false), true);
181
182 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
183 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), false);
184 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
185 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(false), true);
186
187 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
188 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
189 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
190
191 EXPECT_EQ(safeAreaManager_->IsAtomicService(), false);
192 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), true);
193 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), false);
194 EXPECT_EQ(safeAreaManager_->IsAtomicService(), true);
195 }
196
197 /**
198 * @tc.name: CutoutSafeAreaTest
199 * @tc.desc: Use CutoutSafeArea and test.
200 * @tc.type: FUNC
201 */
202 HWTEST_F(SafeAreaManagerTest, CutoutSafeAreaTest, TestSize.Level1)
203 {
204 /**
205 * @tc.steps: step1 call UpdateCutoutSafeArea without rootSize params.
206 * @tc.expected: cutout regions need to adjacent to edges.
207 */
208 safeAreaManager_->SetIsFullScreen(true);
209 auto ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
210 EXPECT_EQ(ret, true);
211 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
212 EXPECT_EQ(ret, false);
213
214 auto cutoutSafeArea = safeAreaManager_->GetCutoutSafeArea();
215 EXPECT_EQ(cutoutSafeArea, cutoutAreaWithRoot);
216 auto safeArea = safeAreaManager_->GetSafeArea();
217 auto safeAreaWithoutProcess = safeAreaManager_->GetSafeAreaWithoutProcess();
218 EXPECT_EQ(safeArea, safeAreaWithoutProcess);
219 EXPECT_EQ(cutoutSafeArea, safeArea);
220
221 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
222 Rect { 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT });
223 /**
224 * @tc.steps: step2 call UpdateCutoutSafeArea with rootSize params.
225 * @tc.expected: cutout regions need to adjacent to edges.
226 */
227 NG::OptionalSize<uint32_t> rootSize;
228 rootSize.SetWidth(DISPLAY_WIDTH - 20);
229 rootSize.SetHeight(DISPLAY_HEIGHT - 25);
230 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea, rootSize);
231 EXPECT_EQ(ret, true);
232 safeArea = safeAreaManager_->GetSafeArea();
233 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
234 Rect { 0.0f, DISPLAY_WIDTH - 20, 0.0f, DISPLAY_HEIGHT - 25 });
235 /**
236 * @tc.steps: step3 call UpdateCutoutSafeArea SafeAreaInsets with invalid params.
237 * @tc.expected: cutout regions need to adjacent to edges.
238 */
239 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
240 EXPECT_EQ(ret, true);
241 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
242 EXPECT_EQ(ret, false);
243 }
244
245 /**
246 * @tc.name: SystemSafeAreaTest
247 * @tc.desc: Use SystemSafeArea and test.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(SafeAreaManagerTest, SystemSafeAreaTest, TestSize.Level1)
251 {
252 /**
253 * @tc.steps: call UpdateSystemSafeAreaTest
254 */
255 safeAreaManager_->SetIsFullScreen(true);
256 auto ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
257 EXPECT_EQ(ret, true);
258 ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
259 EXPECT_EQ(ret, false);
260
261 auto systemSafeArea = safeAreaManager_->GetSystemSafeArea();
262 EXPECT_EQ(systemSafeArea, systemArea);
263
264 auto safeArea = safeAreaManager_->GetSafeArea();
265 auto safeAreaWithoutProcess = safeAreaManager_->GetSafeAreaWithoutProcess();
266 EXPECT_EQ(safeArea, safeAreaWithoutProcess);
267 EXPECT_EQ(systemSafeArea, safeArea);
268
269 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
270 Rect { SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END });
271 }
272
273 /**
274 * @tc.name: NavSafeAreaTest
275 * @tc.desc: Use UpdateNavSafeArea and test.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(SafeAreaManagerTest, NavSafeAreaTest, TestSize.Level1)
279 {
280 /**
281 * @tc.steps: call UpdateNavSafeAreaTest
282 */
283 safeAreaManager_->SetIsFullScreen(true);
284 auto ret = safeAreaManager_->UpdateNavSafeArea(navArea);
285 EXPECT_EQ(ret, true);
286 ret = safeAreaManager_->UpdateNavSafeArea(navArea);
287 EXPECT_EQ(ret, false);
288
289 auto safeArea = safeAreaManager_->GetSafeArea();
290 auto safeAreaWithoutProcess = safeAreaManager_->GetSafeAreaWithoutProcess();
291 EXPECT_EQ(safeArea, safeAreaWithoutProcess);
292
293 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
294 Rect { NAV_LEFT_START, NAV_RIGHT_END, NAV_TOP_START, NAV_BOTTOM_END });
295 }
296
297 /**
298 * @tc.name: UpdateKeyboardSafeAreaTest
299 * @tc.desc: Use UpdateKeyboardSafeArea and test.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(SafeAreaManagerTest, UpdateKeyboardSafeAreaTest, TestSize.Level1)
303 {
304 /**
305 * @tc.steps: step1 call UpdateKeyboardSafeAreaTest with valid systemArea
306 */
307 safeAreaManager_->SetIsFullScreen(true);
308 safeAreaManager_->UpdateSystemSafeArea(systemArea);
309 auto ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
310 EXPECT_EQ(ret, true);
311 ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
312 EXPECT_EQ(ret, false);
313 auto keyboardInset = safeAreaManager_->GetKeyboardInset();
314 EXPECT_EQ(keyboardInset.start, DISPLAY_HEIGHT - KEYBOARD_HEIGHT);
315 EXPECT_EQ(keyboardInset.end, DISPLAY_HEIGHT);
316 /**
317 * @tc.steps: step2 call UpdateKeyboardSafeAreaTest with invalid systemArea
318 */
319 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
320 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
321 keyboardInset = safeAreaManager_->GetKeyboardInset();
322 auto rootHeight = PipelineContext::GetCurrentRootHeight();
323 EXPECT_EQ(keyboardInset.start, rootHeight - KEYBOARD_HEIGHT);
324 EXPECT_EQ(keyboardInset.end, rootHeight);
325 /**
326 * @tc.steps: step3 call UpdateKeyboardSafeAreaTest with rootHeight and invalid systemArea
327 */
328 rootHeight = SYSTEM_BOTTOM_START;
329 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
330 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT, rootHeight);
331 keyboardInset = safeAreaManager_->GetKeyboardInset();
332 EXPECT_EQ(keyboardInset.start, rootHeight - KEYBOARD_HEIGHT);
333 EXPECT_EQ(keyboardInset.end, rootHeight);
334 }
335
336 HWTEST_F(SafeAreaManagerTest, UpdateKeyboardSafeAreaWebTest, TestSize.Level1)
337 {
338 /**
339 * @tc.steps: step1 call UpdateKeyboardWebSafeAreaTest with valid systemArea
340 */
341 MockContainer container(nullptr);
342 safeAreaManager_->SetIsFullScreen(true);
343 safeAreaManager_->UpdateSystemSafeArea(systemArea);
344 auto ret = safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT);
345 EXPECT_EQ(ret, true);
346 ret = safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT);
347 EXPECT_EQ(ret, false);
348 auto keyboardInset = safeAreaManager_->GetKeyboardWebInset();
349 EXPECT_EQ(keyboardInset.start, DISPLAY_HEIGHT - KEYBOARD_HEIGHT);
350 EXPECT_EQ(keyboardInset.end, DISPLAY_HEIGHT);
351 MockContainer::SetUp();
352 safeAreaManager_->SetIsFullScreen(false);
353 safeAreaManager_->UpdateSystemSafeArea(systemArea);
354 ret = safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT);
355 EXPECT_EQ(ret, true);
356 ret = safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT);
357 EXPECT_EQ(ret, false);
358 keyboardInset = safeAreaManager_->GetKeyboardWebInset();
359 EXPECT_EQ(keyboardInset.start, SYSTEM_BOTTOM_START - KEYBOARD_HEIGHT);
360 EXPECT_EQ(keyboardInset.end, SYSTEM_BOTTOM_START);
361 /**
362 * @tc.steps: step2 call UpdateKeyboardSafeAreaTest with invalid systemArea
363 */
364 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
365 safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT);
366 keyboardInset = safeAreaManager_->GetKeyboardWebInset();
367 auto rootHeight = PipelineContext::GetCurrentRootHeight();
368 EXPECT_EQ(keyboardInset.start, rootHeight - KEYBOARD_HEIGHT);
369 EXPECT_EQ(keyboardInset.end, rootHeight);
370 /**
371 * @tc.steps: step3 call UpdateKeyboardSafeAreaTest with rootHeight and invalid systemArea
372 */
373 rootHeight = SYSTEM_BOTTOM_START;
374 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
375 safeAreaManager_->UpdateKeyboardWebSafeArea(KEYBOARD_HEIGHT, rootHeight);
376 keyboardInset = safeAreaManager_->GetKeyboardWebInset();
377 EXPECT_EQ(keyboardInset.start, rootHeight - KEYBOARD_HEIGHT);
378 EXPECT_EQ(keyboardInset.end, rootHeight);
379 MockContainer::TearDown();
380 }
381
382 /**
383 * @tc.name: CheckCutoutSafeAreaTest
384 * @tc.desc: Use CheckCutoutSafeArea and test.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(SafeAreaManagerTest, CheckCutoutSafeAreaTest, TestSize.Level1)
388 {
389 /*
390 * @tc.steps: step1 call CheckCutoutSafeArea with null rootSize params.
391 * @tc.expected: CheckCutoutSafeArea returns false.
392 */
393 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
394 NG::OptionalSize<uint32_t> rootSize;
395 auto ret = safeAreaManager_->CheckCutoutSafeArea(cutoutArea, rootSize);
396 EXPECT_EQ(ret, false);
397
398 /*
399 * @tc.steps: step2 call CheckCutoutSafeArea with wrong rootSize params.
400 * @tc.expected: CheckCutoutSafeArea returns true.
401 */
402 rootSize.SetWidth(1.0f);
403 rootSize.SetHeight(1.0f);
404 ret = safeAreaManager_->CheckCutoutSafeArea(cutoutArea, rootSize);
405 EXPECT_EQ(ret, true);
406
407 /*
408 * @tc.steps: step3 call CheckCutoutSafeArea SafeAreaInsets is not valid params.
409 * @tc.expected: CheckCutoutSafeArea returns false.
410 */
411 safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
412 rootSize.SetWidth(0.0f);
413 rootSize.SetHeight(0.0f);
414 ret = safeAreaManager_->CheckCutoutSafeArea(cutoutAreaNotValid, rootSize);
415 EXPECT_EQ(ret, false);
416 }
417
418 /**
419 * @tc.name: CheckSystemSafeAreaTest
420 * @tc.desc: Use CheckSystemSafeArea and test.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(SafeAreaManagerTest, CheckSystemSafeAreaTest, TestSize.Level1)
424 {
425 safeAreaManager_->UpdateSystemSafeArea(systemArea);
426 auto ret = safeAreaManager_->CheckSystemSafeArea(systemArea);
427 EXPECT_EQ(ret, false);
428
429 ret = safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
430 EXPECT_EQ(ret, true);
431 ret = safeAreaManager_->CheckSystemSafeArea(systemArea);
432 EXPECT_EQ(ret, true);
433 }
434
435 /**
436 * @tc.name: CheckNavSafeAreaTest
437 * @tc.desc: Use CheckNavSafeArea and test.
438 * @tc.type: FUNC
439 */
440 HWTEST_F(SafeAreaManagerTest, CheckNavSafeAreaTest, TestSize.Level1)
441 {
442 safeAreaManager_->UpdateNavSafeArea(navArea);
443 auto ret = safeAreaManager_->CheckNavSafeArea(navArea);
444 EXPECT_EQ(ret, false);
445
446 ret = safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
447 EXPECT_EQ(ret, true);
448 ret = safeAreaManager_->CheckNavSafeArea(cutoutArea);
449 EXPECT_EQ(ret, true);
450 }
451
452 /**
453 * @tc.name: GetCombinedSafeAreaTest
454 * @tc.desc: Use GetCombinedSafeArea GetSafeAreaWithoutCutout GetSafeAreaWithoutProcess and test.
455 * @tc.type: FUNC
456 */
457 HWTEST_F(SafeAreaManagerTest, GetCombinedSafeAreaTest, TestSize.Level1)
458 {
__anonf31f69be0202(SafeAreaExpandOpts options, float left, float right, float top, float bottom) 459 auto funExPect = [this](SafeAreaExpandOpts options, float left, float right, float top, float bottom) {
460 auto res = safeAreaManager_->GetCombinedSafeArea(options);
461 CommonExpectEQ(Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end },
462 Rect { left, right, top, bottom });
463 };
464
465 safeAreaManager_->SetIsFullScreen(true);
466 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
467 safeAreaManager_->UpdateSystemSafeArea(systemArea);
468 safeAreaManager_->UpdateNavSafeArea(navArea);
469 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
470 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
471 SafeAreaExpandOpts opt;
472
473 /*@tc.steps: step1 Ignore SafeArea and call GetCombinedSafeArea*/
474 safeAreaManager_->SetIgnoreSafeArea(true);
475 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
476
477 /*@tc.steps: step2 Set option is null and call GetCombinedSafeArea*/
478 safeAreaManager_->SetIgnoreSafeArea(false);
479 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
480
481 /*@tc.steps: step3 Call GetCombinedSafeArea with invalid SafeArea*/
482 safeAreaManager_->SetIsNeedAvoidWindow(false);
483 safeAreaManager_->SetIsFullScreen(false);
484 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
485 safeAreaManager_->SetIsFullScreen(true);
486
487 /*@tc.steps: step4 SafeArea expand type includes SAFE_AREA_TYPE_CUTOUT*/
488 opt.type |= SAFE_AREA_TYPE_CUTOUT;
489 funExPect(opt, 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT);
490
491 /*@tc.steps: step5 SafeArea expand type includes SAFE_AREA_TYPE_SYSTEM*/
492 opt.type |= SAFE_AREA_TYPE_SYSTEM;
493 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
494
495 /**@tc.steps: step6 SafeArea expand type includes SAFE_AREA_TYPE_KEYBOARD and Set KeyBoardAvoidMode
496 to RESIZE and NONE*/
497 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
498 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
499
500 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::NONE);
501 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
502
503 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
504 opt.type |= SAFE_AREA_TYPE_KEYBOARD;
505 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
506
507 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::NONE);
508 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
509
510 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
511 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
512
513 /*@tc.steps: step7 call GetSafeAreaWithoutCutout*/
514 auto res = safeAreaManager_->GetSafeAreaWithoutCutout();
515 CommonExpectEQ(Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end },
516 Rect { 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT });
517
518 /*@tc.steps: step7 call GetSafeAreaWithoutProcess*/
519 res = safeAreaManager_->GetSafeAreaWithoutProcess();
520 CommonExpectEQ(Rect { res.left_.start, res.right_.end, res.top_.start, res.bottom_.end },
521 Rect { 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT });
522 }
523
524 /**
525 * @tc.name: ScbSystemSafeAreaTest
526 * @tc.desc: Use UpdateScbSystemSafeArea and test.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(SafeAreaManagerTest, ScbSystemSafeAreaTest, TestSize.Level1)
530 {
531 /**
532 * @tc.steps: step1 Call UpdateSystemSafeArea.
533 */
534 auto ret = safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
535 EXPECT_EQ(ret, true);
536 ret = safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
537 EXPECT_EQ(ret, false);
538
539 /**
540 * @tc.steps: step2 Set the window type to SCB window and call GetSystemSafeArea.
541 * @tc.expected: scbSystemSafeArea is null, GetSystemSafeArea returns systemSafeArea instead of scbSystemSafeArea.
542 */
543 safeAreaManager_->SetWindowTypeConfig(false, false, true);
544 auto scbSystemSafeArea = safeAreaManager_->GetSystemSafeArea();
545 EXPECT_EQ(scbSystemSafeArea, systemAreaNotValid);
546
547 /**
548 * @tc.steps: step3 Set the window type to app window and call UpdateScbSystemSafeArea.
549 * @tc.expected: scbSystemSafeArea has value, but GetSystemSafeArea returns systemSafeArea because of appWindow.
550 */
551 safeAreaManager_->SetWindowTypeConfig(true, false, false);
552 ret = safeAreaManager_->UpdateScbSystemSafeArea(systemArea);
553 EXPECT_EQ(ret, true);
554 ret = safeAreaManager_->UpdateScbSystemSafeArea(systemArea);
555 EXPECT_EQ(ret, false);
556 auto systemSafeArea = safeAreaManager_->GetSystemSafeArea();
557 EXPECT_EQ(systemSafeArea, systemAreaNotValid);
558
559 /**
560 * @tc.steps: step2 Set the window type to SCB window and call GetSystemSafeArea.
561 * @tc.expected: scbSystemSafeArea has value and window type is SCB, GetSystemSafeArea returns scbSystemSafeArea.
562 */
563 safeAreaManager_->SetWindowTypeConfig(false, false, true);
564 scbSystemSafeArea = safeAreaManager_->GetSystemSafeArea();
565 EXPECT_EQ(scbSystemSafeArea, systemArea);
566
567 auto safeArea = safeAreaManager_->GetSafeAreaWithoutProcess();
568 EXPECT_EQ(scbSystemSafeArea, safeArea);
569
570 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
571 Rect { SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END });
572 }
573
574 /**
575 * @tc.name: ScbCutoutSafeAreaTest
576 * @tc.desc: Use ScbCutoutSafeArea and test.
577 * @tc.type: FUNC
578 */
579 HWTEST_F(SafeAreaManagerTest, ScbCutoutSafeAreaTest, TestSize.Level1)
580 {
581 /**
582 * @tc.steps: step1 call UpdateScbCutoutSafeArea without rootSize params.
583 * @tc.expected: cutout regions need to adjacent to edges.
584 */
585 safeAreaManager_->SetIsFullScreen(true);
586 auto ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
587 EXPECT_EQ(ret, true);
588 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
589 EXPECT_EQ(ret, false);
590
591 /*@tc.steps: Set the window type to SCB window and call GetCutoutSafeArea.*/
592 safeAreaManager_->SetWindowTypeConfig(false, false, true);
593 auto scbCutoutSafeArea = safeAreaManager_->GetCutoutSafeArea();
594 EXPECT_EQ(scbCutoutSafeArea, cutoutAreaNotValid);
595
596 /*@tc.steps: Set the window type to app window and call UpdateScbCutoutSafeArea.*/
597 safeAreaManager_->SetWindowTypeConfig(true, false, false);
598 ret = safeAreaManager_->UpdateScbCutoutSafeArea(cutoutArea);
599 EXPECT_EQ(ret, true);
600 ret = safeAreaManager_->UpdateScbCutoutSafeArea(cutoutArea);
601 EXPECT_EQ(ret, false);
602 auto cutoutSafeArea = safeAreaManager_->GetCutoutSafeArea();
603 EXPECT_EQ(cutoutSafeArea, cutoutAreaNotValid);
604
605 /*@tc.steps: Set the window type to SCB window and call UpdateScbCutoutSafeArea.*/
606 safeAreaManager_->SetWindowTypeConfig(false, false, true);
607 scbCutoutSafeArea = safeAreaManager_->GetCutoutSafeArea();
608 EXPECT_EQ(scbCutoutSafeArea, cutoutAreaWithRoot);
609
610 auto safeArea = safeAreaManager_->GetSafeAreaWithoutProcess();
611 EXPECT_EQ(scbCutoutSafeArea, safeArea);
612
613 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
614 Rect { 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT });
615
616 /**
617 * @tc.steps: step2 call UpdateScbCutoutSafeArea with rootSize params.
618 * @tc.expected: cutout regions need to adjacent to edges.
619 */
620 NG::OptionalSize<uint32_t> rootSize;
621 rootSize.SetWidth(DISPLAY_WIDTH - 20);
622 rootSize.SetHeight(DISPLAY_HEIGHT - 25);
623 ret = safeAreaManager_->UpdateScbCutoutSafeArea(cutoutArea, rootSize);
624 EXPECT_EQ(ret, true);
625 safeArea = safeAreaManager_->GetSafeAreaWithoutProcess();
626 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
627 Rect { 0.0f, DISPLAY_WIDTH - 20, 0.0f, DISPLAY_HEIGHT - 25 });
628
629 /**
630 * @tc.steps: step3 call UpdateScbCutoutSafeArea SafeAreaInsets with invalid params.
631 * @tc.expected: cutout regions need to adjacent to edges.
632 */
633 ret = safeAreaManager_->UpdateScbCutoutSafeArea(cutoutAreaNotValid);
634 EXPECT_EQ(ret, true);
635 ret = safeAreaManager_->UpdateScbCutoutSafeArea(cutoutAreaNotValid);
636 EXPECT_EQ(ret, false);
637 }
638
639 /**
640 * @tc.name: ScbNavSafeAreaTest
641 * @tc.desc: Use UpdateScbNavSafeArea and test.
642 * @tc.type: FUNC
643 */
644 HWTEST_F(SafeAreaManagerTest, ScbNavSafeAreaTest, TestSize.Level1)
645 {
646 /**
647 * @tc.steps: call UpdateScbNavSafeAreaTest
648 */
649 safeAreaManager_->SetIsFullScreen(true);
650 auto ret = safeAreaManager_->UpdateScbNavSafeArea(navArea);
651 EXPECT_EQ(ret, true);
652 ret = safeAreaManager_->UpdateScbNavSafeArea(navArea);
653 EXPECT_EQ(ret, false);
654
655 safeAreaManager_->SetWindowTypeConfig(false, false, true);
656 auto safeArea = safeAreaManager_->GetSafeAreaWithoutProcess();
657 CommonExpectEQ(Rect { safeArea.left_.start, safeArea.right_.end, safeArea.top_.start, safeArea.bottom_.end },
658 Rect { NAV_LEFT_START, NAV_RIGHT_END, NAV_TOP_START, NAV_BOTTOM_END });
659 }
660
661 /**
662 * @tc.name: KeyboardOffsetTest1
663 * @tc.desc: Set KeyBoardAvoidMode to KeyBoardAvoidMode::OFFSET And see if GetKeyboardOffset get right result
664 * @tc.type: FUNC
665 */
666 HWTEST_F(SafeAreaManagerTest, KeyboardOffsetTest1, TestSize.Level1)
667 {
668 float offset = 100.0f;
669 safeAreaManager_->UpdateKeyboardOffset(offset);
670 /**
671 * @tc.steps: SetKeyBoardAvoidMode OFFSET
672 */
673 auto ret = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
674 EXPECT_EQ(ret, false);
675 auto keyboardAvoidMode = safeAreaManager_->GetKeyBoardAvoidMode();
676 ret = keyboardAvoidMode == KeyBoardAvoidMode::OFFSET;
677 EXPECT_EQ(ret, true);
678
679 auto keyboardOffset = safeAreaManager_->GetKeyboardOffset();
680 EXPECT_EQ(keyboardOffset, offset);
681 keyboardOffset = safeAreaManager_->GetKeyboardOffset(true);
682 EXPECT_EQ(keyboardOffset, offset);
683 }
684
685 /**
686 * @tc.name: KeyboardOffsetTest2
687 * @tc.desc: Set KeyBoardAvoidMode to KeyBoardAvoidMode::RESIZE And see if GetKeyboardOffset get right result
688 * @tc.type: FUNC
689 */
690 HWTEST_F(SafeAreaManagerTest, KeyboardOffsetTest2, TestSize.Level1)
691 {
692 float offset = 100.0f;
693 safeAreaManager_->UpdateKeyboardOffset(offset);
694 /**
695 * @tc.steps: SetKeyBoardAvoidMode OFFSET
696 */
697 auto ret = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
698 EXPECT_EQ(ret, true);
699 auto keyboardAvoidMode = safeAreaManager_->GetKeyBoardAvoidMode();
700 ret = keyboardAvoidMode == KeyBoardAvoidMode::RESIZE;
701 EXPECT_EQ(ret, true);
702
703 auto keyboardOffset = safeAreaManager_->GetKeyboardOffset();
704 EXPECT_EQ(keyboardOffset, 0.0f);
705 keyboardOffset = safeAreaManager_->GetKeyboardOffset(true);
706 EXPECT_EQ(keyboardOffset, offset);
707 }
708
709 /**
710 * @tc.name: KeyboardOffsetTest3
711 * @tc.desc: Set KeyBoardAvoidMode to KeyBoardAvoidMode::NONE And see if GetKeyboardOffset get right result
712 * @tc.type: FUNC
713 */
714 HWTEST_F(SafeAreaManagerTest, KeyboardOffsetTest3, TestSize.Level1)
715 {
716 float offset = 100.0f;
717 safeAreaManager_->UpdateKeyboardOffset(offset);
718 /**
719 * @tc.steps: SetKeyBoardAvoidMode OFFSET
720 */
721 auto ret = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::NONE);
722 EXPECT_EQ(ret, true);
723 auto keyboardAvoidMode = safeAreaManager_->GetKeyBoardAvoidMode();
724 ret = keyboardAvoidMode == KeyBoardAvoidMode::NONE;
725 EXPECT_EQ(ret, true);
726
727 auto keyboardOffset = safeAreaManager_->GetKeyboardOffset();
728 EXPECT_EQ(keyboardOffset, 0.0f);
729 keyboardOffset = safeAreaManager_->GetKeyboardOffset(true);
730 EXPECT_EQ(keyboardOffset, 0.0f);
731 }
732
733 /**
734 * @tc.name: CaretAvoidModeTest001
735 * @tc.desc: Set KeyBoardAvoidMode to KeyBoardAvoidMode::RESIZE_WITH_CARET
736 And see if GetKeyboardOffset get right result
737 * @tc.type: FUNC
738 */
739 HWTEST_F(SafeAreaManagerTest, CaretAvoidModeTest001, TestSize.Level1)
740 {
741 float offset = 100.0f;
742 safeAreaManager_->UpdateKeyboardOffset(offset);
743 /**
744 * @tc.steps: step1 SetKeyBoardAvoidMode RESIZE_WITH_CARET
745 */
746 auto ret = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET_WITH_CARET);
747 EXPECT_EQ(ret, true);
748 auto keyboardAvoidMode = safeAreaManager_->GetKeyBoardAvoidMode();
749 ret = keyboardAvoidMode == KeyBoardAvoidMode::OFFSET_WITH_CARET;
750 EXPECT_EQ(ret, true);
751
752 auto keyboardOffset = safeAreaManager_->GetKeyboardOffset();
753 EXPECT_EQ(keyboardOffset, offset);
754 keyboardOffset = safeAreaManager_->GetKeyboardOffset(true);
755 EXPECT_EQ(keyboardOffset, offset);
756 }
757
758 /**
759 * @tc.name: CaretAvoidModeTest002
760 * @tc.desc: Set KeyBoardAvoidMode to KeyBoardAvoidMode::RESIZE_WITH_CARET
761 And see if GetKeyboardOffset get right result
762 * @tc.type: FUNC
763 */
764 HWTEST_F(SafeAreaManagerTest, CaretAvoidModeTest002, TestSize.Level1)
765 {
766 float offset = 100.0f;
767 safeAreaManager_->UpdateKeyboardOffset(offset);
768 /**
769 * @tc.steps: step1 SetKeyBoardAvoidMode RESIZE_WITH_CARET
770 */
771 auto ret = safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE_WITH_CARET);
772 EXPECT_EQ(ret, true);
773 auto keyboardAvoidMode = safeAreaManager_->GetKeyBoardAvoidMode();
774 ret = keyboardAvoidMode == KeyBoardAvoidMode::RESIZE_WITH_CARET;
775 EXPECT_EQ(ret, true);
776
777 auto keyboardOffset = safeAreaManager_->GetKeyboardOffset();
778 EXPECT_EQ(keyboardOffset, 0.0f);
779 keyboardOffset = safeAreaManager_->GetKeyboardOffset(true);
780 EXPECT_EQ(keyboardOffset, offset);
781 }
782
783 /**
784 * @tc.name: LastKeyboardPoistionTest
785 * @tc.desc: Use SetLastKeyboardPoistion GetLastKeyboardPoistion and test.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(SafeAreaManagerTest, LastKeyboardPoistionTest, TestSize.Level1)
789 {
790 float lastKeyPos = 10.0f;
791 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
792 safeAreaManager_->SetLastKeyboardPoistion(lastKeyPos);
793 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), lastKeyPos);
794 safeAreaManager_->SetLastKeyboardPoistion(0.0f);
795 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
796 }
797
798 /**
799 * @tc.name: WindowWrapperOffsetTest
800 * @tc.desc: Use GetWindowWrapperOffset and test.
801 * @tc.type: FUNC
802 */
803 HWTEST_F(SafeAreaManagerTest, WindowWrapperOffsetTest, TestSize.Level1)
804 {
__anonf31f69be0302() 805 auto windowModeCallback1 = []() { return WindowMode::WINDOW_MODE_FLOATING; };
__anonf31f69be0402() 806 auto windowModeCallback2 = []() { return WindowMode::WINDOW_MODE_FULLSCREEN; };
807 auto pipeline = PipelineContext::GetCurrentContext();
808 auto manager = pipeline->GetSafeAreaManager();
809 auto windowManager = pipeline->GetWindowManager();
810
811 pipeline->SetWindowModal(WindowModal::NORMAL);
812 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
813 auto ret = manager->GetWindowWrapperOffset();
814 EXPECT_EQ(ret, OffsetF());
815
816 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
817 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
818 ret = manager->GetWindowWrapperOffset();
819 EXPECT_EQ(ret, OffsetF(4.0f, 0.0f));
820
821 pipeline->SetWindowModal(WindowModal::NORMAL);
822 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
823 ret = manager->GetWindowWrapperOffset();
824 EXPECT_EQ(ret, OffsetF());
825
826 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
827 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
828 ret = manager->GetWindowWrapperOffset();
829 EXPECT_EQ(ret, OffsetF());
830 }
831
832 /**
833 * @tc.name: NodesTest
834 * @tc.desc: Use GetGeoRestoreNodes AddGeoRestoreNode RemoveRestoreNode
835 * AddNeedExpandNode ClearNeedExpandNode ExpandSafeArea AddNodeToExpandListIfNeeded and test.
836 * @tc.type: FUNC
837 */
838 HWTEST_F(SafeAreaManagerTest, NodesTest, TestSize.Level1)
839 {
840 safeAreaManager_->ExpandSafeArea();
841 auto frameNode0 = FrameNode::CreateFrameNode(
842 V2::PAGE_ETS_TAG, 0, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
843 frameNode0->SetRootNodeId(0);
844 auto pattern0 = frameNode0->GetPattern<PagePattern>();
845 pattern0->CreateOverlayManager(true);
846 auto frameNode1 = FrameNode::CreateFrameNode(
847 V2::PAGE_ETS_TAG, 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
848 frameNode1->SetRootNodeType(RootNodeType::PAGE_ETS_TAG);
849 frameNode1->SetRootNodeId(0);
850 auto frameNode2 = FrameNode::CreateFrameNode(
851 V2::PAGE_ETS_TAG, 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
852 frameNode2->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
853 frameNode2->SetRootNodeId(0);
854 auto frameNode3 = FrameNode::CreateFrameNode(
855 V2::NAVDESTINATION_VIEW_ETS_TAG, 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
856 frameNode3->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
857 frameNode3->SetRootNodeId(0);
858 auto frameNode4 = FrameNode::CreateFrameNode(V2::CHECK_BOX_ETS_TAG, 4, AceType::MakeRefPtr<CheckBoxPattern>());
859 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode0), true);
860 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode1), true);
861 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode2), true);
862 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode3), false);
863 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode4), false);
864
865 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
866 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
867 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
868 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
869 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
870
871 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), false);
872 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), false);
873 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), false);
874 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), false);
875 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), false);
876
877 safeAreaManager_->ExpandSafeArea();
878 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
879 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
880 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
881 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
882 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
883 auto pipeline = PipelineContext::GetCurrentContext();
884 auto manager = pipeline->GetSafeAreaManager();
885 EXPECT_EQ(manager->GetGeoRestoreNodes().size(), 5);
886 }
887
888 /**
889 * @tc.name: SafeAreaToPaddingTest1
890 * @tc.desc: Test SafeAreaToPadding with default parameter false.
891 * @tc.type: FUNC
892 */
893 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest1, TestSize.Level1)
894 {
895 /**
896 * @tc.steps: Call SafeAreaToPadding with different ignoreSafeArea_, isFullScreen_, isNeedAvoidWindow_.
897 * @tc.expected: SafeAreaToPadding returns empty.
898 */
899 safeAreaManager_->SetIgnoreSafeArea(true);
900 safeAreaManager_->SetIsFullScreen(true);
901 safeAreaManager_->SetIsNeedAvoidWindow(true);
902 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding();
903 EXPECT_EQ(paddingProperty.Empty(), true);
904
905 safeAreaManager_->SetIgnoreSafeArea(true);
906 safeAreaManager_->SetIsFullScreen(false);
907 safeAreaManager_->SetIsNeedAvoidWindow(true);
908 paddingProperty = safeAreaManager_->SafeAreaToPadding();
909 EXPECT_EQ(paddingProperty.Empty(), true);
910
911 safeAreaManager_->SetIgnoreSafeArea(true);
912 safeAreaManager_->SetIsFullScreen(true);
913 safeAreaManager_->SetIsNeedAvoidWindow(false);
914 paddingProperty = safeAreaManager_->SafeAreaToPadding();
915 EXPECT_EQ(paddingProperty.Empty(), true);
916
917 safeAreaManager_->SetIgnoreSafeArea(true);
918 safeAreaManager_->SetIsFullScreen(false);
919 safeAreaManager_->SetIsNeedAvoidWindow(false);
920 paddingProperty = safeAreaManager_->SafeAreaToPadding();
921 EXPECT_EQ(paddingProperty.Empty(), true);
922
923 safeAreaManager_->SetIgnoreSafeArea(false);
924 safeAreaManager_->SetIsFullScreen(false);
925 safeAreaManager_->SetIsNeedAvoidWindow(false);
926 paddingProperty = safeAreaManager_->SafeAreaToPadding();
927 EXPECT_EQ(paddingProperty.Empty(), true);
928 }
929
930 /**
931 * @tc.name: SafeAreaToPaddingTest2
932 * @tc.desc: Test SafeAreaToPadding with default parameter false.
933 * @tc.type: FUNC
934 */
935 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest2, TestSize.Level1)
936 {
937 /**
938 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
939 * valid safeAreaInsets before calling SafeAreaToPadding.
940 * @tc.expected: SafeAreaToPadding returns empty or non-empty.
941 */
942 safeAreaManager_->UpdateSystemSafeArea(systemArea);
943 safeAreaManager_->UpdateNavSafeArea(navArea);
944 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
945
946 safeAreaManager_->SetIgnoreSafeArea(false);
947 safeAreaManager_->SetIsFullScreen(true);
948 safeAreaManager_->SetIsNeedAvoidWindow(false);
949 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding();
950
951 EXPECT_EQ(paddingProperty.left, NAV_LEFT_END - SYSTEM_LEFT_START);
952 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - NAV_RIGHT_START);
953 EXPECT_EQ(paddingProperty.top, NAV_TOP_END - SYSTEM_TOP_START);
954 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - NAV_BOTTOM_START);
955
956 safeAreaManager_->SetIgnoreSafeArea(false);
957 safeAreaManager_->SetIsFullScreen(false);
958 safeAreaManager_->SetIsNeedAvoidWindow(true);
959 paddingProperty = safeAreaManager_->SafeAreaToPadding();
960
961 EXPECT_EQ(paddingProperty.left, NAV_LEFT_END - SYSTEM_LEFT_START);
962 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - NAV_RIGHT_START);
963 EXPECT_EQ(paddingProperty.top, NAV_TOP_END - SYSTEM_TOP_START);
964 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - NAV_BOTTOM_START);
965
966 safeAreaManager_->SetIgnoreSafeArea(false);
967 safeAreaManager_->SetIsFullScreen(false);
968 safeAreaManager_->SetIsNeedAvoidWindow(false);
969 paddingProperty = safeAreaManager_->SafeAreaToPadding();
970 EXPECT_EQ(paddingProperty.Empty(), true);
971
972 safeAreaManager_->SetIgnoreSafeArea(true);
973 safeAreaManager_->SetIsFullScreen(false);
974 safeAreaManager_->SetIsNeedAvoidWindow(false);
975 paddingProperty = safeAreaManager_->SafeAreaToPadding();
976 EXPECT_EQ(paddingProperty.Empty(), true);
977
978 safeAreaManager_->SetIgnoreSafeArea(true);
979 safeAreaManager_->SetIsFullScreen(true);
980 safeAreaManager_->SetIsNeedAvoidWindow(false);
981 paddingProperty = safeAreaManager_->SafeAreaToPadding();
982 EXPECT_EQ(paddingProperty.Empty(), true);
983
984 safeAreaManager_->SetIgnoreSafeArea(true);
985 safeAreaManager_->SetIsFullScreen(false);
986 safeAreaManager_->SetIsNeedAvoidWindow(true);
987 paddingProperty = safeAreaManager_->SafeAreaToPadding();
988 EXPECT_EQ(paddingProperty.Empty(), true);
989 }
990
991 /**
992 * @tc.name: SafeAreaToPaddingTest3
993 * @tc.desc: Test SafeAreaToPadding with default parameter false.
994 * @tc.type: FUNC
995 */
996 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest3, TestSize.Level1)
997 {
998 /**
999 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1000 * not valid safeAreaInsets before calling SafeAreaToPadding.
1001 * @tc.expected: SafeAreaToPadding returns empty or non-empty.
1002 */
1003 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
1004 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1005 safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
1006 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding();
1007 EXPECT_EQ(paddingProperty.Empty(), true);
1008
1009 safeAreaManager_->SetIgnoreSafeArea(false);
1010 safeAreaManager_->SetIsFullScreen(true);
1011 safeAreaManager_->SetIsNeedAvoidWindow(true);
1012 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1013 EXPECT_EQ(paddingProperty.Empty(), true);
1014
1015 safeAreaManager_->SetIgnoreSafeArea(false);
1016 safeAreaManager_->SetIsFullScreen(true);
1017 safeAreaManager_->SetIsNeedAvoidWindow(false);
1018 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1019 EXPECT_EQ(paddingProperty.Empty(), true);
1020
1021 safeAreaManager_->SetIgnoreSafeArea(false);
1022 safeAreaManager_->SetIsFullScreen(false);
1023 safeAreaManager_->SetIsNeedAvoidWindow(true);
1024 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1025 EXPECT_EQ(paddingProperty.Empty(), true);
1026
1027 safeAreaManager_->SetIgnoreSafeArea(false);
1028 safeAreaManager_->SetIsFullScreen(false);
1029 safeAreaManager_->SetIsNeedAvoidWindow(false);
1030 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1031 EXPECT_EQ(paddingProperty.Empty(), true);
1032
1033 safeAreaManager_->SetIgnoreSafeArea(true);
1034 safeAreaManager_->SetIsFullScreen(false);
1035 safeAreaManager_->SetIsNeedAvoidWindow(false);
1036 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1037 EXPECT_EQ(paddingProperty.Empty(), true);
1038
1039 safeAreaManager_->SetIgnoreSafeArea(true);
1040 safeAreaManager_->SetIsFullScreen(true);
1041 safeAreaManager_->SetIsNeedAvoidWindow(false);
1042 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1043 EXPECT_EQ(paddingProperty.Empty(), true);
1044
1045 safeAreaManager_->SetIgnoreSafeArea(true);
1046 safeAreaManager_->SetIsFullScreen(false);
1047 safeAreaManager_->SetIsNeedAvoidWindow(true);
1048 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1049 EXPECT_EQ(paddingProperty.Empty(), true);
1050 }
1051
1052 /**
1053 * @tc.name: SafeAreaToPaddingTest4
1054 * @tc.desc: Test SafeAreaToPadding with default parameter false.
1055 * @tc.type: FUNC
1056 */
1057 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest4, TestSize.Level1)
1058 {
1059 /**
1060 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1061 * valid systemArea and not valid navArea cutoutArea before calling SafeAreaToPadding.
1062 * @tc.expected: SafeAreaToPadding returns empty or non-empty.
1063 */
1064 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1065 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1066 safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
1067
1068 safeAreaManager_->SetIgnoreSafeArea(false);
1069 safeAreaManager_->SetIsFullScreen(true);
1070 safeAreaManager_->SetIsNeedAvoidWindow(false);
1071 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding();
1072
1073 EXPECT_EQ(paddingProperty.left, SYSTEM_LEFT_END - SYSTEM_LEFT_START);
1074 EXPECT_EQ(paddingProperty.right, SYSTEM_TOP_END - SYSTEM_TOP_START);
1075 EXPECT_EQ(paddingProperty.top, SYSTEM_RIGHT_END - SYSTEM_RIGHT_START);
1076 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - SYSTEM_BOTTOM_START);
1077
1078 safeAreaManager_->SetIgnoreSafeArea(false);
1079 safeAreaManager_->SetIsFullScreen(false);
1080 safeAreaManager_->SetIsNeedAvoidWindow(true);
1081 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1082
1083 EXPECT_EQ(paddingProperty.left, SYSTEM_LEFT_END - SYSTEM_LEFT_START);
1084 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - SYSTEM_RIGHT_START);
1085 EXPECT_EQ(paddingProperty.top, SYSTEM_TOP_END - SYSTEM_TOP_START);
1086 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - SYSTEM_BOTTOM_START);
1087
1088 safeAreaManager_->SetIgnoreSafeArea(false);
1089 safeAreaManager_->SetIsFullScreen(false);
1090 safeAreaManager_->SetIsNeedAvoidWindow(false);
1091 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1092 EXPECT_EQ(paddingProperty.Empty(), true);
1093
1094 safeAreaManager_->SetIgnoreSafeArea(true);
1095 safeAreaManager_->SetIsFullScreen(false);
1096 safeAreaManager_->SetIsNeedAvoidWindow(false);
1097 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1098 EXPECT_EQ(paddingProperty.Empty(), true);
1099
1100 safeAreaManager_->SetIgnoreSafeArea(true);
1101 safeAreaManager_->SetIsFullScreen(true);
1102 safeAreaManager_->SetIsNeedAvoidWindow(false);
1103 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1104 EXPECT_EQ(paddingProperty.Empty(), true);
1105
1106 safeAreaManager_->SetIgnoreSafeArea(true);
1107 safeAreaManager_->SetIsFullScreen(false);
1108 safeAreaManager_->SetIsNeedAvoidWindow(true);
1109 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1110 EXPECT_EQ(paddingProperty.Empty(), true);
1111 }
1112
1113 /**
1114 * @tc.name: SafeAreaToPaddingTest5
1115 * @tc.desc: Test SafeAreaToPadding with default parameter false.
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest5, TestSize.Level1)
1119 {
1120 /**
1121 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1122 * valid systemArea and cutoutArea and not valid navArea before calling SafeAreaToPadding.
1123 * @tc.expected: SafeAreaToPadding returns empty or non-empty.
1124 */
1125 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1126 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1127 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
1128
1129 safeAreaManager_->SetIgnoreSafeArea(false);
1130 safeAreaManager_->SetIsFullScreen(true);
1131 safeAreaManager_->SetIsNeedAvoidWindow(false);
1132 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding();
1133
1134 EXPECT_EQ(paddingProperty.left, CUTOUT_LEFT_END - SYSTEM_LEFT_START);
1135 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - CUTOUT_RIGHT_START);
1136 EXPECT_EQ(paddingProperty.top, CUTOUT_TOP_END - SYSTEM_TOP_START);
1137 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - CUTOUT_BOTTOM_START);
1138
1139 safeAreaManager_->SetIgnoreSafeArea(false);
1140 safeAreaManager_->SetIsFullScreen(false);
1141 safeAreaManager_->SetIsNeedAvoidWindow(true);
1142 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1143
1144 EXPECT_EQ(paddingProperty.left, CUTOUT_LEFT_END - SYSTEM_LEFT_START);
1145 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - CUTOUT_RIGHT_START);
1146 EXPECT_EQ(paddingProperty.top, CUTOUT_TOP_END - SYSTEM_TOP_START);
1147 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - CUTOUT_BOTTOM_START);
1148
1149 safeAreaManager_->SetIgnoreSafeArea(false);
1150 safeAreaManager_->SetIsFullScreen(false);
1151 safeAreaManager_->SetIsNeedAvoidWindow(false);
1152 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1153 EXPECT_EQ(paddingProperty.Empty(), true);
1154
1155 safeAreaManager_->SetIgnoreSafeArea(true);
1156 safeAreaManager_->SetIsFullScreen(false);
1157 safeAreaManager_->SetIsNeedAvoidWindow(false);
1158 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1159 EXPECT_EQ(paddingProperty.Empty(), true);
1160
1161 safeAreaManager_->SetIgnoreSafeArea(true);
1162 safeAreaManager_->SetIsFullScreen(true);
1163 safeAreaManager_->SetIsNeedAvoidWindow(false);
1164 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1165 EXPECT_EQ(paddingProperty.Empty(), true);
1166
1167 safeAreaManager_->SetIgnoreSafeArea(true);
1168 safeAreaManager_->SetIsFullScreen(false);
1169 safeAreaManager_->SetIsNeedAvoidWindow(true);
1170 paddingProperty = safeAreaManager_->SafeAreaToPadding();
1171 EXPECT_EQ(paddingProperty.Empty(), true);
1172 }
1173
1174 /**
1175 * @tc.name: SafeAreaToPaddingTest6
1176 * @tc.desc: Test SafeAreaToPadding with parameter true.
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest6, TestSize.Level1)
1180 {
1181 /**
1182 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1183 * valid safeAreaInsets before calling SafeAreaToPadding.
1184 * @tc.expected: SafeAreaToPadding returns non-empty.
1185 */
1186 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1187 safeAreaManager_->UpdateNavSafeArea(navArea);
1188 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
1189 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding(true);
1190
1191 EXPECT_EQ(paddingProperty.left, NAV_LEFT_END - SYSTEM_LEFT_START);
1192 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - NAV_RIGHT_START);
1193 EXPECT_EQ(paddingProperty.top, NAV_TOP_END - SYSTEM_TOP_START);
1194 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - NAV_BOTTOM_START);
1195
1196 /**
1197 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1198 * not valid safeAreaInsets before calling SafeAreaToPadding.
1199 * @tc.expected: SafeAreaToPadding returns empty.
1200 */
1201 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
1202 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1203 safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
1204 paddingProperty = safeAreaManager_->SafeAreaToPadding(true);
1205 EXPECT_EQ(paddingProperty.Empty(), true);
1206
1207 /**
1208 * @tc.steps: Call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1209 * valid systemArea and not valid navArea cutoutArea before calling SafeAreaToPadding.
1210 * @tc.expected: SafeAreaToPadding returns non-empty.
1211 */
1212 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1213 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1214 safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
1215 paddingProperty = safeAreaManager_->SafeAreaToPadding(true);
1216
1217 EXPECT_EQ(paddingProperty.left, SYSTEM_LEFT_END - SYSTEM_LEFT_START);
1218 EXPECT_EQ(paddingProperty.right, SYSTEM_TOP_END - SYSTEM_TOP_START);
1219 EXPECT_EQ(paddingProperty.top, SYSTEM_RIGHT_END - SYSTEM_RIGHT_START);
1220 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - SYSTEM_BOTTOM_START);
1221
1222 /**
1223 * @tc.steps: step4 call UpdateSystemSafeArea, UpdateNavSafeArea, UpdateCutoutSafeArea with
1224 * valid systemArea and cutoutArea and not valid navArea before calling SafeAreaToPadding.
1225 * @tc.expected: SafeAreaToPadding returns non-empty.
1226 */
1227 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1228 safeAreaManager_->UpdateNavSafeArea(navAreaNotValid);
1229 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
1230 paddingProperty = safeAreaManager_->SafeAreaToPadding(true);
1231
1232 EXPECT_EQ(paddingProperty.left, CUTOUT_LEFT_END - SYSTEM_LEFT_START);
1233 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - CUTOUT_RIGHT_START);
1234 EXPECT_EQ(paddingProperty.top, CUTOUT_TOP_END - SYSTEM_TOP_START);
1235 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - CUTOUT_BOTTOM_START);
1236 }
1237
1238 /**
1239 * @tc.name: SafeAreaToPaddingTest7
1240 * @tc.desc: Test SafeAreaToPadding with LayoutSafeAreaType.
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(SafeAreaManagerTest, SafeAreaToPaddingTest7, TestSize.Level1)
1244 {
1245 safeAreaManager_->SetIgnoreSafeArea(false);
1246 safeAreaManager_->SetIsFullScreen(false);
1247 safeAreaManager_->SetIsNeedAvoidWindow(true);
1248
1249 safeAreaManager_->UpdateSystemSafeArea(systemArea);
1250 safeAreaManager_->UpdateNavSafeArea(navArea);
1251 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
1252
1253 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::RESIZE);
1254 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
1255 PaddingPropertyF paddingProperty = safeAreaManager_->SafeAreaToPadding(true, LAYOUT_SAFE_AREA_TYPE_KEYBOARD);
1256 EXPECT_EQ(paddingProperty.left, std::nullopt);
1257 EXPECT_EQ(paddingProperty.right, std::nullopt);
1258 EXPECT_EQ(paddingProperty.top, std::nullopt);
1259 EXPECT_EQ(paddingProperty.bottom, KEYBOARD_HEIGHT);
1260
1261 paddingProperty = safeAreaManager_->SafeAreaToPadding(true, LAYOUT_SAFE_AREA_TYPE_ALL);
1262 EXPECT_EQ(paddingProperty.left, NAV_LEFT_END - SYSTEM_LEFT_START);
1263 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - NAV_RIGHT_START);
1264 EXPECT_EQ(paddingProperty.top, NAV_TOP_END - SYSTEM_TOP_START);
1265 EXPECT_EQ(paddingProperty.bottom, KEYBOARD_HEIGHT);
1266
1267 safeAreaManager_->SetKeyBoardAvoidMode(KeyBoardAvoidMode::OFFSET);
1268 float offset = -KEYBOARD_HEIGHT;
1269 safeAreaManager_->UpdateKeyboardOffset(offset);
1270 paddingProperty = safeAreaManager_->SafeAreaToPadding(true, LAYOUT_SAFE_AREA_TYPE_KEYBOARD);
1271 EXPECT_EQ(paddingProperty.left, std::nullopt);
1272 EXPECT_EQ(paddingProperty.right, std::nullopt);
1273 EXPECT_EQ(paddingProperty.top, std::nullopt);
1274 EXPECT_EQ(paddingProperty.bottom, std::nullopt);
1275
1276 offset = -KEYBOARD_HEIGHT / 2.0f;
1277 safeAreaManager_->UpdateKeyboardOffset(offset);
1278 paddingProperty = safeAreaManager_->SafeAreaToPadding(true, LAYOUT_SAFE_AREA_TYPE_KEYBOARD);
1279 EXPECT_EQ(paddingProperty.left, std::nullopt);
1280 EXPECT_EQ(paddingProperty.right, std::nullopt);
1281 EXPECT_EQ(paddingProperty.top, std::nullopt);
1282 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - NAV_BOTTOM_START);
1283
1284 paddingProperty = safeAreaManager_->SafeAreaToPadding(true, LAYOUT_SAFE_AREA_TYPE_ALL);
1285 EXPECT_EQ(paddingProperty.left, NAV_LEFT_END - SYSTEM_LEFT_START);
1286 EXPECT_EQ(paddingProperty.right, SYSTEM_RIGHT_END - NAV_RIGHT_START);
1287 EXPECT_EQ(paddingProperty.top, NAV_TOP_END - SYSTEM_TOP_START);
1288 EXPECT_EQ(paddingProperty.bottom, SYSTEM_BOTTOM_END - NAV_BOTTOM_START);
1289 }
1290
1291 /**
1292 * @tc.name: NeedExpandNodeListTest
1293 * @tc.desc: Build an UI tree and start layouting from the root
1294 * and test if set of nodes are added in the list correctly.
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(SafeAreaManagerTest, NeedExpandNodeListTest, TestSize.Level1)
1298 {
1299 // create nodes
1300 auto frameNode0 = FrameNode::CreateFrameNode(
1301 V2::PAGE_ETS_TAG, 0, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
1302
1303 auto frameNode1 = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, 1, AceType::MakeRefPtr<LinearLayoutPattern>(true));
1304
1305 auto frameNode2 = FrameNode::CreateFrameNode(V2::FLEX_ETS_TAG, 2, AceType::MakeRefPtr<LinearLayoutPattern>(true));
1306
1307 auto frameNode3 = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 3, AceType::MakeRefPtr<LinearLayoutPattern>(false));
1308 frameNode1->MountToParent(frameNode0);
1309 frameNode2->MountToParent(frameNode1);
1310 frameNode3->MountToParent(frameNode2);
1311 // make sure nodes mount correctly
1312 EXPECT_EQ(frameNode1->GetParent()->GetTag(), V2::PAGE_ETS_TAG);
1313 EXPECT_EQ(frameNode2->GetParent()->GetTag(), V2::COLUMN_ETS_TAG);
1314 EXPECT_EQ(frameNode3->GetParent()->GetTag(), V2::FLEX_ETS_TAG);
1315 SafeAreaExpandOpts opts = { .type = SAFE_AREA_TYPE_SYSTEM, .edges = SAFE_AREA_EDGE_TOP };
1316 auto columnLayoutProperty = frameNode1->GetLayoutProperty();
1317 EXPECT_NE(columnLayoutProperty, nullptr);
1318 columnLayoutProperty->UpdateSafeAreaExpandOpts(opts);
1319 auto flexLayoutProperty = frameNode2->GetLayoutProperty();
1320 EXPECT_NE(flexLayoutProperty, nullptr);
1321 flexLayoutProperty->UpdateSafeAreaExpandOpts(opts);
1322 auto rowLayoutProperty = frameNode3->GetLayoutProperty();
1323 EXPECT_NE(rowLayoutProperty, nullptr);
1324 rowLayoutProperty->UpdateSafeAreaExpandOpts(opts);
1325 // page start to measure
1326 frameNode0->SetLayoutDirtyMarked(true);
1327 frameNode0->CreateLayoutTask();
1328 auto pipeline = PipelineContext::GetCurrentContext();
1329 EXPECT_NE(pipeline, nullptr);
1330 auto manager = pipeline->GetSafeAreaManager();
1331 EXPECT_NE(manager, nullptr);
1332 auto nodeSet = manager->GetExpandNodeSet();
1333 // page should not be added
1334 EXPECT_EQ(nodeSet.size(), 3);
1335 auto iter = nodeSet.begin();
1336 EXPECT_NE(iter, nodeSet.end());
1337 auto nodeIter = (*iter).Upgrade();
1338 EXPECT_NE(nodeIter, nullptr);
1339 EXPECT_EQ(nodeIter->GetTag(), V2::COLUMN_ETS_TAG);
1340 EXPECT_EQ(nodeIter->GetId(), 1);
1341 iter++;
1342 EXPECT_NE(iter, nodeSet.end());
1343 nodeIter = (*iter).Upgrade();
1344 EXPECT_NE(nodeIter, nullptr);
1345 EXPECT_EQ(nodeIter->GetTag(), V2::FLEX_ETS_TAG);
1346 EXPECT_EQ(nodeIter->GetId(), 2);
1347 iter++;
1348 EXPECT_NE(iter, nodeSet.end());
1349 nodeIter = (*iter).Upgrade();
1350 EXPECT_NE(nodeIter, nullptr);
1351 EXPECT_EQ(nodeIter->GetTag(), V2::ROW_ETS_TAG);
1352 EXPECT_EQ(nodeIter->GetId(), 3);
1353 }
1354
1355 /**
1356 * @tc.name: AddNodeToExpandListIfNeededTest
1357 * @tc.desc: test functionality of AddNodeToExpandListIfNeededTest interface
1358 * @tc.type: FUNC
1359 */
1360 HWTEST_F(SafeAreaManagerTest, AddNodeToExpandListIfNeededTest, TestSize.Level1)
1361 {
1362 auto frameNode0 = FrameNode::CreateFrameNode(
1363 V2::PAGE_ETS_TAG, 0, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
1364
1365 auto frameNode1 =
1366 FrameNode::CreateFrameNode(V2::NAVIGATION_VIEW_ETS_TAG, 1, AceType::MakeRefPtr<NavigationPattern>(), false);
1367
1368 auto frameNode2 = FrameNode::CreateFrameNode(
1369 V2::NAVDESTINATION_VIEW_ETS_TAG, 2, AceType::MakeRefPtr<NavDestinationPattern>(), true);
1370
1371 auto frameNode3 = FrameNode::CreateFrameNode(
1372 V2::NAVDESTINATION_CONTENT_ETS_TAG, 3, AceType::MakeRefPtr<LinearLayoutPattern>(true), false);
1373
1374 auto frameNode4 = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 4, AceType::MakeRefPtr<LinearLayoutPattern>(false));
1375 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
1376 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
1377 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
1378 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
1379 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
1380 EXPECT_EQ(safeAreaManager_->GetExpandNodeSet().size(), 5);
1381
1382 // repeat add should not work
1383 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), false);
1384 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), false);
1385 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), false);
1386 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), false);
1387 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), false);
1388
1389 safeAreaManager_->ClearNeedExpandNode();
1390 EXPECT_EQ(safeAreaManager_->GetExpandNodeSet().size(), 0);
1391 }
1392
1393 /**
1394 * @tc.name: IsModeResizeOrIsModeOffset
1395 * @tc.desc: Test IsModeResize and IsModeOffset
1396 * @tc.type: FUNC
1397 */
1398 HWTEST_F(SafeAreaManagerTest, IsModeResizeOrIsModeOffset, TestSize.Level1)
1399 {
1400 std::vector<KeyBoardAvoidMode> modeArr = {
1401 KeyBoardAvoidMode::OFFSET,
1402 KeyBoardAvoidMode::RESIZE,
1403 KeyBoardAvoidMode::OFFSET_WITH_CARET,
1404 KeyBoardAvoidMode::RESIZE_WITH_CARET,
1405 KeyBoardAvoidMode::NONE
1406 };
1407 std::vector<std::pair<bool, bool>> expectedRes = {
1408 { true, false },
1409 { false, true },
1410 { true, false },
1411 { false, true },
1412 { false, false }
1413 };
1414 for (int i= 0; i < modeArr.size(); ++i) {
1415 safeAreaManager_->SetKeyBoardAvoidMode(modeArr[i]);
1416 EXPECT_EQ(safeAreaManager_->IsModeOffset(), expectedRes[i].first);
1417 EXPECT_EQ(safeAreaManager_->IsModeResize(), expectedRes[i].second);
1418 }
1419 }
1420
1421 /**
1422 * @tc.name: GetKeyboardWebInset
1423 * @tc.desc: test functionality of GetKeyboardWebInset interface
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(SafeAreaManagerTest, GetKeyboardWebInset, TestSize.Level1)
1427 {
1428 SafeAreaInsets::Inset inset;
1429 safeAreaManager_->keyboardAvoidMode_ = KeyBoardAvoidMode::NONE;
1430 auto keyboardInset = safeAreaManager_->GetKeyboardWebInset();
1431 EXPECT_EQ(keyboardInset.start, inset.start);
1432 EXPECT_EQ(keyboardInset.end, inset.end);
1433 safeAreaManager_->keyboardAvoidMode_ = KeyBoardAvoidMode::OFFSET;
1434 keyboardInset = safeAreaManager_ ->GetKeyboardWebInset();
1435 EXPECT_EQ(keyboardInset.start, safeAreaManager_->keyboardWebInset_.start);
1436 EXPECT_EQ(keyboardInset.end, safeAreaManager_->keyboardWebInset_.end);
1437 }
1438
1439 /**
1440 * @tc.name: SetAndGetKeyboardInsetImplTest
1441 * @tc.desc: test Set And GetKeyboardInsetImplTest interface
1442 * @tc.type: FUNC
1443 */
1444 HWTEST_F(SafeAreaManagerTest, SetAndGetKeyboardInsetImplTest, TestSize.Level1)
1445 {
__anonf31f69be0502(SafeAreaManager* manager) 1446 safeAreaManager_->SetKeyboardInsetImpl([](SafeAreaManager* manager) { return manager->GetKeyboardWebInset(); });
1447 EXPECT_NE(safeAreaManager_->getKeyboardInset, nullptr);
1448 auto ret = safeAreaManager_->GetKeyboardInsetImpl();
1449 auto compare = safeAreaManager_->GetKeyboardWebInset();
1450 EXPECT_EQ(ret, compare);
1451 safeAreaManager_->SetKeyboardInsetImpl(std::function<SafeAreaInsets::Inset(SafeAreaManager*)>());
1452 EXPECT_EQ(safeAreaManager_->getKeyboardInset, nullptr);
1453 ret = safeAreaManager_->GetKeyboardInsetImpl();
1454 compare = safeAreaManager_->GetKeyboardInset();
1455 EXPECT_EQ(ret, compare);
1456 }
1457 } // namespace OHOS::Ace::NG