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