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