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