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 <optional>
17 
18 #include "gtest/gtest.h"
19 #include "mock_navigation_stack.h"
20 
21 #define protected public
22 #define private public
23 #include "test/mock/base/mock_task_executor.h"
24 #include "core/components/button/button_theme.h"
25 #include "core/components_ng/base/frame_node.h"
26 #include "core/components_ng/base/ui_node.h"
27 #include "core/components_ng/pattern/navigation/navigation_model_ng.h"
28 #include "core/components_ng/pattern/navigation/navigation_pattern.h"
29 #include "core/components_ng/pattern/scroll/scroll_pattern.h"
30 #include "core/components_ng/pattern/text/text_pattern.h"
31 #include "test/mock/core/common/mock_theme_manager.h"
32 #include "test/mock/core/pipeline/mock_pipeline_context.h"
33 #include "test/mock/core/common/mock_container.h"
34 
35 using namespace testing;
36 using namespace testing::ext;
37 namespace OHOS::Ace::NG {
38 namespace {
39 constexpr float DEFAULT_ROOT_HEIGHT = 800.f;
40 constexpr float DEFAULT_ROOT_WIDTH = 480.f;
41 } // namespace
42 
43 class NavigationAnimationTest : public testing::Test {
44 public:
45     static void SetUpTestSuite();
46     static void TearDownTestSuite();
47     static void MockPipelineContextGetTheme();
48     static void RunMeasureAndLayout(RefPtr<LayoutWrapperNode>& layoutWrapper, float width = DEFAULT_ROOT_WIDTH);
49     static RefPtr<NavDestinationGroupNode> CreateDestination(const std::string name);
50     static RefPtr<NavigationGroupNode> InitNavigation();
51 };
52 
SetUpTestSuite()53 void NavigationAnimationTest::SetUpTestSuite()
54 {
55     MockPipelineContext::SetUp();
56     MockContainer::SetUp();
57     auto context = MockPipelineContext::GetCurrent();
58     if (context) {
59         context->stageManager_ = nullptr;
60     }
61 }
62 
TearDownTestSuite()63 void NavigationAnimationTest::TearDownTestSuite()
64 {
65     MockPipelineContext::TearDown();
66     MockContainer::TearDown();
67 }
68 
RunMeasureAndLayout(RefPtr<LayoutWrapperNode> & layoutWrapper,float width)69 void NavigationAnimationTest::RunMeasureAndLayout(RefPtr<LayoutWrapperNode>& layoutWrapper, float width)
70 {
71     layoutWrapper->SetActive();
72     layoutWrapper->SetRootMeasureNode();
73     LayoutConstraintF LayoutConstraint;
74     LayoutConstraint.parentIdealSize = { width, DEFAULT_ROOT_HEIGHT };
75     LayoutConstraint.percentReference = { width, DEFAULT_ROOT_HEIGHT };
76     LayoutConstraint.selfIdealSize = { width, DEFAULT_ROOT_HEIGHT };
77     LayoutConstraint.maxSize = { width, DEFAULT_ROOT_HEIGHT };
78     layoutWrapper->Measure(LayoutConstraint);
79     layoutWrapper->Layout();
80     layoutWrapper->MountToHostOnMainThread();
81 }
82 
MockPipelineContextGetTheme()83 void NavigationAnimationTest::MockPipelineContextGetTheme()
84 {
85     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
86     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
87     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<NavigationBarTheme>()));
88 }
89 
CreateDestination(const std::string name)90 RefPtr<NavDestinationGroupNode> NavigationAnimationTest::CreateDestination(const std::string name)
91 {
92     auto* stack = ViewStackProcessor::GetInstance();
93     // navDestination node
94     int32_t nodeId = stack->ClaimNodeId();
95     ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::NAVDESTINATION_VIEW_ETS_TAG, nodeId);
96     auto frameNode = NavDestinationGroupNode::GetOrCreateGroupNode(
97         V2::NAVDESTINATION_VIEW_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
98     EXPECT_NE(frameNode, nullptr);
99     auto pattern = AceType::DynamicCast<NavDestinationPattern>(frameNode->GetPattern());
100     EXPECT_NE(pattern, nullptr);
101     pattern->SetName(name);
102     auto context = AceType::MakeRefPtr<NavDestinationContext>();
103     auto pathInfo = AceType::MakeRefPtr<NavPathInfo>();
104     pathInfo->name_ = name;
105     context->SetNavPathInfo(pathInfo);
106     pattern->SetNavDestinationContext(context);
107     return frameNode;
108 }
109 
InitNavigation()110 RefPtr<NavigationGroupNode> NavigationAnimationTest::InitNavigation()
111 {
112     auto context = MockPipelineContext::GetCurrent();
113     if (!context) {
114         return nullptr;
115     }
116     MockPipelineContextGetTheme();
117 
118     NavigationModelNG navigationModel;
119     navigationModel.Create();
120     auto stack = AceType::MakeRefPtr<MockNavigationStack>();
121     navigationModel.SetNavigationStack(stack);
122     navigationModel.SetTitle("navigationModel", false);
123     RefPtr<NavigationGroupNode> navigationNode = AceType::DynamicCast<NavigationGroupNode>(
124         ViewStackProcessor::GetInstance()->Finish());
125     return navigationNode;
126 }
127 
128 /**
129  * @tc.name: NavigationInteractiveTest
130  * @tc.desc: Test push lifecycle is correct without animation
131  * @tc.type: FUNC
132  */
133 HWTEST_F(NavigationAnimationTest, NavigationInteractiveTest001, TestSize.Level1)
134 {
135     /**
136      * @tc.steps:step1.create navigation and navigation stack
137     */
138     auto navigationNode = InitNavigation();
139     ASSERT_NE(navigationNode, nullptr);
140 
141     /**
142      * @tc.steps.step2.create navDestination node pageA
143     */
144     auto navigationPattern = AceType::DynamicCast<NavigationPattern>(navigationNode->GetPattern());
145     ASSERT_NE(navigationPattern, nullptr);
146     navigationPattern->SetNavigationTransition([](const RefPtr<NavDestinationContext>& preContext,
__anonec19fbf40302(const RefPtr<NavDestinationContext>& preContext, const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) 147         const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) ->NavigationTransition {
148         NavigationTransition transition;
149         transition.isValid = true;
150         transition.interactive = true;
151         transition.transition = [](const RefPtr<NavigationTransitionProxy>& proxy) {};
152         return transition;
153     });
154 
155     /**
156      * @tc.steps: step3. add pageA and sync navigation stack
157      * @tc.expected: step3. current interactive is true
158      *
159      */
160     auto stack = navigationPattern->GetNavigationStack();
161     ASSERT_NE(stack, nullptr);
162     auto pageA = CreateDestination("pageA");
163     stack->Add("pageA", pageA);
164     navigationPattern->isCustomAnimation_ = true;
165     navigationPattern->OnModifyDone();
166     navigationPattern->MarkNeedSyncWithJsStack();
167     navigationPattern->SyncWithJsStackIfNeeded();
168     ASSERT_NE(navigationPattern->GetTopNavigationProxy(), nullptr);
169     EXPECT_TRUE(navigationPattern->GetTopNavigationProxy()->GetInteractive());
170 
171     /**
172      * @tc.steps: step3. set navigation transition callback, set interactive value false
173     */
174     navigationPattern->GetTopNavigationProxy()->hasFinished_ = true;
175     navigationPattern->isFinishInteractiveAnimation_ = true;
176     navigationPattern->SetNavigationTransition([](const RefPtr<NavDestinationContext>& preContext,
__anonec19fbf40502(const RefPtr<NavDestinationContext>& preContext, const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) 177         const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) -> NavigationTransition {
178             NavigationTransition transition;
179             transition.isValid = true;
180             transition.interactive = false;
181             transition.transition = [](const RefPtr<NavigationTransitionProxy>& proxy) {};
182             return transition;
183         });
184 
185     /**
186      * @tc.steps: step4. add pageA and sync navigation stack
187      * @tc.expected: step4. current interactive value is false
188     */
189     auto destinationB = CreateDestination("pageB");
190     stack->Add("pageB", destinationB);
191     navigationPattern->isCustomAnimation_ = true;
192     navigationPattern->OnModifyDone();
193     navigationPattern->MarkNeedSyncWithJsStack();
194     navigationPattern->SyncWithJsStackIfNeeded();
195     ASSERT_NE(navigationPattern->GetTopNavigationProxy(), nullptr);
196     EXPECT_FALSE(navigationPattern->GetTopNavigationProxy()->GetInteractive());
197 }
198 
199 /**
200  * @tc.name: NavigationInteractiveTest
201  * @tc.desc: Test cancel animation is correct or not
202  * @tc.type: FUNC
203  */
204 HWTEST_F(NavigationAnimationTest, NavigationFinishAnimation002, TestSize.Level1)
205 {
206     /**
207      * @tc.steps: step1. create navigation and navigation stack
208     */
209     auto navigationNode = InitNavigation();
210     ASSERT_NE(navigationNode, nullptr);
211 
212     auto pattern = navigationNode->GetPattern<NavigationPattern>();
213     ASSERT_NE(pattern, nullptr);
214 
215     /**
216      * @tc.steps: step2. set interactive false
217     */
218     pattern->SetNavigationTransition([](const RefPtr<NavDestinationContext>& preContext,
__anonec19fbf40702(const RefPtr<NavDestinationContext>& preContext, const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) 219         const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) -> NavigationTransition {
220         NavigationTransition transition;
221         transition.isValid = true;
222         transition.interactive = false;
223         transition.transition = [](const RefPtr<NavigationTransitionProxy>& proxy) {};
224         return transition;
225     });
226     pattern->isCustomAnimation_ = true;
227 
228     /**
229      * @tc.steps: step2. push pageA, and sync navigation stack, adn fire cancelAnimation
230      * @tc.expected: step3. current top stack is pageA
231     */
232     auto navDestinationA = CreateDestination("pageA");
233     ASSERT_NE(navDestinationA, nullptr);
234     auto stack = pattern->GetNavigationStack();
235     ASSERT_NE(stack, nullptr);
236     stack->Add("pageA", navDestinationA);
237     pattern->MarkNeedSyncWithJsStack();
238     pattern->SyncWithJsStackIfNeeded();
239     ASSERT_NE(pattern->GetTopNavigationProxy(), nullptr);
240     pattern->GetTopNavigationProxy()->FireCancelAnimation();
241     auto targetPage = stack->Get();
242     EXPECT_TRUE(targetPage == navDestinationA);
243     ASSERT_EQ(stack->Size(), 1);
244 }
245 
246 /**
247  * @tc.name: NavigationInteractiveTest
248  * @tc.desc: Test interactive value in cancel transition
249  * @tc.type: FUNC
250  */
251 HWTEST_F(NavigationAnimationTest, NavigationCancelAnimation003, TestSize.Level1)
252 {
253     /**
254      * @tc.steps: step1. create navigation node and init navigation stack
255     */
256     auto navigationNode = InitNavigation();
257     ASSERT_NE(navigationNode, nullptr);
258 
259     /**
260      * @tc.steps: step2. set interactive value true
261     */
262     auto pattern = AceType::DynamicCast<NavigationPattern>(navigationNode->GetPattern());
263     CHECK_NULL_VOID(pattern);
264     pattern->SetNavigationTransition([](const RefPtr<NavDestinationContext>& preContext,
265         const RefPtr<NavDestinationContext> topContext,
__anonec19fbf40902(const RefPtr<NavDestinationContext>& preContext, const RefPtr<NavDestinationContext> topContext, NavigationOperation operation) 266         NavigationOperation operation) -> NavigationTransition {
267             NavigationTransition transition;
268             transition.interactive = true;
269             transition.isValid = true;
270             transition.transition = [] (const RefPtr<NavigationTransitionProxy>& proxy) {};
271             return transition;
272     });
273     pattern->isCustomAnimation_ = true;
274 
275     /**
276      * @tc.steps: step3. create destination A and sync navigation
277     */
278     auto stack = pattern->GetNavigationStack();
279     EXPECT_NE(stack, nullptr);
280     stack->UpdateRecoveryList();
281     auto destinationA = CreateDestination("pageA");
282     stack->Add("pageA", destinationA);
283     pattern->UpdateNavPathList();
284     pattern->RefreshNavDestination();
285     ASSERT_NE(pattern->GetTopNavigationProxy(), nullptr);
286     pattern->GetTopNavigationProxy()->CancelInteractiveAnimation();
287     ASSERT_EQ(stack->Size(), 0);
288 }
289 
290 /**
291  * @tc.name: NavigationInteractiveTest
292  * @tc.desc: Test interactive value in cancel transition
293  * @tc.type: FUNC
294  */
295 HWTEST_F(NavigationAnimationTest, NavigationFinishAnimation004, TestSize.Level1)
296 {
297     /**
298      * @tc.steps:step1. create navigation and init navigation stack
299     */
300     auto navigationNode = InitNavigation();
301     ASSERT_NE(navigationNode, nullptr);
302 
303     /**
304      * @tc.steps: step2. set interactive false and timeout 0
305      */
306     auto pattern = AceType::DynamicCast<NavigationPattern>(navigationNode->GetPattern());
307     EXPECT_NE(pattern, nullptr);
308     pattern->SetNavigationTransition([](const RefPtr<NavDestinationContext>& preContext,
309         const RefPtr<NavDestinationContext>& topContext,
__anonec19fbf40b02(const RefPtr<NavDestinationContext>& preContext, const RefPtr<NavDestinationContext>& topContext, NavigationOperation operation) 310         NavigationOperation operation) -> NavigationTransition {
311         NavigationTransition transition;
312         transition.isValid = true;
313         transition.interactive = true;
314         transition.timeout = 0;
315         auto onTransition = [](const RefPtr<NavigationTransitionProxy>& proxy) {
316         };
317         transition.transition = std::move(onTransition);
318         transition.endCallback = [](bool isSuccess) {};
319         return transition;
320     });
321     pattern->isCustomAnimation_ = true;
322 
323     /**
324      * @tc.steps:step3. create navDestination node, and push node to stack
325      * @tc.expected: step3. get sync stack
326     */
327     auto navDestinationA = CreateDestination("pageA");
328     ASSERT_NE(navDestinationA, nullptr);
329     auto stack = pattern->GetNavigationStack();
330     ASSERT_NE(stack, nullptr);
331     stack->Add("pageA", navDestinationA);
332     pattern->MarkNeedSyncWithJsStack();
333     pattern->SyncWithJsStackIfNeeded();
334     ASSERT_EQ(stack->Size(), 1);
335     auto navBar = AceType::DynamicCast<NavBarNode>(navigationNode->GetNavBarNode());
336     ASSERT_NE(navBar, nullptr);
337     auto navBarLayoutProperty = navBar->GetLayoutProperty();
338     ASSERT_NE(navBarLayoutProperty, nullptr);
339     ASSERT_NE(navBarLayoutProperty->GetVisibilityValue(VisibleType::VISIBLE), VisibleType::INVISIBLE);
340     auto topDestination = AceType::DynamicCast<FrameNode>(stack->Get());
341     ASSERT_NE(topDestination, nullptr);
342     auto navDestinationAProperty = topDestination->GetLayoutProperty();
343     ASSERT_NE(navDestinationAProperty, nullptr);
344     ASSERT_EQ(navDestinationAProperty->GetVisibilityValue(), VisibleType::VISIBLE);
345 }
346 
347 /**
348  * @tc.name: UpdateTextNodeListAsRenderGroup
349  * @tc.desc: Test NavDestinationGroupNode::UpdateTextNodeListAsRenderGroup
350  * @tc.type: FUNC
351  */
352 HWTEST_F(NavigationAnimationTest, UpdateTextNodeListAsRenderGroup001, TestSize.Level1)
353 {
354     /**
355      * @tc.steps: step1. create navDestination.
356      */
357     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf40e02() 358         "navDestinationNode", 33, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
359     ASSERT_NE(navDestinationNode, nullptr);
360     auto proxy = AceType::MakeRefPtr<NavigationTransitionProxy>();
361     /**
362      * @tc.steps: step2. call the target function.
363      */
364     navDestinationNode->UpdateTextNodeListAsRenderGroup(true, proxy);
365 }
366 
367 /**
368  * @tc.name: UpdateTextNodeListAsRenderGroup
369  * @tc.desc: Test NavDestinationGroupNode::UpdateTextNodeListAsRenderGroup
370  * @tc.type: FUNC
371  */
372 HWTEST_F(NavigationAnimationTest, UpdateTextNodeListAsRenderGroup002, TestSize.Level1)
373 {
374     /**
375      * @tc.steps: step1. create navDestination.
376      */
377     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf40f02() 378         "navDestinationNode", 44, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
379     ASSERT_NE(navDestinationNode, nullptr);
380     auto proxy = AceType::MakeRefPtr<NavigationTransitionProxy>();
381     /**
382      * @tc.steps: step2. call the target function.
383      */
384     navDestinationNode->UpdateTextNodeListAsRenderGroup(false, proxy);
385 }
386 
387 /**
388  * @tc.name: CollectTextNodeAsRenderGroup
389  * @tc.desc: Test NavDestinationGroupNode::CollectTextNodeAsRenderGroup
390  * @tc.type: FUNC
391  */
392 HWTEST_F(NavigationAnimationTest, CollectTextNodeAsRenderGroup001, TestSize.Level1)
393 {
394     /**
395      * @tc.steps: step1. create navDestination.
396      */
397     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41002() 398         "navDestinationNode", 55, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
399     ASSERT_NE(navDestinationNode, nullptr);
400     /**
401      * @tc.steps: step2. create contentNode for navDestination and add text node to content node.
402      */
403     auto navDestinationContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVDESTINATION_CONTENT_ETS_TAG, 1,
__anonec19fbf41102() 404             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
405     ASSERT_NE(navDestinationContentNode, nullptr);
406     navDestinationNode->AddChild(navDestinationContentNode);
407     navDestinationNode->SetContentNode(navDestinationContentNode);
408     auto textNode =
__anonec19fbf41202() 409         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 66, []() { return AceType::MakeRefPtr<TextPattern>(); });
410     ASSERT_NE(textNode, nullptr);
411     navDestinationContentNode->AddChild(textNode);
412     /**
413      * @tc.steps: step3. call the target function.
414      */
415     navDestinationNode->CollectTextNodeAsRenderGroup(true);
416     ASSERT_NE(navDestinationNode->textNodeList_.size(), 0);
417 }
418 
419 /**
420  * @tc.name: ReleaseTextNodeList
421  * @tc.desc: Test NavDestinationGroupNode::ReleaseTextNodeList
422  * @tc.type: FUNC
423  */
424 HWTEST_F(NavigationAnimationTest, ReleaseTextNodeList001, TestSize.Level1)
425 {
426     /**
427      * @tc.steps: step1. create navDestination.
428      */
429     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41302() 430         "navDestinationNode", 77, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
431     ASSERT_NE(navDestinationNode, nullptr);
432     /**
433      * @tc.steps: step2. create contentNode for navDestination and add text node to content node.
434      */
435     auto navDestinationContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVDESTINATION_CONTENT_ETS_TAG, 1,
__anonec19fbf41402() 436             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
437     ASSERT_NE(navDestinationContentNode, nullptr);
438     navDestinationNode->AddChild(navDestinationContentNode);
439     navDestinationNode->SetContentNode(navDestinationContentNode);
440     auto textNode =
__anonec19fbf41502() 441         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 88, []() { return AceType::MakeRefPtr<TextPattern>(); });
442     ASSERT_NE(textNode, nullptr);
443     navDestinationContentNode->AddChild(textNode);
444     /**
445      * @tc.steps: step3. collect text nodes before release.
446      */
447     navDestinationNode->CollectTextNodeAsRenderGroup(true);
448     ASSERT_NE(navDestinationNode->textNodeList_.size(), 0);
449     /**
450      * @tc.steps: step4. call the target function.
451      */
452     navDestinationNode->ReleaseTextNodeList();
453     ASSERT_EQ(navDestinationNode->textNodeList_.size(), 0);
454 }
455 
456 /**
457  * @tc.name: TitleOpacityAnimation
458  * @tc.desc: Test NavDestinationGroupNode::TitleOpacityAnimation
459  * @tc.type: FUNC
460  */
461 HWTEST_F(NavigationAnimationTest, OpacityAnimation001, TestSize.Level1)
462 {
463     /**
464      * @tc.steps: step1. create navigation.
465      */
466     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41602() 467         "navDestinationNode", 1, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
468     ASSERT_NE(navDestinationNode, nullptr);
469     auto titleBar = TitleBarNode::GetOrCreateTitleBarNode(V2::TITLE_BAR_ETS_TAG,
__anonec19fbf41702() 470         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<Pattern>(); });
471     navDestinationNode->titleBarNode_ = titleBar;
472     auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navDestinationNode->GetTitleBarNode());
473     ASSERT_NE(titleBarNode, nullptr);
474     auto backButtonNode = FrameNode::CreateFrameNode(
475         V2::BUTTON_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
476     titleBarNode->backButton_ = backButtonNode;
477     ASSERT_NE(titleBarNode->GetBackButton(), nullptr);
478     navDestinationNode->BackButtonAnimation(false);
479     navDestinationNode->BackButtonAnimation(true);
480 }
481 
482 /**
483  * @tc.name: TitleOpacityAnimation
484  * @tc.desc: Test NavDestinationGroupNode::TitleOpacityAnimation
485  * @tc.type: FUNC
486  */
487 HWTEST_F(NavigationAnimationTest, OpacityAnimation002, TestSize.Level1)
488 {
489     /**
490      * @tc.steps: step1. create navigation.
491      */
492     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41802() 493         "navDestinationNode", 1, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
494     ASSERT_NE(navDestinationNode, nullptr);
495     auto titleBar = TitleBarNode::GetOrCreateTitleBarNode(V2::TITLE_BAR_ETS_TAG,
__anonec19fbf41902() 496         ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<Pattern>(); });
497     navDestinationNode->titleBarNode_ = titleBar;
498     auto titleBarNode = AceType::DynamicCast<TitleBarNode>(navDestinationNode->GetTitleBarNode());
499     ASSERT_NE(titleBarNode, nullptr);
500     navDestinationNode->TitleOpacityAnimation(false);
501     navDestinationNode->TitleOpacityAnimation(true);
502 }
503 
504 /**
505  * @tc.name: IsNeedContentTransition
506  * @tc.desc: Test NavDestinationGroupNode::IsNeedContentTransition
507  * @tc.type: FUNC
508  */
509 HWTEST_F(NavigationAnimationTest, IsNeedContentTransition001, TestSize.Level1)
510 {
511     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41a02() 512         "navDestinationNode", 55, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
513     ASSERT_NE(navDestinationNode, nullptr);
514 
515     auto navDestinationContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVDESTINATION_CONTENT_ETS_TAG, 1,
__anonec19fbf41b02() 516             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
517     ASSERT_NE(navDestinationContentNode, nullptr);
518     navDestinationNode->AddChild(navDestinationContentNode);
519     navDestinationNode->SetContentNode(navDestinationContentNode);
520     auto textNode =
__anonec19fbf41c02() 521         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 66, []() { return AceType::MakeRefPtr<TextPattern>(); });
522     ASSERT_NE(textNode, nullptr);
523     navDestinationContentNode->AddChild(textNode);
524 
525     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::DEFAULT);
526     bool ret = navDestinationNode->IsNeedContentTransition();
527     ASSERT_EQ(ret, true);
528     navDestinationNode->SetNavDestinationMode(NavDestinationMode::STANDARD);
529     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::CONTENT);
530     ret = navDestinationNode->IsNeedContentTransition();
531     ASSERT_EQ(ret, true);
532     navDestinationNode->SetNavDestinationMode(NavDestinationMode::DIALOG);
533     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::CONTENT);
534     ret = navDestinationNode->IsNeedContentTransition();
535     ASSERT_EQ(ret, true);
536     navDestinationNode->SetNavDestinationMode(NavDestinationMode::DIALOG);
537     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::NONE);
538     ret = navDestinationNode->IsNeedContentTransition();
539     ASSERT_EQ(ret, false);
540 }
541 
542 /**
543  * @tc.name: TransitionContentInValid
544  * @tc.desc: Test NavDestinationGroupNode::TransitionContentInValid
545  * @tc.type: FUNC
546  */
547 HWTEST_F(NavigationAnimationTest, TransitionContentInValid001, TestSize.Level1)
548 {
549     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf41d02() 550         "navDestinationNode", 55, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
551     ASSERT_NE(navDestinationNode, nullptr);
552 
553     auto navDestinationContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVDESTINATION_CONTENT_ETS_TAG, 1,
__anonec19fbf41e02() 554             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
555     ASSERT_NE(navDestinationContentNode, nullptr);
556     navDestinationNode->AddChild(navDestinationContentNode);
557     navDestinationNode->SetContentNode(navDestinationContentNode);
558     auto textNode =
__anonec19fbf41f02() 559         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 66, []() { return AceType::MakeRefPtr<TextPattern>(); });
560     ASSERT_NE(textNode, nullptr);
561     navDestinationContentNode->AddChild(textNode);
562 
563     navDestinationNode->SetNavDestinationMode(NavDestinationMode::STANDARD);
564     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::NONE);
565     bool ret = navDestinationNode->TransitionContentInValid();
566     ASSERT_EQ(ret, true);
567 
568     navDestinationNode->SetNavDestinationMode(NavDestinationMode::DIALOG);
569     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::CONTENT);
570     ret = navDestinationNode->TransitionContentInValid();
571     ASSERT_EQ(ret, false);
572 
573     navDestinationNode->SetNavDestinationMode(NavDestinationMode::STANDARD);
574     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::CONTENT);
575     ret = navDestinationNode->TransitionContentInValid();
576     ASSERT_EQ(ret, false);
577 }
578 
579 /**
580  * @tc.name: IsNeedTitleTransition
581  * @tc.desc: Test NavDestinationGroupNode::IsNeedTitleTransition
582  * @tc.type: FUNC
583  */
584 HWTEST_F(NavigationAnimationTest, IsNeedTitleTransition001, TestSize.Level1)
585 {
586     auto navDestinationNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anonec19fbf42002() 587         "navDestinationNode", 55, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
588     ASSERT_NE(navDestinationNode, nullptr);
589 
590     auto navDestinationContentNode = FrameNode::GetOrCreateFrameNode(V2::NAVDESTINATION_CONTENT_ETS_TAG, 1,
__anonec19fbf42102() 591             []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
592     ASSERT_NE(navDestinationContentNode, nullptr);
593     navDestinationNode->AddChild(navDestinationContentNode);
594     navDestinationNode->SetContentNode(navDestinationContentNode);
595     auto textNode =
__anonec19fbf42202() 596         FrameNode::GetOrCreateFrameNode(V2::TEXT_ETS_TAG, 66, []() { return AceType::MakeRefPtr<TextPattern>(); });
597     ASSERT_NE(textNode, nullptr);
598     navDestinationContentNode->AddChild(textNode);
599 
600     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::DEFAULT);
601     bool ret = navDestinationNode->IsNeedTitleTransition();
602     ASSERT_EQ(ret, true);
603 
604     navDestinationNode->SetNavDestinationMode(NavDestinationMode::STANDARD);
605     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::TITLE);
606     ret = navDestinationNode->IsNeedTitleTransition();
607     ASSERT_EQ(ret, true);
608 
609     navDestinationNode->SetNavDestinationMode(NavDestinationMode::DIALOG);
610     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::TITLE);
611     ret = navDestinationNode->IsNeedTitleTransition();
612     ASSERT_EQ(ret, false);
613 
614     navDestinationNode->SetNavDestinationMode(NavDestinationMode::STANDARD);
615     navDestinationNode->SetSystemTransitionType(NavigationSystemTransitionType::NONE);
616     ret = navDestinationNode->IsNeedTitleTransition();
617     ASSERT_EQ(ret, false);
618 }
619 }; // namespace OHOS::Ace::NG