1 /*
2 * Copyright (c) 2023 iSoftStone Information Technology (Group) 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 private public
19 #define protected public
20
21 #include "test/mock/core/common/mock_container.h"
22 #include "test/mock/core/pipeline/mock_pipeline_context.h"
23
24 #include "core/common/ace_engine.h"
25 #include "core/common/container.h"
26 #include "core/common/container_scope.h"
27 #include "core/components_ng/base/frame_node.h"
28 #include "core/components_ng/base/view_stack_processor.h"
29 #include "core/components_ng/pattern/checkboxgroup/checkboxgroup_pattern.h"
30 #include "core/components_ng/pattern/custom/custom_measure_layout_node.h"
31 #include "core/components_ng/pattern/radio/radio_pattern.h"
32 #include "core/components_ng/pattern/stage/page_event_hub.h"
33 #include "core/components_ng/pattern/stage/page_pattern.h"
34 #include "core/components_ng/pattern/stage/page_transition_effect.h"
35 #include "core/components_ng/pattern/stage/page_transition_model_ng.h"
36 #include "core/components_ng/pattern/stage/stage_layout_algorithm.h"
37 #include "core/components_ng/pattern/stage/stage_pattern.h"
38 #include "core/pipeline/base/element_register.h"
39 #undef private
40 #undef protected
41
42 using namespace testing;
43 using namespace testing::ext;
44
45 namespace OHOS::Ace::NG {
46 namespace {
47 const std::string CHECK_STRING = "check";
48 const std::string TEST_GROUP_NAME = "testGroup";
49 const std::string ERROR_GROUP_NAME = "errorGroup";
50 const std::string FRAME_NODE_TAG = "testFrameNode";
51 const std::string TEST_ANIMATOR_ID = "testAnimatorId";
52 constexpr int32_t RADIO_ID_FIRST = 1;
53 constexpr int32_t RADIO_ID_SECOND = 2;
54 constexpr int32_t RADIO_ID_THIRD = 3;
55 constexpr int32_t CHECK_BOX_ID_FIRST = 4;
56 constexpr int32_t CHECK_BOX_ID_THIRD = 6;
57 constexpr int32_t CHECK_BOX_ID_FOURTH = 6;
58 constexpr int32_t TEST_CONTAINER_ID = 100;
59 constexpr int32_t AT_LEAST_TIME = 1;
60 const float NOPADDING = 0.0f;
61 const float RK356_WIDTH = 720.0f;
62 constexpr float RK356_HEIGHT = 1136.0f;
63 const float ROW_HEIGHT = 120.0f;
64 const SizeF CONTAINER_SIZE { RK356_WIDTH, RK356_HEIGHT };
65 int32_t flag = 0;
__anonf0e2b0460202() 66 std::function<void()> FLAG_FUNC = []() { flag++; };
67 } // namespace
68
CreatChildlayoutWrapper()69 RefPtr<LayoutWrapperNode> CreatChildlayoutWrapper()
70 {
71 auto firstFrameNode = FrameNode::CreateFrameNode("one", 1, AceType::MakeRefPtr<StagePattern>());
72 RefPtr<GeometryNode> firstGeometryNode = AceType::MakeRefPtr<GeometryNode>();
73 firstGeometryNode->Reset();
74 RefPtr<LayoutWrapperNode> firstLayoutWrapper =
75 AceType::MakeRefPtr<LayoutWrapperNode>(firstFrameNode, firstGeometryNode, firstFrameNode->GetLayoutProperty());
76 return firstLayoutWrapper;
77 }
78
79 class StageTestNg : public testing::Test {
80 public:
SetUpTestSuite()81 static void SetUpTestSuite()
82 {
83 MockPipelineContext::SetUp();
84 auto pipeline = AceType::DynamicCast<NG::MockPipelineContext>(PipelineBase::GetCurrentContext());
85 auto stageNode = FrameNode::CreateFrameNode(
86 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
87 pipeline->sharedTransitionManager_ = AceType::MakeRefPtr<SharedOverlayManager>(stageNode);
88 MockContainer::SetUp();
89 EXPECT_CALL(*MockContainer::Current(), WindowIsShow())
90 .Times(testing::AtLeast(AT_LEAST_TIME))
91 .WillRepeatedly(Return(true));
92 ContainerScope::UpdateCurrent(TEST_CONTAINER_ID);
93 }
TearDownTestSuite()94 static void TearDownTestSuite()
95 {
96 MockPipelineContext::TearDown();
97 MockContainer::TearDown();
98 }
SetUp()99 void SetUp()
100 {
101 flag = 0;
102 }
TearDown()103 void TearDown() {}
104 };
105
106 /**
107 * @tc.name: PageEventHubTest001
108 * @tc.desc: Testing Radio Correlation Functions of PageEventHub work correctly.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(StageTestNg, PageEventHubTest001, TestSize.Level1)
112 {
113 /**
114 * @tc.steps: step1. Build a PageEventHub.
115 */
116 PageEventHub pageEventHub;
117 auto groupManager = pageEventHub.GetGroupManager();
118 groupManager->UpdateRadioGroupValue(TEST_GROUP_NAME, RADIO_ID_FIRST);
119
120 /**
121 * @tc.steps: step2. Add radio to group.
122 * @tc.expected: The HasRadioId function of PageEventHub meets expectations .
123 */
124 groupManager->AddRadioToGroup(TEST_GROUP_NAME, RADIO_ID_FIRST);
125 EXPECT_TRUE(groupManager->HasRadioId(TEST_GROUP_NAME, RADIO_ID_FIRST));
126 EXPECT_FALSE(groupManager->HasRadioId(ERROR_GROUP_NAME, RADIO_ID_FIRST));
127
128 /**
129 * @tc.steps: step3. Add another two radio to group.
130 * @tc.expected: The HasRadioId function of PageEventHub meets expectations .
131 */
132 groupManager->AddRadioToGroup(TEST_GROUP_NAME, RADIO_ID_SECOND);
133 groupManager->AddRadioToGroup(TEST_GROUP_NAME, RADIO_ID_THIRD);
134
135 /**
136 * @tc.steps: step4. Create real node and fake node to ElementRegister.
137 */
138 auto radioPattern = AceType::MakeRefPtr<RadioPattern>();
139 auto radioNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, RADIO_ID_FIRST, radioPattern);
140 ElementRegister::GetInstance()->AddReferenced(RADIO_ID_FIRST, radioNode);
141 auto checkBoxGroup = AceType::MakeRefPtr<CheckBoxGroupPattern>();
142 auto checkBoxGroupNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, RADIO_ID_SECOND, checkBoxGroup);
143 ElementRegister::GetInstance()->AddReferenced(RADIO_ID_SECOND, checkBoxGroupNode);
144
145 /**
146 * @tc.steps: step5. UpdateRadioGroupValue.
147 */
148 groupManager->UpdateRadioGroupValue(TEST_GROUP_NAME, RADIO_ID_FIRST);
149 groupManager->UpdateRadioGroupValue(TEST_GROUP_NAME, RADIO_ID_SECOND);
150
151 /**
152 * @tc.steps: step6. RemoveRadioFromGroup.
153 * @tc.expected: The radio remove successful .
154 */
155 groupManager->RemoveRadioFromGroup(TEST_GROUP_NAME, RADIO_ID_FIRST);
156 EXPECT_FALSE(groupManager->HasRadioId(TEST_GROUP_NAME, RADIO_ID_FIRST));
157 }
158
159 /**
160 * @tc.name: PageEventHubTest002
161 * @tc.desc: Testing CheckBox Correlation Functions of PageEventHub work correctly.
162 * @tc.type: FUNC
163 */
164 HWTEST_F(StageTestNg, PageEventHubTest002, TestSize.Level1)
165 {
166 /**
167 * @tc.steps: step1. Build a PageEventHub.
168 * @tc.expected: The CheckBoxGroupMap size meets expectations .
169 */
170 PageEventHub pageEventHub;
171 auto groupManager = pageEventHub.GetGroupManager();
172 EXPECT_EQ(groupManager->GetCheckboxList(TEST_GROUP_NAME).size(), 0);
173
174 /**
175 * @tc.steps: step2. build error pattern and add to the group.
176 * @tc.expected: The CheckBoxGroupMap[TEST_GROUP_NAME] has the error pattern.
177 */
178 auto errorPattern = AceType::MakeRefPtr<RadioPattern>();
179 auto errorNode = FrameNode::CreateFrameNode(V2::CHECKBOXGROUP_ETS_TAG, CHECK_BOX_ID_FIRST, errorPattern);
180 ElementRegister::GetInstance()->AddReferenced(CHECK_BOX_ID_FIRST, errorNode);
181 groupManager->RemoveCheckBoxGroup(TEST_GROUP_NAME, CHECK_BOX_ID_FIRST);
182 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, errorNode);
183 EXPECT_EQ(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
184
185 /**
186 * @tc.steps: step3. remove error pattern.
187 * @tc.expected: The CheckBoxGroupMap[TEST_GROUP_NAME] has the error pattern.
188 */
189 ElementRegister::GetInstance()->RemoveItem(CHECK_BOX_ID_FIRST);
190 groupManager->RemoveCheckBoxGroup(TEST_GROUP_NAME, CHECK_BOX_ID_FIRST);
191 EXPECT_EQ(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
192
193 /**
194 * @tc.steps: step4. add real checkBoxGroup and add to the group.
195 * @tc.expected: add success.
196 */
197 auto checkBoxGroup = AceType::MakeRefPtr<CheckBoxGroupPattern>();
198 auto checkBoxGroupNode = FrameNode::CreateFrameNode(V2::CHECKBOXGROUP_ETS_TAG, CHECK_BOX_ID_THIRD, checkBoxGroup);
199 ElementRegister::GetInstance()->AddReferenced(CHECK_BOX_ID_THIRD, checkBoxGroupNode);
200 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, checkBoxGroupNode);
201 EXPECT_NE(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
202
203 /**
204 * @tc.steps: step5. add checkBox to group
205 * @tc.expected: add success.
206 */
207 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, nullptr);
208 EXPECT_NE(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
209
210 /**
211 * @tc.steps: step6. remove the checkBoxGroup from group.
212 * @tc.expected: remove success.
213 */
214 ElementRegister::GetInstance()->RemoveItem(CHECK_BOX_ID_THIRD);
215 groupManager->RemoveCheckBoxGroup(TEST_GROUP_NAME, CHECK_BOX_ID_THIRD);
216 EXPECT_EQ(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
217
218 /**
219 * @tc.steps: step7. add checkBoxGroup to group again.
220 * @tc.expected: add success.
221 */
222 ElementRegister::GetInstance()->AddReferenced(CHECK_BOX_ID_THIRD, checkBoxGroupNode);
223 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, nullptr);
224 EXPECT_EQ(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
225
226 /**
227 * @tc.steps: step8. build second checkBoxGroup to group.
228 * @tc.expected: add fail.
229 */
230 auto checkBoxGroup2 = AceType::MakeRefPtr<CheckBoxGroupPattern>();
231 auto checkBoxGroupNode2 =
232 FrameNode::CreateFrameNode(V2::CHECKBOXGROUP_ETS_TAG, CHECK_BOX_ID_FOURTH, checkBoxGroup2);
233 ElementRegister::GetInstance()->AddReferenced(CHECK_BOX_ID_FOURTH, checkBoxGroupNode2);
234 groupManager->RemoveCheckBoxFromGroup(TEST_GROUP_NAME, CHECK_BOX_ID_FOURTH);
235 EXPECT_EQ(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
236 }
237
238 /**
239 * @tc.name: PageEventHubTest003
240 * @tc.desc: Testing CheckBox Correlation Functions of PageEventHub work correctly.
241 * @tc.type: FUNC
242 */
243 HWTEST_F(StageTestNg, PageEventHubTest003, TestSize.Level1)
244 {
245 /**
246 * @tc.steps: step1. Build a PageEventHub.
247 * @tc.expected: The CheckBoxGroupMap size meets expectations .
248 */
249 PageEventHub pageEventHub;
250 auto groupManager = pageEventHub.GetGroupManager();
251 EXPECT_EQ(groupManager->GetCheckboxList(TEST_GROUP_NAME).size(), 0);
252
253 /**
254 * @tc.steps: step2. add real checkBoxGroup and add to the group.
255 * @tc.expected: add success.
256 */
257 auto checkBoxGroup = AceType::MakeRefPtr<CheckBoxGroupPattern>();
258 auto checkBoxGroupNode = FrameNode::CreateFrameNode("CheckboxGroup2", CHECK_BOX_ID_FIRST, checkBoxGroup);
259 ElementRegister::GetInstance()->AddReferenced(CHECK_BOX_ID_FIRST, checkBoxGroupNode);
260 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, checkBoxGroupNode);
261 EXPECT_NE(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
262
263 /**
264 * @tc.steps: step3. add checkBoxGroup to group
265 * @tc.expected: add success.
266 */
267 auto checkBoxGroupNode2 = FrameNode::CreateFrameNode(V2::CHECKBOXGROUP_ETS_TAG, CHECK_BOX_ID_FIRST, checkBoxGroup);
268 ElementRegister::GetInstance()->AddReferenced(12, checkBoxGroupNode2);
269 groupManager->AddCheckBoxGroup(TEST_GROUP_NAME, checkBoxGroupNode2);
270 ASSERT_NE(groupManager->GetCheckboxGroup(TEST_GROUP_NAME), nullptr);
271 EXPECT_NE(groupManager->GetCheckboxGroup(TEST_GROUP_NAME)->GetTag(), V2::CHECKBOXGROUP_ETS_TAG);
272 }
273
274 /**
275 * @tc.name: StageManagerTest001
276 * @tc.desc: Testing PushPage and PopPage Function of StageManager work correctly.
277 * @tc.type: FUNC
278 */
279 HWTEST_F(StageTestNg, StageManagerTest001, TestSize.Level1)
280 {
281 /**
282 * @tc.steps: step1. Create StagePattern and some PagePattern.
283 */
284 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
285 auto firstNode =
286 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
287 auto secondNode =
288 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
289 auto thirdNode =
290 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
291 auto fourthNode =
292 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
293
294 /**
295 * @tc.steps: step2. Create a StageManager based on stageNode.
296 */
297 StageManager stageManager(stageNode);
298
299 /**
300 * @tc.steps: step3. PopPage.
301 * @tc.expected: Expected no child failed.
302 */
303 EXPECT_FALSE(stageManager.PopPage());
304
305 /**
306 * @tc.steps: step4. Push a Page into StageManager.
307 * @tc.expected: Push successfully.
308 */
309 EXPECT_TRUE(stageManager.PushPage(firstNode));
310
311 /**
312 * @tc.steps: step5. Push another three Page with different parameters into StageManager.
313 * @tc.expected: Push successfully.
314 */
315 stageManager.PushPage(secondNode, false, false);
316 stageManager.PushPage(thirdNode, true, false);
317 stageManager.stageNode_->GetGeometryNode()->SetFrameSize(SizeF(1.0f, 1.0f));
318 stageManager.PushPage(fourthNode, false, true);
319 EXPECT_EQ(stageNode->GetChildren().size(), 4);
320
321 /**
322 * @tc.steps: step6. Push an exist page.
323 * @tc.expected: StageNode size not changed.
324 */
325 stageManager.PushPage(secondNode);
326 EXPECT_EQ(stageNode->GetChildren().size(), 4);
327
328 /**
329 * @tc.steps: step7. PopPage with different parameters.
330 * @tc.expected: removeChild meets expectations .
331 */
332 stageManager.PopPage(false, false);
333 EXPECT_EQ(stageNode->GetChildren().size(), 3);
334 stageManager.PopPage(false, false);
335 EXPECT_EQ(stageNode->GetChildren().size(), 2);
336
337 // children.size() < 2
338 stageManager.PopPage(false, false);
339 EXPECT_EQ(stageNode->GetChildren().size(), 1);
340 }
341
342 /**
343 * @tc.name: StageManagerTest002
344 * @tc.desc: Testing PopPageToIndex function of StageManager work correctly.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(StageTestNg, StageManagerTest002, TestSize.Level1)
348 {
349 /**
350 * @tc.steps: step1. Create StagePattern and some PagePattern.
351 */
352 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
353 auto firstNode =
354 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
355 auto secondNode =
356 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
357 auto thirdNode =
358 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
359 auto fourthNode =
360 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
361 StageManager stageManager(stageNode);
362
363 /**
364 * @tc.steps: step2. Calling PopPageToIndex function.
365 * @tc.expected: Children are empty and return false
366 */
367 EXPECT_FALSE(stageManager.PopPageToIndex(1));
368
369 /**
370 * @tc.steps: step3. Add first child node and recall PopPageToIndex.
371 * @tc.expected: Children length is less than the current index and return false
372 */
373 stageManager.PushPage(firstNode);
374 EXPECT_FALSE(stageManager.PopPageToIndex(1));
375
376 /**
377 * @tc.steps: step4. Add second child node and recall PopPageToIndex.
378 * @tc.expected: Children length is equal to the current index and return true
379 */
380 stageManager.PushPage(secondNode);
381 EXPECT_TRUE(stageManager.PopPageToIndex(1));
382
383 /**
384 * @tc.steps: step5. Add third child node and recall PopPageToIndex.
385 * @tc.expected: stageManager child size meets expectations.
386 */
387 stageManager.PushPage(thirdNode);
388 stageManager.PushPage(fourthNode);
389 stageManager.PopPageToIndex(1);
390 EXPECT_EQ(stageNode->GetChildren().size(), 3);
391 stageManager.PopPageToIndex(0);
392 EXPECT_EQ(stageNode->GetChildren().size(), 2);
393
394 /**
395 * @tc.steps: step6. Add third child node and recall PopPageToIndex.
396 * @tc.expected: return true
397 */
398 stageManager.PushPage(thirdNode);
399 stageManager.PushPage(fourthNode);
400 EXPECT_TRUE(stageManager.PopPageToIndex(1, false, false));
401 }
402
403 /**
404 * @tc.name: StageManagerTest003
405 * @tc.desc: Testing CleanPageStack Function of StageManager work correctly.
406 * @tc.type: FUNC
407 */
408 HWTEST_F(StageTestNg, StageManagerTest003, TestSize.Level1)
409 {
410 /**
411 * @tc.steps: step1. Create StagePattern and PagePattern.
412 */
413 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
414 auto firstNode =
415 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
416 auto secondNode =
417 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
418 StageManager stageManager(stageNode);
419
420 /**
421 * @tc.steps: step2. Call CleanPageStack function.
422 * @tc.expected:Children just one and return false
423 */
424 stageManager.PushPage(firstNode);
425 EXPECT_FALSE(stageManager.CleanPageStack());
426
427 /**
428 * @tc.steps: step3. Add second child node and recall CleanPageStack.
429 * @tc.expected: return true
430 */
431 stageManager.PushPage(secondNode);
432 EXPECT_TRUE(stageManager.CleanPageStack());
433 }
434
435 /**
436 * @tc.name: StageManagerTest004
437 * @tc.desc: Testing GetLastPage and MovePageToFront Function of StageManager work correctly.
438 * @tc.type: FUNC
439 */
440 HWTEST_F(StageTestNg, StageManagerTest004, TestSize.Level1)
441 {
442 /**
443 * @tc.steps: step1. Create StagePattern and some PagePattern.
444 */
445 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
446 auto firstNode =
447 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
448 auto secondNode =
449 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
450
451 /**
452 * @tc.steps: step2. Create a StageManager based on stageNode.
453 */
454 StageManager stageManager(stageNode);
455
456 /**
457 * @tc.steps: step3. Calling the GetLastPage function.
458 * @tc.expected: The manager GetLastPage return null.
459 */
460 EXPECT_EQ(stageManager.GetLastPage(), nullptr);
461
462 /**
463 * @tc.steps: step4. Calling the MovePageToFront function.
464 * @tc.expected: return false.
465 */
466 EXPECT_FALSE(stageManager.MovePageToFront(firstNode));
467
468 /**
469 * @tc.steps: step5. StateManager put a page and recall MovePageToFront.
470 * @tc.expected: return true.
471 */
472 stageManager.PushPage(firstNode);
473 EXPECT_TRUE(stageManager.MovePageToFront(firstNode));
474
475 /**
476 * @tc.steps: step6. StateManager another page and recall MovePageToFront with different params.
477 * @tc.expected: always return true.
478 */
479 stageManager.PushPage(secondNode);
480 EXPECT_TRUE(stageManager.MovePageToFront(firstNode, false, true));
481 EXPECT_TRUE(stageManager.MovePageToFront(secondNode, true, false));
482
483 /**
484 * @tc.steps: step7. Calling the GetLastPage function.
485 * @tc.expected: The secondNode is last page.
486 */
487 EXPECT_EQ(stageManager.GetLastPage(), secondNode);
488 }
489 /**
490 * @tc.name: StageManagerTest005
491 * @tc.desc: Testing ReloadStage Function of StageManager work correctly.
492 * @tc.type: FUNC
493 */
494 HWTEST_F(StageTestNg, StageManagerTest005, TestSize.Level1)
495 {
496 /**
497 * @tc.steps: step1. Create a StageManager.
498 */
499 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
500 StageManager stageManager(stageNode);
501
502 /**
503 * @tc.steps: step2. call ReloadStage.
504 */
505 stageManager.ReloadStage();
506
507 /**
508 * @tc.steps: step3. Create FrameNode and fake CustomNode.
509 */
510 auto firstNode =
511 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
512 stageManager.PushPage(firstNode);
513 auto secondNode = AceType::MakeRefPtr<CustomNode>(2, "2");
514 secondNode->MountToParent(stageNode);
515
516 /**
517 * @tc.steps: step4. call ReloadStage.
518 * @tc.expected: stageNode children size not changed
519 */
520 stageManager.ReloadStage();
521 EXPECT_EQ(stageNode->GetChildren().size(), 2);
522 }
523
524 /**
525 * @tc.name: StageManagerTest006
526 * @tc.desc: Testing PushPage and PopPage Function of StageManager work correctly.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(StageTestNg, StageManagerTest006, TestSize.Level1)
530 {
531 /**
532 * @tc.steps: step1. Create StagePattern and some PagePattern.
533 */
534 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
535 auto firstNode =
536 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
537 auto secondNode =
538 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
539 auto thirdNode =
540 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
541 auto fourthNode =
542 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
543
544 /**
545 * @tc.steps: step2. Create a StageManager based on stageNode.
546 */
547 StageManager stageManager(stageNode);
548 stageManager.PushPage(firstNode);
549 stageManager.PushPage(secondNode);
550 stageManager.PushPage(thirdNode);
551 stageManager.PushPage(fourthNode);
552 EXPECT_EQ(stageNode->GetChildren().size(), 4);
553
554 /**
555 * @tc.steps: step3. Create outPageNode and inPageNode.
556 */
557 auto pipeline = PipelineContext::GetCurrentContext();
558 stageManager.StopPageTransition();
559 const auto& children = stageManager.stageNode_->GetChildren();
560 bool needTransition = true;
561 auto pageNode = children.back();
562 const size_t transitionPageSize = 2;
563 needTransition &= (children.size() >= transitionPageSize);
564 if (needTransition) {
565 pipeline->FlushPipelineImmediately();
566 }
567 stageManager.FirePageHide(pageNode, needTransition ? PageTransitionType::EXIT_POP : PageTransitionType::NONE);
568 RefPtr<FrameNode> inPageNode;
569 if (children.size() >= transitionPageSize) {
570 auto newPageNode = *(++children.rbegin());
571 stageManager.FirePageShow(
572 newPageNode, needTransition ? PageTransitionType::ENTER_POP : PageTransitionType::NONE);
573 inPageNode = AceType::DynamicCast<FrameNode>(newPageNode);
574 }
575 auto outPageNode = AceType::DynamicCast<FrameNode>(pageNode);
576
577 /**
578 * @tc.steps: step4. Call StartTransition.
579 * @tc.expected: Start Successful.
580 */
581 stageManager.StartTransition(outPageNode, inPageNode, RouteType::NONE);
582 inPageNode->OnAccessibilityEvent(AccessibilityEventType::CHANGE);
583 EXPECT_EQ(stageManager.srcPageNode_, outPageNode);
584 EXPECT_EQ(stageManager.destPageNode_, inPageNode);
585 }
586
587 /**
588 * @tc.name: StageManagerTest007
589 * @tc.desc: Testing PushPage and PopPage Function of StageManager work correctly.
590 * @tc.type: FUNC
591 */
592 HWTEST_F(StageTestNg, StageManagerTest007, TestSize.Level1)
593 {
594 /**
595 * @tc.steps: step1. Create StagePattern and some PagePattern.
596 */
597 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
598 auto firstNode =
599 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
600 auto secondNode =
601 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
602 auto thirdNode =
603 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
604 auto fourthNode =
605 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
606
607 /**
608 * @tc.steps: step2. Create a StageManager based on stageNode.
609 */
610 StageManager stageManager(stageNode);
611
612 /**
613 * @tc.steps: step3. PopPage.
614 * @tc.expected: Expected no child failed.
615 */
616 EXPECT_FALSE(stageManager.PopPage());
617
618 /**
619 * @tc.steps: step4. Push a Page into StageManager.
620 * @tc.expected: Push successfully.
621 */
622 EXPECT_TRUE(stageManager.PushPage(firstNode));
623
624 /**
625 * @tc.steps: step5. Push another three Page with different parameters into StageManager.
626 * @tc.expected: Push successfully.
627 */
628 stageManager.PushPage(secondNode, false, false);
629 stageManager.PushPage(thirdNode, true, false);
630 stageManager.stageNode_->GetGeometryNode()->SetFrameSize(SizeF(1.0f, 1.0f));
631 stageManager.PushPage(fourthNode, false, true);
632 EXPECT_EQ(stageNode->GetChildren().size(), 4);
633
634 /**
635 * @tc.steps: step6. Push an exist page.
636 * @tc.expected: StageNode size not changed.
637 */
638 stageManager.PushPage(secondNode);
639 EXPECT_EQ(stageNode->GetChildren().size(), 4);
640
641 /**
642 * @tc.steps: step7. PopPage with different parameters.
643 * @tc.expected: removeChild meets expectations .
644 */
645 bool bResult = stageManager.PopPage(true, true);
646 EXPECT_EQ(stageNode->GetChildren().size(), 4);
647 EXPECT_TRUE(bResult);
648 }
649
650 /**
651 * @tc.name: StageManagerTest008
652 * @tc.desc: Testing PushPage and PopPage Function of StageManager work correctly.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(StageTestNg, StageManagerTest008, TestSize.Level1)
656 {
657 /**
658 * @tc.steps: step1. Create StagePattern and some PagePattern.
659 */
660 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
661 auto firstNode =
662 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
663 auto secondNode =
664 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
665 auto thirdNode =
666 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
667 auto fourthNode =
668 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
669
670 /**
671 * @tc.steps: step2. Create a StageManager based on stageNode.
672 */
673 StageManager stageManager(stageNode);
674
675 /**
676 * @tc.steps: step3. PopPage.
677 * @tc.expected: Expected no child failed.
678 */
679 EXPECT_FALSE(stageManager.PopPage());
680
681 /**
682 * @tc.steps: step4. Push a Page into StageManager.
683 * @tc.expected: Push successfully.
684 */
685 EXPECT_TRUE(stageManager.PushPage(firstNode));
686
687 /**
688 * @tc.steps: step5. Push another three Page with different parameters into StageManager.
689 * @tc.expected: Push successfully.
690 */
691 stageManager.PushPage(secondNode, false, false);
692 stageManager.PushPage(thirdNode, true, false);
693 stageManager.stageNode_->GetGeometryNode()->SetFrameSize(SizeF(10.0f, 10.0f));
694 stageManager.PushPage(fourthNode, false, true);
695 EXPECT_EQ(stageNode->GetChildren().size(), 4);
696
697 /**
698 * @tc.steps: step6. Push an exist page.
699 * @tc.expected: StageNode size not changed.
700 */
701 stageManager.PushPage(secondNode);
702 EXPECT_EQ(stageNode->GetChildren().size(), 4);
703
704 /**
705 * @tc.steps: step7. PopPage with different parameters.
706 * @tc.expected: removeChild meets expectations .
707 */
708 bool bResult = stageManager.PopPage(true, true);
709 EXPECT_EQ(stageNode->GetChildren().size(), 4);
710 EXPECT_TRUE(bResult);
711
712 stageManager.PopPage(true, false);
713 EXPECT_EQ(stageNode->GetChildren().size(), 2);
714 }
715
716 /**
717 * @tc.name: StageManagerTest009
718 * @tc.desc: Testing PushPage and PopPage Function of StageManager work correctly.
719 * @tc.type: FUNC
720 */
721 HWTEST_F(StageTestNg, StageManagerTest009, TestSize.Level1)
722 {
723 /**
724 * @tc.steps: step1. Create StagePattern and some PagePattern.
725 */
726 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
727 auto firstNode =
728 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
729 auto secondNode =
730 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
731 auto thirdNode =
732 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
733 auto fourthNode =
734 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
735
736 /**
737 * @tc.steps: step2. Create a StageManager based on stageNode.
738 */
739 StageManager stageManager(stageNode);
740
741 /**
742 * @tc.steps: step3. PopPage.
743 * @tc.expected: Expected no child failed.
744 */
745 EXPECT_FALSE(stageManager.PopPage());
746
747 /**
748 * @tc.steps: step4. Push a Page into StageManager.
749 * @tc.expected: Push successfully.
750 */
751 EXPECT_TRUE(stageManager.PushPage(firstNode));
752
753 /**
754 * @tc.steps: step5. Push another three Page with different parameters into StageManager.
755 * @tc.expected: Push successfully.
756 */
757 stageManager.PushPage(secondNode, false, false);
758 stageManager.PushPage(thirdNode, true, false);
759 stageManager.stageNode_->GetGeometryNode()->SetFrameSize(SizeF(1.0f, 1.0f));
760 stageManager.PushPage(fourthNode, false, true);
761 EXPECT_EQ(stageNode->GetChildren().size(), 4);
762
763 /**
764 * @tc.steps: step6. Push an exist page.
765 * @tc.expected: StageNode size not changed.
766 */
767 stageManager.PushPage(secondNode);
768 EXPECT_EQ(stageNode->GetChildren().size(), 4);
769
770 /**
771 * @tc.steps: step7. PopPage with different parameters.
772 * @tc.expected: removeChild meets expectations .
773 */
774 bool bResult = stageManager.PopPage(true, false);
775 EXPECT_EQ(stageNode->GetChildren().size(), 3);
776 EXPECT_TRUE(bResult);
777 }
778
779 /**
780 * @tc.name: StageManagerTest010
781 * @tc.desc: Testing GetPageById Function of StageManager work correctly.
782 * @tc.type: FUNC
783 */
784 HWTEST_F(StageTestNg, StageManagerTest010, TestSize.Level1)
785 {
786 /**
787 * @tc.steps: step1. Create StagePattern and some PagePattern.
788 */
789 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
790 auto firstNode =
791 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
792 auto secondNode =
793 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
794 auto thirdNode =
795 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
796 auto fourthNode =
797 FrameNode::CreateFrameNode("4", 4, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
798
799 /**
800 * @tc.steps: step2. Create a StageManager based on stageNode.
801 */
802 StageManager stageManager(stageNode);
803
804 /**
805 * @tc.steps: step3. PopPage.
806 * @tc.expected: Expected no child failed.
807 */
808 EXPECT_FALSE(stageManager.PopPage());
809
810 /**
811 * @tc.steps: step4. Push a Page into StageManager.
812 * @tc.expected: Push successfully.
813 */
814 EXPECT_TRUE(stageManager.PushPage(firstNode));
815
816 /**
817 * @tc.steps: step5. Push another three Page with different parameters into StageManager.
818 * @tc.expected: Push successfully.
819 */
820 stageManager.PushPage(secondNode, false, false);
821 stageManager.PushPage(thirdNode, true, false);
822 stageManager.stageNode_->GetGeometryNode()->SetFrameSize(SizeF(1.0f, 1.0f));
823 stageManager.PushPage(fourthNode, false, true);
824 EXPECT_EQ(stageNode->GetChildren().size(), 4);
825
826 /**
827 * @tc.steps: step6. GetPageById(0).
828 * @tc.expected: Get successfully.
829 */
830 auto pageNode = stageManager.GetPageById(0);
831
832 EXPECT_EQ(pageNode->tag_, firstNode->tag_);
833
834 /**
835 * @tc.steps: step6. GetPageById(other).
836 * @tc.expected: Get nullptr.
837 */
838 pageNode = stageManager.GetPageById(5);
839 EXPECT_FALSE(pageNode);
840 }
841
842 /**
843 * @tc.name: StageManagerTest011
844 * @tc.desc: Testing InsertPage Function of StageManager work correctly.
845 * @tc.type: FUNC
846 */
847 HWTEST_F(StageTestNg, StageManagerTest011, TestSize.Level1)
848 {
849 /**
850 * @tc.steps: step1. Create StagePattern and some PagePattern.
851 */
852 auto stageNode = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
853 auto firstNode =
854 FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
855 auto secondNode =
856 FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
857 auto thirdNode =
858 FrameNode::CreateFrameNode("3", 3, AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()));
859
860 /**
861 * @tc.steps: step2. Create a StageManager based on stageNode.
862 */
863 StageManager stageManager(stageNode);
864
865 /**
866 * @tc.steps: step3. Insert page bellow Top when stageNode has no child.
867 * @tc.expected: Expected insert failed.
868 */
869 EXPECT_FALSE(stageManager.InsertPage(firstNode, true));
870 EXPECT_EQ(stageNode->GetChildren().size(), 0);
871
872 /**
873 * @tc.steps: step4. Insert page to bottom when stageNode has no child.
874 * @tc.expected: Expected insert failed.
875 */
876 EXPECT_FALSE(stageManager.InsertPage(firstNode, false));
877 EXPECT_EQ(stageNode->GetChildren().size(), 0);
878
879 /**
880 * @tc.steps: step5. Push a Page into StageManager.
881 * @tc.expected: Push successfully.
882 */
883 EXPECT_TRUE(stageManager.PushPage(firstNode));
884 EXPECT_EQ(stageNode->GetChildren().size(), 1);
885 EXPECT_EQ(stageNode->GetFirstChild(), firstNode);
886
887 /**
888 * @tc.steps: step6. Insert page bellow Top when stageNode has child.
889 * @tc.expected: Expected insert success.
890 */
891 EXPECT_TRUE(stageManager.InsertPage(secondNode, true));
892 EXPECT_EQ(stageNode->GetChildren().size(), 2);
893 EXPECT_EQ(stageNode->GetFirstChild(), secondNode);
894
895 /**
896 * @tc.steps: step7. Insert page to bottom when stageNode has child.
897 * @tc.expected: Expected insert success.
898 */
899 EXPECT_TRUE(stageManager.InsertPage(thirdNode, false));
900 EXPECT_EQ(stageNode->GetChildren().size(), 3);
901 EXPECT_EQ(stageNode->GetFirstChild(), thirdNode);
902 }
903
904 /**
905 * @tc.name: PagePatternTest001
906 * @tc.desc: Testing OnDirtyLayoutWrapperSwap of PagePattern work correctly.
907 * @tc.type: FUNC
908 */
909 HWTEST_F(StageTestNg, PagePatternTest001, TestSize.Level1)
910 {
911 /**
912 * @tc.steps: step1. Create a PagePattern.
913 */
914 PagePattern pattern(AceType::MakeRefPtr<PageInfo>());
915 /**
916 * @tc.steps: step2. Calling the SetFirstBuildCallback function.
917 * @tc.expected: The callback firstBuildCallback_ in the pagePattern not nullptr.
918 */
919 pattern.SetFirstBuildCallback(std::move(FLAG_FUNC));
920 EXPECT_NE(pattern.firstBuildCallback_, nullptr);
921 /**
922 * @tc.steps: step3. try call OnDirtyLayoutWrapperSwap with different condition.
923 * @tc.expected: the callback firstBuildCallback_ in the pagePattern cleared.
924 */
925 DirtySwapConfig config;
926 pattern.OnDirtyLayoutWrapperSwap(nullptr, config);
927 pattern.isFirstLoad_ = true;
928 pattern.OnDirtyLayoutWrapperSwap(nullptr, config);
929 pattern.OnDirtyLayoutWrapperSwap(nullptr, config);
930 EXPECT_EQ(flag, 1);
931 /**
932 * @tc.steps: step4. Call SetFirstBuildCallback again.
933 * @tc.expected: The callback will be executed immediately.
934 */
935 pattern.SetFirstBuildCallback(std::move(FLAG_FUNC));
936 EXPECT_EQ(flag, 2);
937 /**
938 * @tc.steps: step4. Call SetFirstBuildCallback again and don's set func.
939 * @tc.expected: The callback won't be executed.
940 */
941 pattern.SetFirstBuildCallback(nullptr);
942 EXPECT_EQ(flag, 2);
943 }
944
945 /**
946 * @tc.name: PagePatternTest002
947 * @tc.desc: Testing BuildSharedTransitionMap of PagePattern work correctly.
948 * @tc.type: FUNC
949 */
950 HWTEST_F(StageTestNg, PagePatternTest002, TestSize.Level1)
951 {
952 /**
953 * @tc.steps: step1. Create a parent and some child node ,config the page.
954 */
955 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
956 auto child = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
957 child->GetRenderContext()->SetShareId("shareId");
958 auto child2 = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 2, AceType::MakeRefPtr<StagePattern>());
959 auto child3 = CustomNode::CreateCustomNode(3, "child");
960 node->AddChild(child);
961 node->AddChild(child2);
962 node->AddChild(child3);
963 PagePattern pattern(AceType::MakeRefPtr<PageInfo>());
964 pattern.AttachToFrameNode(node);
965 /**
966 * @tc.steps: step2. Calling the BuildSharedTransitionMap function.
967 * @tc.expected: The property sharedTransitionMap_ in the pagePattern size meets expectations.
968 */
969 pattern.BuildSharedTransitionMap();
970 EXPECT_EQ(pattern.sharedTransitionMap_.size(), 1);
971 }
972
973 /**
974 * @tc.name: PagePatternTest003
975 * @tc.desc: Testing ProcessHideState And ProcessShowState of PagePattern work correctly.
976 * @tc.type: FUNC
977 */
978 HWTEST_F(StageTestNg, PagePatternTest003, TestSize.Level1)
979 {
980 /**
981 * @tc.steps: step1. Create some node and PagePattern.
982 */
983 auto parent = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
984 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
985 auto child = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 2, AceType::MakeRefPtr<StagePattern>());
986 parent->AddChild(node);
987 node->AddChild(child);
988 child->GetRenderContext()->SetShareId("shareId");
989 PagePattern pattern(AceType::MakeRefPtr<PageInfo>());
990 pattern.AttachToFrameNode(node);
991
992 /**
993 * @tc.steps: step2. Calling the ProcessShowState function.
994 * @tc.expected: Call node isActive function return true.
995 */
996 pattern.ProcessShowState();
997 EXPECT_TRUE(node->IsActive());
998
999 /**
1000 * @tc.steps: step3. Calling the ProcessHideState function.
1001 * @tc.expected: Call node isActive function return false.
1002 */
1003 pattern.ProcessHideState();
1004 EXPECT_FALSE(node->IsActive());
1005 }
1006
1007 /**
1008 * @tc.name: PagePatternTest004
1009 * @tc.desc: Testing the Show and Hide Related Methods of PagePattern.
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(StageTestNg, PagePatternTest004, TestSize.Level1)
1013 {
1014 Container::Current()->state_ = Frontend::State::ON_SHOW;
1015 /**
1016 * @tc.steps: step1. Create some node and PagePattern.
1017 */
1018 auto parent = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
1019 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
1020 auto child = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 2, AceType::MakeRefPtr<StagePattern>());
1021 parent->AddChild(node);
1022 node->AddChild(child);
1023 PagePattern pattern(AceType::MakeRefPtr<PageInfo>());
1024 pattern.AttachToFrameNode(node);
1025 /**
1026 * @tc.steps: step2. Calling the MarkRenderDone function.
1027 * @tc.expected: The property isRenderDone_ in the pagePattern is true
1028 */
1029 pattern.MarkRenderDone();
1030 EXPECT_TRUE(pattern.isRenderDone_);
1031 /**
1032 * @tc.steps: step3. Calling the OnShow and OnHide.
1033 * @tc.expected: The property isOnShow_ meets expectations.
1034 */
1035 pattern.OnShow();
1036 EXPECT_TRUE(pattern.isOnShow_);
1037 pattern.OnHide();
1038 EXPECT_FALSE(pattern.isOnShow_);
1039 /**
1040 * @tc.steps: step4. set show hide callback and call show hide again.
1041 * @tc.expected: The callback call times meets expectation.
1042 */
1043 pattern.SetOnPageShow(std::move(FLAG_FUNC));
1044 pattern.SetOnPageHide(std::move(FLAG_FUNC));
1045 pattern.OnShow();
1046 pattern.OnHide();
1047 EXPECT_EQ(flag, 2);
1048 }
1049
1050 /**
1051 * @tc.name: PagePatternTest005
1052 * @tc.desc: Test the PageTransition related functions in the PagePattern work correctly.
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(StageTestNg, PagePatternTest005, TestSize.Level1)
1056 {
1057 /**
1058 * @tc.steps: step1. Create some node and PagePattern.
1059 */
1060 auto parent = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
1061 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
1062 auto child = CustomMeasureLayoutNode::CreateCustomMeasureLayoutNode(2, "child");
1063 parent->AddChild(node);
1064 node->AddChild(child);
1065 auto pattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1066 pattern->AttachToFrameNode(node);
1067 pattern->ReloadPage();
1068
1069 /**
1070 * @tc.steps: step2. Create PageTransitionEffect with option.
1071 */
1072 PageTransitionOption option;
1073 option.routeType = RouteType::POP;
1074 auto effect = AceType::MakeRefPtr<PageTransitionEffect>(PageTransitionType::ENTER, option);
1075
1076 /**
1077 * @tc.steps: step3. Calling the AddPageTransition function.
1078 * @tc.expected: Calling the GetTopTransition function returned not nullptr.
1079 */
1080 pattern->AddPageTransition(effect);
1081 EXPECT_NE(pattern->GetTopTransition(), nullptr);
1082
1083 /**
1084 * @tc.steps: step4. Calling the TriggerPageTransition function and StopPageTransition function.
1085 * @tc.expected: Attribute pageTransitionFinish_ not nullptr.
1086 */
1087 pattern->TriggerPageTransition(PageTransitionType::NONE, FLAG_FUNC);
1088 pattern->StopPageTransition();
1089 EXPECT_EQ(flag, 1);
1090
1091 /**
1092 * @tc.steps: step5. SetUserCallback and recall TriggerPageTransition and StopPageTransition.
1093 */
__anonf0e2b0460302(RouteType routeType, const float& value) 1094 effect->SetUserCallback([](RouteType routeType, const float& value) {});
1095 pattern->SetPageTransitionFunc(std::move(FLAG_FUNC));
1096 pattern->TriggerPageTransition(PageTransitionType::ENTER_POP, FLAG_FUNC);
1097 pattern->StopPageTransition();
1098 EXPECT_EQ(flag, 3);
1099 /**
1100 * @tc.steps: step6.change some params ,recall TriggerPageTransition and StopPageTransition.
1101 * @tc.expected: The FLAG_FUNC call times meets expectation.
1102 */
1103 auto innerEffect = pattern->FindPageTransitionEffect(PageTransitionType::ENTER_POP);
1104 ASSERT_NE(effect, nullptr);
1105 innerEffect->animationOption_.delay = -1;
1106 pattern->TriggerPageTransition(PageTransitionType::ENTER_POP, FLAG_FUNC);
1107 pattern->StopPageTransition();
1108 EXPECT_EQ(flag, 5);
1109 /**
1110 * @tc.steps: step7.Calling the ClearPageTransitionEffect function.
1111 * @tc.expected: The GetTopTransition function returns a nullptr.
1112 */
1113 pattern->ClearPageTransitionEffect();
1114 EXPECT_EQ(pattern->GetTopTransition(), nullptr);
1115 }
1116
1117 /**
1118 * @tc.name: PagePatternTest006
1119 * @tc.desc: Testing AddJsAnimator And GetJsAnimator of PagePattern work correctly.
1120 * @tc.type: FUNC
1121 */
1122 HWTEST_F(StageTestNg, PagePatternTest006, TestSize.Level1)
1123 {
1124 /**
1125 * @tc.steps: step1. Create PagePattern.
1126 */
1127 PagePattern pattern(AceType::MakeRefPtr<PageInfo>());
1128
1129 /**
1130 * @tc.steps: step2. Create AnimatorInfo.
1131 */
1132 auto animatorInfo = AceType::MakeRefPtr<Framework::AnimatorInfo>();
1133
1134 /**
1135 * @tc.steps: step3. Calling the GetJsAnimator function in the PagePattern.
1136 * @tc.expected: The GetJsAnimator function returned nullptr;
1137 */
1138 EXPECT_EQ(pattern.GetJsAnimator(TEST_ANIMATOR_ID), nullptr);
1139
1140 /**
1141 * @tc.steps: step4. Calling the SetAnimator function in the PagePattern.
1142 * @tc.expected: The GetJsAnimator function returned not nullptr;
1143 */
1144 animatorInfo->SetAnimator(AceType::MakeRefPtr<Animator>(TEST_ANIMATOR_ID.c_str()));
1145 pattern.AddJsAnimator(TEST_ANIMATOR_ID, animatorInfo);
1146 EXPECT_NE(pattern.GetJsAnimator(TEST_ANIMATOR_ID), nullptr);
1147 }
1148 /**
1149 * @tc.name: PagePatternTest007
1150 * @tc.desc: Test the PagePattern related functions in the PagePattern work correctly.
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(StageTestNg, PagePatternTest007, TestSize.Level1)
1154 {
1155 /**
1156 * @tc.steps: step1. Create some node and PagePattern.
1157 */
1158 auto parent = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
1159 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
1160 auto child = CustomMeasureLayoutNode::CreateCustomMeasureLayoutNode(2, "child");
1161 parent->AddChild(node);
1162 node->AddChild(child);
1163 auto pattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1164 pattern->AttachToFrameNode(node);
1165 pattern->ReloadPage();
1166
1167 /**
1168 * @tc.steps: step2. add Element to nodeAnimatablePropertyMap_.
1169 * @tc.expected: GetAnimatablePropertyFloat seccuess.
1170 */
1171 auto FRAME_NODE = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<Pattern>());
1172 FRAME_NODE->nodeAnimatablePropertyMap_.emplace(
1173 "pageTransitionProperty", AceType::MakeRefPtr<NodeAnimatablePropertyBase>());
1174 pattern->frameNode_ = FRAME_NODE;
1175 pattern->StopPageTransition();
1176 EXPECT_TRUE(FRAME_NODE->GetAnimatablePropertyFloat("pageTransitionProperty"));
1177
1178 /**
1179 * @tc.steps: step3. test BeforeCreateLayoutWrapper.
1180 */
1181 auto pipeline = PipelineContext::GetCurrentContext();
1182 pattern->BeforeCreateLayoutWrapper();
1183 EXPECT_FALSE(pipeline->GetInstallationFree());
1184
1185 pipeline->windowManager_ = AceType::MakeRefPtr<WindowManager>();
1186 pipeline->safeAreaManager_->keyboardSafeAreaEnabled_ = true;
__anonf0e2b0460402() 1187 pipeline->windowManager_->windowGetModeCallback_ = []() -> WindowMode { return WindowMode::WINDOW_MODE_FLOATING; };
1188 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
1189 auto inset = pipeline->GetSafeArea();
1190 inset.bottom_.start = 0;
1191 inset.bottom_.end = 1;
1192 pattern->BeforeCreateLayoutWrapper();
1193 EXPECT_FALSE(pipeline->GetInstallationFree());
1194
1195 pipeline->SetInstallationFree(1);
1196 pattern->BeforeCreateLayoutWrapper();
1197 EXPECT_TRUE(pipeline->GetInstallationFree());
1198
1199 /**
1200 * @tc.steps: step4. coverage AvoidKeyboard.
1201 * @tc.expected: true.
1202 */
1203 pipeline->safeAreaManager_->keyboardSafeAreaEnabled_ = true;
1204 bool bResult = pattern->AvoidKeyboard();
1205 EXPECT_TRUE(bResult);
1206 }
1207
1208 /**
1209 * @tc.name: PagePatternTest008
1210 * @tc.desc: Test the PagePattern related functions in the PagePattern work correctly.
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(StageTestNg, PagePatternTest008, TestSize.Level1)
1214 {
1215 /**
1216 * @tc.steps: step1. Create some node and PagePattern.
1217 */
1218 auto parent = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<StagePattern>());
1219 auto node = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 1, AceType::MakeRefPtr<StagePattern>());
1220 auto child = CustomMeasureLayoutNode::CreateCustomMeasureLayoutNode(2, "child");
1221 parent->AddChild(node);
1222 node->AddChild(child);
1223 auto pattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1224 pattern->AttachToFrameNode(node);
1225 pattern->ReloadPage();
1226
1227 /**
1228 * @tc.steps: step2. add Element to nodeAnimatablePropertyMap_.
1229 * @tc.expected: GetAnimatablePropertyFloat seccuess.
1230 */
1231 auto FRAME_NODE = FrameNode::CreateFrameNode(FRAME_NODE_TAG, 0, AceType::MakeRefPtr<Pattern>());
1232 FRAME_NODE->nodeAnimatablePropertyMap_.emplace(
1233 "pageTransitionProperty", AceType::MakeRefPtr<NodeAnimatablePropertyBase>());
1234 pattern->frameNode_ = FRAME_NODE;
1235 pattern->StopPageTransition();
1236 EXPECT_TRUE(FRAME_NODE->GetAnimatablePropertyFloat("pageTransitionProperty"));
1237
1238 /**
1239 * @tc.steps: step3. create safeAreaInsets_ .
1240 * @tc.expected: create seccuessful.
1241 */
1242 auto pipeline = MockPipelineContext::GetCurrentContext();
1243 pipeline->SetInstallationFree(0);
1244 SafeAreaInsets::Inset insetleft;
1245 insetleft.end = 5;
1246 SafeAreaInsets::Inset insetTop;
1247 insetTop.end = 1;
1248 SafeAreaInsets::Inset insetRight;
1249 SafeAreaInsets::Inset insetBottom;
1250 insetBottom.start = RK356_HEIGHT - 1;
1251 insetBottom.end = RK356_HEIGHT;
1252 pipeline->safeAreaManager_->cutoutSafeArea_ = SafeAreaInsets(insetleft, insetTop, insetRight, insetBottom);
1253 auto host = pattern->GetHost();
1254 auto props = host->GetLayoutProperty();
1255 props->UpdateSafeAreaInsets(pipeline->safeAreaManager_->cutoutSafeArea_);
1256 EXPECT_TRUE(props->GetSafeAreaInsets());
1257
1258 /**
1259 * @tc.steps: step4. test BeforeCreateLayoutWrapper .
1260 * @tc.expected: GetInstallationFree is true.
1261 */
1262 pattern->BeforeCreateLayoutWrapper();
1263 EXPECT_FALSE(pipeline->GetInstallationFree());
1264
1265 /**
1266 * @tc.steps: step5. coverage AvoidKeyboard.
1267 * @tc.expected: true.
1268 */
1269 pipeline->safeAreaManager_->keyboardSafeAreaEnabled_ = true;
1270 bool bResult = pattern->AvoidKeyboard();
1271 EXPECT_TRUE(bResult);
1272
1273 /**
1274 * @tc.steps: step5. set keyboardInset_ to button.
1275 * @tc.expected: set success and Valid().
1276 */
1277 pipeline->GetSafeAreaManager()->keyboardInset_ = SafeAreaInsets::Inset(insetBottom);
1278 pattern->BeforeCreateLayoutWrapper();
1279 EXPECT_TRUE(pipeline->GetSafeAreaManager()->GetKeyboardInset().IsValid());
1280 }
1281
1282 /**
1283 * @tc.name: PageTransitionModelTest001
1284 * @tc.desc: Testing .
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(StageTestNg, PageTransitionModelTest001, TestSize.Level1)
1288 {
1289 auto stageNode = FrameNode::CreateFrameNode(
1290 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1291 stageNode->pattern_ = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1292 ViewStackProcessor::GetInstance()->SetPageNode(stageNode);
1293
1294 /**
1295 * @tc.steps: step1. Create.
1296 * @tc.expected: pageTransitionEffects_ clear;
1297 */
1298 PageTransitionModelNG pageTransitionModel;
1299 pageTransitionModel.Create();
1300 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->pageTransitionEffects_.size(), 0);
1301
1302 pageTransitionModel.Pop();
1303
1304 /**
1305 * @tc.steps: step2. CreateTransition.
1306 * @tc.expected: pageTransitionEffects_ add;
1307 */
1308 PageTransitionOption option;
1309 pageTransitionModel.CreateTransition(PageTransitionType::ENTER, option);
1310 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->pageTransitionEffects_.size(), 1);
1311
1312 /**
1313 * @tc.steps: step3. SetOpacityEffect.
1314 * @tc.expected: set Success;
1315 */
1316 pageTransitionModel.SetOpacityEffect(0.0);
1317 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->GetTopTransition()->opacity_, 0.0);
1318
1319 pageTransitionModel.SetOpacityEffect(10);
1320 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->GetTopTransition()->opacity_, 10);
1321
1322 /**
1323 * @tc.steps: step4. SetScaleEffect.
1324 * @tc.expected: set Success;
1325 */
1326 ScaleOptions scale(5.0, 6, 7, CalcDimension(), CalcDimension());
1327 pageTransitionModel.SetScaleEffect(scale);
1328 EXPECT_TRUE(stageNode->GetPattern<PagePattern>()->GetTopTransition()->scale_ == scale);
1329
1330 /**
1331 * @tc.steps: step5. SetTranslateEffect.
1332 * @tc.expected: set Success;
1333 */
1334 TranslateOptions transop(5.0, 6, 7);
1335 pageTransitionModel.SetTranslateEffect(transop);
1336 EXPECT_TRUE(stageNode->GetPattern<PagePattern>()->GetTopTransition()->translate_ == transop);
1337
1338 /**
1339 * @tc.steps: step6. SetSlideEffect.
1340 * @tc.expected: set Success;
1341 */
1342 pageTransitionModel.SetSlideEffect(SlideEffect::NONE);
1343 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->GetTopTransition()->slide_, SlideEffect::NONE);
1344
1345 /**
1346 * @tc.steps: step7. SetOnEnter.
1347 * @tc.expected: set Success;
1348 */
1349 int iTemp = 0;
__anonf0e2b0460502(RouteType type, const float& y) 1350 auto myLambda = [&iTemp](RouteType type, const float& y) { iTemp++; };
1351 pageTransitionModel.SetOnEnter(myLambda);
1352 stageNode->GetPattern<PagePattern>()->GetTopTransition()->userCallback_(RouteType::PUSH, 2);
1353 EXPECT_EQ(iTemp, 1);
1354
1355 /**
1356 * @tc.steps: step8. SetOnExit.
1357 * @tc.expected: set Success;
1358 */
__anonf0e2b0460602(RouteType type, const float& y) 1359 auto myLambda2 = [&iTemp](RouteType type, const float& y) { iTemp--; };
1360 pageTransitionModel.SetOnExit(myLambda2);
1361 stageNode->GetPattern<PagePattern>()->GetTopTransition()->userCallback_(RouteType::PUSH, 2);
1362 EXPECT_EQ(iTemp, 0);
1363 }
1364
1365 /**
1366 * @tc.name: PageTransitionModelTest002
1367 * @tc.desc: Testing .
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(StageTestNg, PageTransitionModelTest002, TestSize.Level1)
1371 {
1372 auto stageNode = FrameNode::CreateFrameNode(
1373 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1374 stageNode->pattern_ = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1375 ViewStackProcessor::GetInstance()->SetPageNode(stageNode);
1376 PageTransitionModelNG pageTransitionModel;
1377 PageTransitionOption option;
1378 pageTransitionModel.CreateTransition(PageTransitionType::ENTER, option);
1379 /**
1380 * @tc.steps: step1. SetSlideEffect is START.
1381 * @tc.expected: set Success;
1382 */
1383 pageTransitionModel.SetSlideEffect(SlideEffect::START);
1384 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->GetTopTransition()->slide_, SlideEffect::START);
1385
1386 /**
1387 * @tc.steps: step2. SetSlideEffect is END.
1388 * @tc.expected: set Success;
1389 */
1390 pageTransitionModel.SetSlideEffect(SlideEffect::END);
1391 EXPECT_EQ(stageNode->GetPattern<PagePattern>()->GetTopTransition()->slide_, SlideEffect::END);
1392 }
1393
1394 /**
1395 * @tc.name: StageLayoutAlgorithmTest001
1396 * @tc.desc: Testing .
1397 * @tc.type: FUNC
1398 */
1399 HWTEST_F(StageTestNg, StageLayoutAlgorithmTest001, TestSize.Level1)
1400 {
1401 /**
1402 * @tc.steps: step1. creat a layoutwrapper and SetLayoutAlgorithm for it.
1403 */
1404 auto rowFrameNode = FrameNode::CreateFrameNode("test", 0, AceType::MakeRefPtr<StagePattern>());
1405 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
1406 RefPtr<LayoutWrapperNode> layoutWrapper =
1407 AceType::MakeRefPtr<LayoutWrapperNode>(rowFrameNode, geometryNode, rowFrameNode->GetLayoutProperty());
1408
1409 auto rowLayoutPattern = rowFrameNode->GetPattern<StagePattern>();
1410 ASSERT_NE(rowLayoutPattern, nullptr);
1411 auto rowLayoutAlgorithm = rowLayoutPattern->CreateLayoutAlgorithm();
1412 ASSERT_NE(rowLayoutAlgorithm, nullptr);
1413 layoutWrapper->SetLayoutAlgorithm(AccessibilityManager::MakeRefPtr<LayoutAlgorithmWrapper>(rowLayoutAlgorithm));
1414
1415 /**
1416 * @tc.steps: step2. layout parameter initialization.
1417 */
1418 LayoutConstraintF parentLayoutConstraint;
1419 parentLayoutConstraint.maxSize = CONTAINER_SIZE;
1420 parentLayoutConstraint.percentReference = CONTAINER_SIZE;
1421 parentLayoutConstraint.selfIdealSize.SetSize(SizeF(RK356_WIDTH, ROW_HEIGHT));
1422 PaddingProperty noPadding;
1423 noPadding.left = CalcLength(NOPADDING);
1424 noPadding.right = CalcLength(NOPADDING);
1425 noPadding.top = CalcLength(NOPADDING);
1426 noPadding.bottom = CalcLength(NOPADDING);
1427
1428 /**
1429 * @tc.steps: step3. Perform element updates.
1430 */
1431 layoutWrapper->GetLayoutProperty()->UpdatePadding(noPadding);
1432 layoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(parentLayoutConstraint);
1433 layoutWrapper->GetLayoutProperty()->UpdateContentConstraint();
1434
1435 /**
1436 * @tc.steps: step4. creat a childLayoutWrapper and add to layoutWrapper.
1437 */
1438 auto childLayoutWrapper = CreatChildlayoutWrapper();
1439 layoutWrapper->AppendChild(childLayoutWrapper);
1440
1441 /**
1442 * @tc.steps: step5. call Measure and Layout.
1443 * @tc.expected: Set FrameOffset Success.
1444 */
1445 StageLayoutAlgorithm stageLayoutAlgorithm;
1446 stageLayoutAlgorithm.Measure(AccessibilityManager::RawPtr(layoutWrapper));
1447 stageLayoutAlgorithm.Layout(AccessibilityManager::RawPtr(layoutWrapper));
1448 bool bEqual =
1449 childLayoutWrapper->GetGeometryNode()->GetFrameOffset() ==
1450 OffsetF(stageLayoutAlgorithm.childInsets_.left_.Length(), stageLayoutAlgorithm.childInsets_.top_.Length());
1451 EXPECT_TRUE(bEqual);
1452 }
1453
1454 /**
1455 * @tc.name: PagePatternTest009
1456 * @tc.desc: test OnBackPressed
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(StageTestNg, PagePatternTest009, TestSize.Level1)
1460 {
1461 const auto& pageNode = ViewStackProcessor::GetInstance()->GetPageNode();
1462 auto pattern = pageNode->GetPattern<PagePattern>();
1463 auto result = pattern->OnBackPressed();
1464 EXPECT_EQ(result, false);
1465 }
1466
1467 /**
1468 * @tc.name: PagePatternTest010
1469 * @tc.desc: test OnBackPressed
1470 * @tc.type: FUNC
1471 */
1472 HWTEST_F(StageTestNg, PagePatternTest010, TestSize.Level1)
1473 {
1474 const auto& pageNode = ViewStackProcessor::GetInstance()->GetPageNode();
1475 auto pattern = pageNode->GetPattern<PagePattern>();
1476 pattern->isPageInTransition_ = true;
1477 auto result = pattern->OnBackPressed();
1478 EXPECT_EQ(result, true);
1479 }
1480
1481 /**
1482 * @tc.name: PagePatternTest011
1483 * @tc.desc: test OnBackPressed
1484 * @tc.type: FUNC
1485 */
1486 HWTEST_F(StageTestNg, PagePatternTest011, TestSize.Level1)
1487 {
1488 const auto& pageNode = ViewStackProcessor::GetInstance()->GetPageNode();
1489 auto pattern = pageNode->GetPattern<PagePattern>();
__anonf0e2b0460702() 1490 auto backPressedFunc = []() -> bool { return false; };
1491 pattern->isPageInTransition_ = false;
1492 pattern->SetOnBackPressed(backPressedFunc);
1493 auto result = pattern->OnBackPressed();
1494 EXPECT_EQ(result, false);
1495 }
1496
1497 /**
1498 * @tc.name: PagePatternTest012
1499 * @tc.desc: test OnBackPressed
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(StageTestNg, PagePatternTest012, TestSize.Level1)
1503 {
1504 const auto& pageNode = ViewStackProcessor::GetInstance()->GetPageNode();
1505 auto pattern = pageNode->GetPattern<PagePattern>();
__anonf0e2b0460802() 1506 auto backPressedFunc = []() -> bool { return false; };
1507 pattern->isPageInTransition_ = false;
1508 pattern->SetOnBackPressed(backPressedFunc);
1509 auto overlayManagernode = FrameNode::CreateFrameNode(
1510 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1511 auto overlayManger = AceType::MakeRefPtr<OverlayManager>(overlayManagernode);
1512 pattern->overlayManager_ = overlayManger;
1513 auto result = pattern->OnBackPressed();
1514 EXPECT_EQ(result, false);
1515 }
1516
1517 /**
1518 * @tc.name: PagePatternTest015
1519 * @tc.desc: test OnBackPressed
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(StageTestNg, PagePatternTest015, TestSize.Level1)
1523 {
1524 auto stageNode = FrameNode::CreateFrameNode(
1525 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1526 auto testStageManager = AceType::MakeRefPtr<StageManager>(stageNode);
1527 auto UInode = AceType::DynamicCast<NG::UINode>(testStageManager);
1528 testStageManager->stageNode_->children_.push_back(UInode);
1529 testStageManager->stageInTrasition_ = true;
1530 auto nodeTest = testStageManager->GetPrevPageWithTransition();
1531 SUCCEED();
1532 }
1533
1534 /**
1535 * @tc.name: PagePatternTest016
1536 * @tc.desc: test OnBackPressed
1537 * @tc.type: FUNC
1538 */
1539 HWTEST_F(StageTestNg, PagePatternTest016, TestSize.Level1)
1540 {
1541 auto stageNode = FrameNode::CreateFrameNode(
1542 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1543 auto testStageManager = AceType::MakeRefPtr<StageManager>(stageNode);
1544 auto UInode = AceType::DynamicCast<NG::UINode>(testStageManager);
1545 testStageManager->stageNode_->children_.push_back(UInode);
1546 testStageManager->stageInTrasition_ = false;
1547 auto nodeTest = testStageManager->GetPrevPageWithTransition();
1548 SUCCEED();
1549 }
1550
1551 /**
1552 * @tc.name: PagePatternTest017
1553 * @tc.desc: test GetLastPageWithTransition
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(StageTestNg, PagePatternTest017, TestSize.Level1)
1557 {
1558 auto stageNode = FrameNode::CreateFrameNode(
1559 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1560 auto testStageManager = AceType::MakeRefPtr<StageManager>(stageNode);
1561 auto UInode = AceType::DynamicCast<NG::UINode>(testStageManager);
1562 testStageManager->stageNode_->children_.push_back(UInode);
1563 testStageManager->stageInTrasition_ = false;
1564 testStageManager->stageNode_->children_.clear();
1565 auto nodeTest = testStageManager->GetLastPageWithTransition();
1566 SUCCEED();
1567 }
1568
1569 /**
1570 * @tc.name: PagePatternTest018
1571 * @tc.desc: test OnBackPressed
1572 * @tc.type: FUNC
1573 */
1574 HWTEST_F(StageTestNg, PagePatternTest018, TestSize.Level1)
1575 {
1576 auto stageNode = FrameNode::CreateFrameNode(
1577 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
1578 auto testStageManager = AceType::MakeRefPtr<StageManager>(stageNode);
1579 auto UInode = AceType::DynamicCast<NG::UINode>(testStageManager);
1580 testStageManager->stageNode_->children_.push_back(UInode);
1581 testStageManager->stageInTrasition_ = false;
1582 testStageManager->stageNode_->children_.clear();
1583 auto nodeTest = testStageManager->GetPrevPageWithTransition();
1584 SUCCEED();
1585 }
1586 } // namespace OHOS::Ace::NG