1 /*
2  * Copyright (c) 2022 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 
20 #define protected public
21 #define private public
22 
23 #include "base/geometry/ng/offset_t.h"
24 #include "base/geometry/ng/size_t.h"
25 #include "base/memory/ace_type.h"
26 #include "core/components_ng/base/frame_node.h"
27 #include "core/components_ng/base/geometry_node.h"
28 #include "core/components_ng/manager/shared_overlay/shared_overlay_manager.h"
29 #include "core/components_ng/pattern/pattern.h"
30 #include "core/components_ng/pattern/stage/page_pattern.h"
31 #include "test/mock/core/render/mock_render_context.h"
32 
33 using namespace testing;
34 using namespace testing::ext;
35 
36 namespace OHOS::Ace::NG {
37 namespace {
38 const std::string ROOT_TAG = "root";
39 const std::string NODE_TAG = "node";
40 const std::string SHARE_ID1("id1");
41 const std::string SHARE_ID2("id2");
42 const SizeF SRC_SIZE(100.0f, 100.0f);
43 const SizeF DEST_SIZE(200.0f, 200.0f);
44 const int32_t SRC_DURATION = 500;
45 const int32_t DEST_DURATION = 1000;
46 
CreateSharedNode(const std::string & shareId,const int32_t & duration,const SizeF & frameSize)47 RefPtr<FrameNode> CreateSharedNode(const std::string& shareId, const int32_t& duration, const SizeF& frameSize)
48 {
49     auto node = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>(), false);
50     node->GetRenderContext()->SetShareId(shareId);
51     auto option = std::make_shared<SharedTransitionOption>();
52     option->curve = Curves::LINEAR;
53     option->duration = duration;
54     option->type = SharedTransitionEffectType::SHARED_EFFECT_EXCHANGE;
55     node->GetRenderContext()->SetSharedTransitionOptions(option);
56     node->GetGeometryNode()->SetFrameSize(frameSize);
57     return node;
58 }
59 } // namespace
60 
61 class SharedOverlayManagerTestNg : public testing::Test {
62 public:
SetUpTestSuite()63     static void SetUpTestSuite() {};
TearDownTestSuite()64     static void TearDownTestSuite() {};
65     void SetUp() override;
66     void TearDown() override;
67 
68 private:
69     RefPtr<SharedOverlayManager> manager_;
70     RefPtr<FrameNode> srcPage_;
71     RefPtr<FrameNode> destPage_;
72 };
73 
SetUp()74 void SharedOverlayManagerTestNg::SetUp()
75 {
76     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
77     manager_ = AceType::MakeRefPtr<SharedOverlayManager>(root);
78     srcPage_ = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(nullptr), false);
79     destPage_ = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(nullptr), false);
80 }
81 
TearDown()82 void SharedOverlayManagerTestNg::TearDown()
83 {
84     manager_.Reset();
85     srcPage_.Reset();
86     destPage_.Reset();
87 }
88 
89 /**
90  * @tc.name: SharedOverlayManagerTest001
91  * @tc.desc: There is no matching shareId, so it cannot perform sharedTransition.
92  * @tc.type: FUNC
93  * @tc.author:
94  */
95 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest001, TestSize.Level1)
96 {
97     /**
98      * @tc.steps: step1. construct a SharedOverlayManager
99      */
100     auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
101     auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
102 
103     /**
104      * @tc.steps: step2. construct two frameNodes which type is Page and pageInfo is default config
105      */
106     auto srcPageInfo = AceType::MakeRefPtr<PageInfo>();
107     auto destPageInfo = AceType::MakeRefPtr<PageInfo>();
108     auto pageSrc = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(srcPageInfo));
109     auto pageDest = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(destPageInfo));
110 
111     /**
112      * @tc.steps: step3. call StartSharedTransition
113      * @tc.expected: step3. effects_ is empty for page has no sharedTransitionEffect
114      */
115     sharedOverlayManager->StartSharedTransition(pageSrc, pageDest);
116     EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
117 
118     /**
119      * @tc.steps: step4. Add a node configured with exchange sharedTransition to source page,
120      *            and add a node with no sharedTransition to destination page
121      */
122     sharedOverlayManager->effects_.clear();
123     auto shareNodeSrc = CreateSharedNode(SHARE_ID1, SRC_DURATION, SRC_SIZE);
124     pageSrc->AddChild(shareNodeSrc);
125     pageSrc->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, shareNodeSrc);
126     auto nodeDest = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>(), false);
127     pageDest->AddChild(nodeDest);
128 
129     /**
130      * @tc.steps: step5. call StartSharedTransition
131      * @tc.expected: effects_ is empty because there is no node configured with exchange sharedTransition
132      *               in destination page
133      */
134     sharedOverlayManager->StartSharedTransition(pageSrc, pageDest);
135     EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
136 
137     /**
138      * @tc.steps: step6. Clear the nodes of dest page, and add a node configured with exchange sharedTransition
139      *            to destination page, but the shareId is different from that of the node in source page
140      */
141     sharedOverlayManager->effects_.clear();
142     pageDest->RemoveChild(nodeDest);
143     auto shareNodeDest = CreateSharedNode(SHARE_ID2, DEST_DURATION, DEST_SIZE);
144     pageDest->AddChild(shareNodeDest);
145     pageDest->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID2, shareNodeDest);
146 
147     /**
148      * @tc.steps: step7. call StartSharedTransition
149      * @tc.expected: effects_ is empty because the node in source page and the node in destination page have
150      *               different shareId
151      */
152     sharedOverlayManager->PrepareSharedTransition(pageSrc, pageDest);
153     EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
154 }
155 
156 /**
157  * @tc.name: SharedOverlayManagerTest003
158  * @tc.desc: Build a node configured with static sharedTransition in source page and perform sharedTransition
159  *           successfully
160  * @tc.type: FUNC
161  * @tc.author:
162  */
163 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest003, TestSize.Level1)
164 {
165     /**
166      * @tc.steps: step1. Add a node configured with static sharedTransition to source page
167      */
168     auto srcNodeShareId1 = CreateSharedNode(SHARE_ID1, SRC_DURATION, SRC_SIZE);
169     srcNodeShareId1->GetRenderContext()->GetSharedTransitionOption()->type =
170         SharedTransitionEffectType::SHARED_EFFECT_STATIC;
171     srcPage_->AddChild(srcNodeShareId1);
172     srcPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, srcNodeShareId1);
173 
174     /**
175      * @tc.steps: step2. call StartSharedTransition
176      * @tc.expected: effects_ has one expected effect. The node in source page has been removed and is mounted to
177      *               sharedManager
178      */
179     manager_->StartSharedTransition(srcPage_, destPage_);
180     ASSERT_EQ(manager_->effects_.size(), 1);
181     auto effect = *manager_->effects_.begin();
182     ASSERT_EQ(effect->GetType(), SharedTransitionEffectType::SHARED_EFFECT_STATIC);
183     EXPECT_EQ(effect->GetSrcSharedNode().Upgrade(), srcNodeShareId1);
184     EXPECT_EQ(effect->GetDestSharedNode().Upgrade(), nullptr);
185     EXPECT_EQ(effect->GetShareId(), SHARE_ID1);
186     ASSERT_TRUE(effect->GetOption() != nullptr);
187     EXPECT_EQ(effect->GetOption()->duration, SRC_DURATION);
188     auto staticEffect = AceType::DynamicCast<SharedTransitionStatic>(effect);
189     EXPECT_EQ(staticEffect->GetPassengerNode().Upgrade(), srcNodeShareId1);
190     ASSERT_EQ(manager_->sharedManager_->GetChildren().size(), 1);
191     EXPECT_EQ(AceType::DynamicCast<FrameNode>(manager_->sharedManager_->GetFirstChild()), srcNodeShareId1);
192     ASSERT_EQ(srcPage_->GetChildren().size(), 1);
193     EXPECT_NE(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
194 
195     /**
196      * @tc.steps: step3. Notify the controller of effect to stop so the sharedTransition can finish
197      * @tc.expected: The node mounted to sharedManager has been removed and is mounted to the original parent
198      */
199     auto controller = effect->GetController();
200     ASSERT_TRUE(controller != nullptr);
201     controller->Stop();
202     EXPECT_EQ(manager_->sharedManager_->GetChildren().size(), 0);
203     ASSERT_EQ(srcPage_->GetChildren().size(), 1);
204     EXPECT_EQ(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
205 }
206 
207 /**
208  * @tc.name: SharedOverlayManagerTest004
209  * @tc.desc: Build a node configured with static sharedTransition in destination page and perform sharedTransition
210  *           successfully
211  * @tc.type: FUNC
212  */
213 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest004, TestSize.Level1)
214 {
215     /**
216      * @tc.steps: step1. Add a node configured with static sharedTransition to destination page
217      */
218     auto destNodeShareId1 = CreateSharedNode(SHARE_ID1, DEST_DURATION, DEST_SIZE);
219     destNodeShareId1->GetRenderContext()->GetSharedTransitionOption()->type =
220         SharedTransitionEffectType::SHARED_EFFECT_STATIC;
221     destPage_->AddChild(destNodeShareId1);
222     destPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, destNodeShareId1);
223 
224     /**
225      * @tc.steps: step2. call StartSharedTransition
226      * @tc.expected: effects_ has one expected effect. The node in destination page has been removed and is mounted to
227      *               sharedManager
228      */
229     manager_->StartSharedTransition(srcPage_, destPage_);
230     ASSERT_EQ(manager_->effects_.size(), 1);
231     auto effect = *manager_->effects_.begin();
232     ASSERT_EQ(effect->GetType(), SharedTransitionEffectType::SHARED_EFFECT_STATIC);
233     EXPECT_EQ(effect->GetSrcSharedNode().Upgrade(), nullptr);
234     EXPECT_EQ(effect->GetDestSharedNode().Upgrade(), destNodeShareId1);
235     EXPECT_EQ(effect->GetShareId(), SHARE_ID1);
236     ASSERT_TRUE(effect->GetOption() != nullptr);
237     EXPECT_EQ(effect->GetOption()->duration, DEST_DURATION);
238     auto staticEffect = AceType::DynamicCast<SharedTransitionStatic>(effect);
239     EXPECT_EQ(staticEffect->GetPassengerNode().Upgrade(), destNodeShareId1);
240     ASSERT_EQ(manager_->sharedManager_->GetChildren().size(), 1);
241     EXPECT_EQ(AceType::DynamicCast<FrameNode>(manager_->sharedManager_->GetFirstChild()), destNodeShareId1);
242     ASSERT_EQ(destPage_->GetChildren().size(), 1);
243     EXPECT_NE(destPage_->GetFirstChild(), destNodeShareId1);
244 
245     /**
246      * @tc.steps: step3. Call StopSharedTransition to test it
247      * @tc.expected: The node mounted to sharedManager has been removed and is mounted to the original parent
248      */
249     manager_->StopSharedTransition();
250     EXPECT_EQ(manager_->sharedManager_->GetChildren().size(), 0);
251     ASSERT_EQ(destPage_->GetChildren().size(), 1);
252     EXPECT_EQ(destPage_->GetFirstChild(), destNodeShareId1);
253 }
254 
255 /**
256  * @tc.name: SharedOverlayManagerTest005
257  * @tc.desc: Test the function CreateAnimation of SharedTransitionStatic
258  * @tc.type: FUNC
259  */
260 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest005, TestSize.Level1)
261 {
262     /**
263      * @tc.steps: step1. create a SharedTransitionStatic and call function CreateAnimation
264      */
265     auto option = std::make_shared<SharedTransitionOption>();
266     SharedTransitionStatic test("test", option);
267     test.SetSharedNode(nullptr, nullptr);
268     EXPECT_FALSE(test.CreateAnimation());
269 }
270 
271 /**
272  * @tc.name: SharedOverlayManagerTest006
273  * @tc.desc: Test the function DestRequestDefaultFocus of SharedTransitionExchange
274  * @tc.type: FUNC
275  */
276 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest006, TestSize.Level1)
277 {
278     /**
279      * @tc.steps: step1. create a SharedTransitionExchange and call function DestRequestDefaultFocus
280      */
281     auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
282     auto option = std::make_shared<SharedTransitionOption>();
283     SharedTransitionExchange test("test", option);
284     test.SetSharedNode(WeakPtr<FrameNode>(frameNode), WeakPtr<FrameNode>(frameNode));
285     test.SetInitialDestVisible(VisibleType::INVISIBLE);
286     test.DestRequestDefaultFocus();
287     test.SetInitialDestVisible(VisibleType::VISIBLE);
288     test.DestRequestDefaultFocus();
289     auto dst = test.GetDestSharedNode().Upgrade();
290     auto page = dst->GetPageNode();
291     auto pagePattern = page->GetPattern<PagePattern>();
292     EXPECT_FALSE(pagePattern->GetIsViewHasFocused());
293 }
294 
295 /**
296  * @tc.name: SharedOverlayManagerTest007
297  * @tc.desc: Test the function CreateSizeAnimation of SharedTransitionExchange
298  * @tc.type: FUNC
299  */
300 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest007, TestSize.Level1)
301 {
302     /**
303      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
304      */
305     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
306     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
307     destNode->GetGeometryNode()->SetFrameSize(SizeF(-1.0, -1.0));
308     auto option = std::make_shared<SharedTransitionOption>();
309     SharedTransitionExchange test("test", option);
310     EXPECT_FALSE(test.CreateSizeAnimation(srcNode, destNode));
311 }
312 
313 /**
314  * @tc.name: SharedOverlayManagerTest011
315  * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
316  * @tc.type: FUNC
317  */
318 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest011, TestSize.Level1)
319 {
320     /**
321      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
322      */
323     auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
324     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
325     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
326     frameNode->AddChild(srcNode);
327     frameNode->AddChild(destNode);
328     auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
329     mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
330     auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
331     mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
332     destNode->renderContext_ = mockDestContext;
333     srcNode->renderContext_ = mockSrcContext;
334     auto option = std::make_shared<SharedTransitionOption>();
335     SharedTransitionExchange test("test", option);
336     test.GetOption()->motionPathOption.SetPath("abc");
337     test.GetOption()->motionPathOption.SetRotate(true);
338     auto flag = test.CreateTranslateAnimation(srcNode, destNode);
339     test.PerformFinishCallback();
340     EXPECT_TRUE(flag);
341 }
342 
343 /**
344  * @tc.name: SharedOverlayManagerTest012
345  * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
346  * @tc.type: FUNC
347  */
348 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest012, TestSize.Level1)
349 {
350     /**
351      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
352      */
353     auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
354     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
355     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
356     frameNode->AddChild(srcNode);
357     frameNode->AddChild(destNode);
358     auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
359     mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
360     auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
361     mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
362     destNode->renderContext_ = mockDestContext;
363     srcNode->renderContext_ = mockSrcContext;
364     auto option = std::make_shared<SharedTransitionOption>();
365     SharedTransitionExchange test("test", option);
366     test.GetOption()->motionPathOption.SetPath("abc");
367     test.GetOption()->motionPathOption.SetRotate(false);
368     auto flag = test.CreateTranslateAnimation(srcNode, destNode);
369     test.PerformFinishCallback();
370     EXPECT_TRUE(flag);
371 }
372 
373 /**
374  * @tc.name: SharedOverlayManagerTest013
375  * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
376  * @tc.type: FUNC
377  */
378 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest013, TestSize.Level1)
379 {
380     /**
381      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
382      */
383     auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
384     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
385     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
386     frameNode->AddChild(srcNode);
387     frameNode->AddChild(destNode);
388     auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
389     mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
390     auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
391     mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
392     destNode->renderContext_ = mockDestContext;
393     srcNode->renderContext_ = mockSrcContext;
394     auto option = std::make_shared<SharedTransitionOption>();
395     SharedTransitionExchange test("test", option);
396     auto flag = test.CreateTranslateAnimation(srcNode, destNode);
397     test.PerformFinishCallback();
398     EXPECT_TRUE(flag);
399 }
400 
401 /**
402  * @tc.name: SharedOverlayManagerTest014
403  * @tc.desc: Test the function CreateAnimation of SharedTransitionExchange
404  * @tc.type: FUNC
405  */
406 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest014, TestSize.Level1)
407 {
408     /**
409      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateAnimation
410      */
411     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
412     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
413     auto option = std::make_shared<SharedTransitionOption>();
414     SharedTransitionExchange test("test", option);
415     test.SetSharedNode(nullptr, WeakPtr<FrameNode>(destNode));
416     EXPECT_FALSE(test.CreateAnimation());
417     EXPECT_FALSE(test.Allow());
418     SharedTransitionExchange testTwo("test", option);
419     testTwo.SetSharedNode(WeakPtr<FrameNode>(srcNode), nullptr);
420     EXPECT_FALSE(testTwo.CreateAnimation());
421     EXPECT_FALSE(testTwo.Allow());
422 }
423 
424 /**
425  * @tc.name: SharedOverlayManagerTest015
426  * @tc.desc: Test the function CreateAnimation of SharedTransitionExchange
427  * @tc.type: FUNC
428  */
429 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest015, TestSize.Level1)
430 {
431     /**
432      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateAnimation
433      */
434     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
435     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
436     destNode->GetGeometryNode()->SetFrameSize(SizeF(-1.0, -1.0));
437     auto option = std::make_shared<SharedTransitionOption>();
438     SharedTransitionExchange test("test", option);
439     test.SetSharedNode(WeakPtr<FrameNode>(srcNode), WeakPtr<FrameNode>(destNode));
440     test.GetOption()->curve = Curves::EASE_IN_OUT;
441     EXPECT_FALSE(test.CreateAnimation());
442 }
443 
444 /**
445  * @tc.name: SharedOverlayManagerTest016
446  * @tc.desc: Test the function CreateOpacityAnimation of SharedTransitionEffect
447  * @tc.type: FUNC
448  */
449 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest016, TestSize.Level1)
450 {
451     /**
452      * @tc.steps: step1. create a SharedTransitionExchange and call function CreateOpacityAnimation
453      */
454     auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
455     auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
456     auto option = std::make_shared<SharedTransitionOption>();
457     SharedTransitionStatic test("test", option);
458     test.SetSharedNode(WeakPtr<FrameNode>(srcNode), WeakPtr<FrameNode>(destNode));
459     test.finishCallbacks_.emplace_back(nullptr);
460     auto flag = test.CreateAnimation();
461     auto interpolator = test.GetController()->interpolators_;
462     for (const auto& inter : interpolator) {
463         inter->OnInitNotify(1.0, true);
464     }
465     test.PerformFinishCallback();
466     EXPECT_TRUE(flag);
467 }
468 } // namespace OHOS::Ace::NG
469