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/log/dump_log.h"
26 #include "base/geometry/ng/offset_t.h"
27 #include "base/geometry/ng/size_t.h"
28 #include "base/memory/ace_type.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/base/geometry_node.h"
31 #include "core/components_ng/manager/shared_overlay/shared_overlay_manager.h"
32 #include "core/components_ng/pattern/pattern.h"
33 #include "core/components_ng/pattern/stage/page_pattern.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS::Ace::NG {
39 namespace {
40 const std::string ROOT_TAG = "root";
41 const std::string NODE_TAG = "node";
42 const std::string SHARE_ID1("id1");
43 const std::string SHARE_ID2("id2");
44 const SizeF SRC_SIZE(100.0f, 100.0f);
45 const SizeF DEST_SIZE(200.0f, 200.0f);
46 const int32_t SRC_DURATION = 500;
47 const int32_t DEST_DURATION = 1000;
48
CreateSharedNode(const std::string & shareId,const int32_t & duration,const SizeF & frameSize)49 RefPtr<FrameNode> CreateSharedNode(const std::string& shareId, const int32_t& duration, const SizeF& frameSize)
50 {
51 auto node = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>(), false);
52 node->GetRenderContext()->SetShareId(shareId);
53 auto option = std::make_shared<SharedTransitionOption>();
54 option->curve = Curves::LINEAR;
55 option->duration = duration;
56 option->type = SharedTransitionEffectType::SHARED_EFFECT_EXCHANGE;
57 node->GetRenderContext()->SetSharedTransitionOptions(option);
58 node->GetGeometryNode()->SetFrameSize(frameSize);
59 return node;
60 }
61 } // namespace
62
63 class SharedOverlayManagerTestNg : public testing::Test {
64 public:
SetUpTestSuite()65 static void SetUpTestSuite() {};
TearDownTestSuite()66 static void TearDownTestSuite() {};
67 void SetUp() override;
68 void TearDown() override;
69
70 private:
71 RefPtr<SharedOverlayManager> manager_;
72 RefPtr<FrameNode> srcPage_;
73 RefPtr<FrameNode> destPage_;
74 };
75
SetUp()76 void SharedOverlayManagerTestNg::SetUp()
77 {
78 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
79 manager_ = AceType::MakeRefPtr<SharedOverlayManager>(root);
80 srcPage_ = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(nullptr), false);
81 destPage_ = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(nullptr), false);
82 }
83
TearDown()84 void SharedOverlayManagerTestNg::TearDown()
85 {
86 manager_.Reset();
87 srcPage_.Reset();
88 destPage_.Reset();
89 }
90
91 /**
92 * @tc.name: SharedOverlayManagerTest001
93 * @tc.desc: There is no matching shareId, so it cannot perform sharedTransition.
94 * @tc.type: FUNC
95 * @tc.author:
96 */
97 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest001, TestSize.Level1)
98 {
99 /**
100 * @tc.steps: step1. construct a SharedOverlayManager
101 */
102 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
103 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
104
105 /**
106 * @tc.steps: step2. construct two frameNodes which type is Page and pageInfo is default config
107 */
108 auto srcPageInfo = AceType::MakeRefPtr<PageInfo>();
109 auto destPageInfo = AceType::MakeRefPtr<PageInfo>();
110 auto pageSrc = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(srcPageInfo));
111 auto pageDest = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<PagePattern>(destPageInfo));
112
113 /**
114 * @tc.steps: step3. call StartSharedTransition
115 * @tc.expected: step3. effects_ is empty for page has no sharedTransitionEffect
116 */
117 sharedOverlayManager->StartSharedTransition(pageSrc, pageDest);
118 EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
119
120 /**
121 * @tc.steps: step4. Add a node configured with exchange sharedTransition to source page,
122 * and add a node with no sharedTransition to destination page
123 */
124 sharedOverlayManager->effects_.clear();
125 auto shareNodeSrc = CreateSharedNode(SHARE_ID1, SRC_DURATION, SRC_SIZE);
126 pageSrc->AddChild(shareNodeSrc);
127 pageSrc->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, shareNodeSrc);
128 auto nodeDest = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>(), false);
129 pageDest->AddChild(nodeDest);
130
131 /**
132 * @tc.steps: step5. call StartSharedTransition
133 * @tc.expected: effects_ is empty because there is no node configured with exchange sharedTransition
134 * in destination page
135 */
136 sharedOverlayManager->StartSharedTransition(pageSrc, pageDest);
137 EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
138
139 /**
140 * @tc.steps: step6. Clear the nodes of dest page, and add a node configured with exchange sharedTransition
141 * to destination page, but the shareId is different from that of the node in source page
142 */
143 sharedOverlayManager->effects_.clear();
144 pageDest->RemoveChild(nodeDest);
145 auto shareNodeDest = CreateSharedNode(SHARE_ID2, DEST_DURATION, DEST_SIZE);
146 pageDest->AddChild(shareNodeDest);
147 pageDest->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID2, shareNodeDest);
148
149 /**
150 * @tc.steps: step7. call StartSharedTransition
151 * @tc.expected: effects_ is empty because the node in source page and the node in destination page have
152 * different shareId
153 */
154 sharedOverlayManager->PrepareSharedTransition(pageSrc, pageDest);
155 EXPECT_EQ(sharedOverlayManager->effects_.size(), 0);
156 }
157
158 /**
159 * @tc.name: SharedOverlayManagerTest002
160 * @tc.desc: Build a sharedTransition node with the same share id on the source page and the destination page
161 * and perform sharedTransition successfully
162 * @tc.type: FUNC
163 * @tc.author:
164 */
165 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest002, TestSize.Level1)
166 {
167 /**
168 * @tc.steps: step1. add node configured with same shareId to source page and destination page respectively
169 */
170 auto srcNodeShareId1 = CreateSharedNode(SHARE_ID1, SRC_DURATION, SRC_SIZE);
171 srcPage_->AddChild(srcNodeShareId1);
172 srcPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, srcNodeShareId1);
173 auto destNodeShareId1 = CreateSharedNode(SHARE_ID1, DEST_DURATION, DEST_SIZE);
174 destNodeShareId1->GetRenderContext()->UpdatePaintRect(RectF(1.0, 1.0, 1.0, 1.0));
175 destPage_->AddChild(destNodeShareId1);
176 destPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, destNodeShareId1);
177
178 /**
179 * @tc.steps: step2. call StartSharedTransition
180 * @tc.expected: effects_ has one expected effect. The node in source page has been removed and is mounted to
181 * sharedManager
182 */
183 manager_->StartSharedTransition(srcPage_, destPage_);
184 ASSERT_EQ(manager_->effects_.size(), 1);
185 auto effect = *manager_->effects_.begin();
186 EXPECT_EQ(effect->GetType(), SharedTransitionEffectType::SHARED_EFFECT_EXCHANGE);
187 EXPECT_EQ(effect->GetSrcSharedNode().Upgrade(), srcNodeShareId1);
188 EXPECT_EQ(effect->GetDestSharedNode().Upgrade(), destNodeShareId1);
189 EXPECT_EQ(effect->GetShareId(), SHARE_ID1);
190 ASSERT_TRUE(effect->GetOption() != nullptr);
191 EXPECT_EQ(effect->GetOption()->duration, DEST_DURATION);
192 ASSERT_EQ(manager_->sharedManager_->GetChildren().size(), 1);
193 EXPECT_EQ(AceType::DynamicCast<FrameNode>(manager_->sharedManager_->GetFirstChild()), srcNodeShareId1);
194 ASSERT_EQ(srcPage_->GetChildren().size(), 1);
195 EXPECT_NE(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
196
197 /**
198 * @tc.steps: step3. Notify the controller of effect to stop so the sharedTransition can finish
199 * @tc.expected: The node mounted to sharedManager has been removed and is mounted to the original parent
200 */
201 auto controller = effect->GetController();
202 ASSERT_TRUE(controller != nullptr);
203 controller->Stop();
204 EXPECT_EQ(manager_->sharedManager_->GetChildren().size(), 0);
205 ASSERT_EQ(srcPage_->GetChildren().size(), 1);
206 EXPECT_EQ(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
207 }
208
209 /**
210 * @tc.name: SharedOverlayManagerTest003
211 * @tc.desc: Build a node configured with static sharedTransition in source page and perform sharedTransition
212 * successfully
213 * @tc.type: FUNC
214 * @tc.author:
215 */
216 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest003, TestSize.Level1)
217 {
218 /**
219 * @tc.steps: step1. Add a node configured with static sharedTransition to source page
220 */
221 auto srcNodeShareId1 = CreateSharedNode(SHARE_ID1, SRC_DURATION, SRC_SIZE);
222 srcNodeShareId1->GetRenderContext()->GetSharedTransitionOption()->type =
223 SharedTransitionEffectType::SHARED_EFFECT_STATIC;
224 srcPage_->AddChild(srcNodeShareId1);
225 srcPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, srcNodeShareId1);
226
227 /**
228 * @tc.steps: step2. call StartSharedTransition
229 * @tc.expected: effects_ has one expected effect. The node in source page has been removed and is mounted to
230 * sharedManager
231 */
232 manager_->StartSharedTransition(srcPage_, destPage_);
233 ASSERT_EQ(manager_->effects_.size(), 1);
234 auto effect = *manager_->effects_.begin();
235 ASSERT_EQ(effect->GetType(), SharedTransitionEffectType::SHARED_EFFECT_STATIC);
236 EXPECT_EQ(effect->GetSrcSharedNode().Upgrade(), srcNodeShareId1);
237 EXPECT_EQ(effect->GetDestSharedNode().Upgrade(), nullptr);
238 EXPECT_EQ(effect->GetShareId(), SHARE_ID1);
239 ASSERT_TRUE(effect->GetOption() != nullptr);
240 EXPECT_EQ(effect->GetOption()->duration, SRC_DURATION);
241 auto staticEffect = AceType::DynamicCast<SharedTransitionStatic>(effect);
242 EXPECT_EQ(staticEffect->GetPassengerNode().Upgrade(), srcNodeShareId1);
243 ASSERT_EQ(manager_->sharedManager_->GetChildren().size(), 1);
244 EXPECT_EQ(AceType::DynamicCast<FrameNode>(manager_->sharedManager_->GetFirstChild()), srcNodeShareId1);
245 ASSERT_EQ(srcPage_->GetChildren().size(), 1);
246 EXPECT_NE(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
247
248 /**
249 * @tc.steps: step3. Notify the controller of effect to stop so the sharedTransition can finish
250 * @tc.expected: The node mounted to sharedManager has been removed and is mounted to the original parent
251 */
252 auto controller = effect->GetController();
253 ASSERT_TRUE(controller != nullptr);
254 controller->Stop();
255 EXPECT_EQ(manager_->sharedManager_->GetChildren().size(), 0);
256 ASSERT_EQ(srcPage_->GetChildren().size(), 1);
257 EXPECT_EQ(AceType::DynamicCast<FrameNode>(srcPage_->GetFirstChild()), srcNodeShareId1);
258 }
259
260 /**
261 * @tc.name: SharedOverlayManagerTest004
262 * @tc.desc: Build a node configured with static sharedTransition in destination page and perform sharedTransition
263 * successfully
264 * @tc.type: FUNC
265 */
266 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest004, TestSize.Level1)
267 {
268 /**
269 * @tc.steps: step1. Add a node configured with static sharedTransition to destination page
270 */
271 auto destNodeShareId1 = CreateSharedNode(SHARE_ID1, DEST_DURATION, DEST_SIZE);
272 destNodeShareId1->GetRenderContext()->GetSharedTransitionOption()->type =
273 SharedTransitionEffectType::SHARED_EFFECT_STATIC;
274 destPage_->AddChild(destNodeShareId1);
275 destPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, destNodeShareId1);
276
277 /**
278 * @tc.steps: step2. call StartSharedTransition
279 * @tc.expected: effects_ has one expected effect. The node in destination page has been removed and is mounted to
280 * sharedManager
281 */
282 manager_->StartSharedTransition(srcPage_, destPage_);
283 ASSERT_EQ(manager_->effects_.size(), 1);
284 auto effect = *manager_->effects_.begin();
285 ASSERT_EQ(effect->GetType(), SharedTransitionEffectType::SHARED_EFFECT_STATIC);
286 EXPECT_EQ(effect->GetSrcSharedNode().Upgrade(), nullptr);
287 EXPECT_EQ(effect->GetDestSharedNode().Upgrade(), destNodeShareId1);
288 EXPECT_EQ(effect->GetShareId(), SHARE_ID1);
289 ASSERT_TRUE(effect->GetOption() != nullptr);
290 EXPECT_EQ(effect->GetOption()->duration, DEST_DURATION);
291 auto staticEffect = AceType::DynamicCast<SharedTransitionStatic>(effect);
292 EXPECT_EQ(staticEffect->GetPassengerNode().Upgrade(), destNodeShareId1);
293 ASSERT_EQ(manager_->sharedManager_->GetChildren().size(), 1);
294 EXPECT_EQ(AceType::DynamicCast<FrameNode>(manager_->sharedManager_->GetFirstChild()), destNodeShareId1);
295 ASSERT_EQ(destPage_->GetChildren().size(), 1);
296 EXPECT_NE(destPage_->GetFirstChild(), destNodeShareId1);
297
298 /**
299 * @tc.steps: step3. Call StopSharedTransition to test it
300 * @tc.expected: The node mounted to sharedManager has been removed and is mounted to the original parent
301 */
302 manager_->StopSharedTransition();
303 EXPECT_EQ(manager_->sharedManager_->GetChildren().size(), 0);
304 ASSERT_EQ(destPage_->GetChildren().size(), 1);
305 EXPECT_EQ(destPage_->GetFirstChild(), destNodeShareId1);
306 }
307
308 /**
309 * @tc.name: SharedOverlayManagerTest005
310 * @tc.desc: Test the function CreateAnimation of SharedTransitionStatic
311 * @tc.type: FUNC
312 */
313 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest005, TestSize.Level1)
314 {
315 /**
316 * @tc.steps: step1. create a SharedTransitionStatic and call function CreateAnimation
317 */
318 auto option = std::make_shared<SharedTransitionOption>();
319 SharedTransitionStatic test("test", option);
320 test.SetSharedNode(nullptr, nullptr);
321 EXPECT_FALSE(test.CreateAnimation());
322 }
323
324 /**
325 * @tc.name: SharedOverlayManagerTest006
326 * @tc.desc: Test the function DestRequestDefaultFocus of SharedTransitionExchange
327 * @tc.type: FUNC
328 */
329 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest006, TestSize.Level1)
330 {
331 /**
332 * @tc.steps: step1. create a SharedTransitionExchange and call function DestRequestDefaultFocus
333 */
334 auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
335 auto option = std::make_shared<SharedTransitionOption>();
336 SharedTransitionExchange test("test", option);
337 test.SetSharedNode(WeakPtr<FrameNode>(frameNode), WeakPtr<FrameNode>(frameNode));
338 test.SetInitialDestVisible(VisibleType::INVISIBLE);
339 test.DestRequestDefaultFocus();
340 test.SetInitialDestVisible(VisibleType::VISIBLE);
341 test.DestRequestDefaultFocus();
342 auto dst = test.GetDestSharedNode().Upgrade();
343 auto page = dst->GetPageNode();
344 auto pagePattern = page->GetPattern<PagePattern>();
345 EXPECT_FALSE(pagePattern->GetIsViewHasFocused());
346 }
347
348 /**
349 * @tc.name: SharedOverlayManagerTest007
350 * @tc.desc: Test the function CreateSizeAnimation of SharedTransitionExchange
351 * @tc.type: FUNC
352 */
353 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest007, TestSize.Level1)
354 {
355 /**
356 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
357 */
358 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
359 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
360 destNode->GetGeometryNode()->SetFrameSize(SizeF(-1.0, -1.0));
361 auto option = std::make_shared<SharedTransitionOption>();
362 SharedTransitionExchange test("test", option);
363 EXPECT_FALSE(test.CreateSizeAnimation(srcNode, destNode));
364 }
365
366 /**
367 * @tc.name: SharedOverlayManagerTest008
368 * @tc.desc: Test the function CreateSizeAnimation of SharedTransitionExchange
369 * @tc.type: FUNC
370 */
371 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest008, TestSize.Level1)
372 {
373 /**
374 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
375 */
376 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
377 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
378 destNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 1.0));
379 destNode->GetRenderContext()->UpdatePaintRect(RectF(1.0, 1.0, 1.0, 1.0));
380 srcNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 1.0));
381 auto option = std::make_shared<SharedTransitionOption>();
382 SharedTransitionExchange test("test", option);
383 EXPECT_TRUE(test.CreateSizeAnimation(srcNode, destNode));
384 }
385
386 /**
387 * @tc.name: SharedOverlayManagerTest009
388 * @tc.desc: Test the function CreateSizeAnimation of SharedTransitionExchange
389 * @tc.type: FUNC
390 */
391 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest009, TestSize.Level1)
392 {
393 /**
394 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
395 */
396 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
397 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
398 destNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 1.0));
399 destNode->GetRenderContext()->UpdatePaintRect(RectF(1.0, 1.0, 1.0, 1.0));
400 srcNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 0.0));
401 auto width = CalcLength::FromString("1px");
402 auto height = CalcLength::FromString("1px");
403 CalcSize calcSize(width, height);
404 MeasureProperty calcLayoutConstraint;
405 calcLayoutConstraint.UpdateMinSizeWithCheck(calcSize);
406 calcLayoutConstraint.UpdateMinSizeWithCheck(calcSize);
407 srcNode->GetLayoutProperty()->UpdateCalcLayoutProperty(calcLayoutConstraint);
408 srcNode->GetLayoutProperty()->GetMagicItemProperty().UpdateAspectRatio(1.0);
409 auto option = std::make_shared<SharedTransitionOption>();
410 SharedTransitionExchange test("test", option);
411 auto flag = test.CreateSizeAnimation(srcNode, destNode);
412 auto interpolator = test.GetController()->interpolators_;
413 for (const auto& inter : interpolator) {
414 inter->OnInitNotify(1.0, true);
415 }
416 test.PerformFinishCallback();
417 EXPECT_TRUE(flag);
418 }
419
420 /**
421 * @tc.name: SharedOverlayManagerTest010
422 * @tc.desc: Test the function CreateSizeAnimation of SharedTransitionExchange
423 * @tc.type: FUNC
424 */
425 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest010, TestSize.Level1)
426 {
427 /**
428 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
429 */
430 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
431 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
432 destNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 1.0));
433 destNode->GetRenderContext()->UpdatePaintRect(RectF(1.0, 1.0, 1.0, 1.0));
434 srcNode->GetGeometryNode()->SetFrameSize(SizeF(1.0, 0.0));
435 auto width = CalcLength::FromString("1px");
436 auto height = CalcLength::FromString("1px");
437 CalcSize calcSize(width, height);
438 MeasureProperty calcLayoutConstraint;
439 calcLayoutConstraint.UpdateMinSizeWithCheck(calcSize);
440 calcLayoutConstraint.UpdateMinSizeWithCheck(calcSize);
441 srcNode->GetLayoutProperty()->UpdateCalcLayoutProperty(calcLayoutConstraint);
442 auto option = std::make_shared<SharedTransitionOption>();
443 SharedTransitionExchange test("test", option);
444 auto flag = test.CreateSizeAnimation(srcNode, destNode);
445 auto interpolator = test.GetController()->interpolators_;
446 for (const auto& inter : interpolator) {
447 inter->OnInitNotify(1.0, true);
448 }
449 test.PerformFinishCallback();
450 EXPECT_TRUE(flag);
451 }
452
453 /**
454 * @tc.name: SharedOverlayManagerTest011
455 * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
456 * @tc.type: FUNC
457 */
458 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest011, TestSize.Level1)
459 {
460 /**
461 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
462 */
463 auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
464 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
465 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
466 frameNode->AddChild(srcNode);
467 frameNode->AddChild(destNode);
468 auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
469 mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
470 auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
471 mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
472 destNode->renderContext_ = mockDestContext;
473 srcNode->renderContext_ = mockSrcContext;
474 auto option = std::make_shared<SharedTransitionOption>();
475 SharedTransitionExchange test("test", option);
476 test.GetOption()->motionPathOption.SetPath("abc");
477 test.GetOption()->motionPathOption.SetRotate(true);
478 auto flag = test.CreateTranslateAnimation(srcNode, destNode);
479 test.PerformFinishCallback();
480 EXPECT_TRUE(flag);
481 }
482
483 /**
484 * @tc.name: SharedOverlayManagerTest012
485 * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
486 * @tc.type: FUNC
487 */
488 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest012, TestSize.Level1)
489 {
490 /**
491 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
492 */
493 auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
494 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
495 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
496 frameNode->AddChild(srcNode);
497 frameNode->AddChild(destNode);
498 auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
499 mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
500 auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
501 mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
502 destNode->renderContext_ = mockDestContext;
503 srcNode->renderContext_ = mockSrcContext;
504 auto option = std::make_shared<SharedTransitionOption>();
505 SharedTransitionExchange test("test", option);
506 test.GetOption()->motionPathOption.SetPath("abc");
507 test.GetOption()->motionPathOption.SetRotate(false);
508 auto flag = test.CreateTranslateAnimation(srcNode, destNode);
509 test.PerformFinishCallback();
510 EXPECT_TRUE(flag);
511 }
512
513 /**
514 * @tc.name: SharedOverlayManagerTest013
515 * @tc.desc: Test the function CreateTranslateAnimation of SharedTransitionExchange
516 * @tc.type: FUNC
517 */
518 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest013, TestSize.Level1)
519 {
520 /**
521 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateSizeAnimation
522 */
523 auto frameNode = FrameNode::CreateFrameNode("page", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
524 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
525 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
526 frameNode->AddChild(srcNode);
527 frameNode->AddChild(destNode);
528 auto mockDestContext = AceType::MakeRefPtr<MockRenderContext>();
529 mockDestContext->rect_ = RectF(0.0, 0.0, 1.0, 1.0);
530 auto mockSrcContext = AceType::MakeRefPtr<MockRenderContext>();
531 mockSrcContext->rect_ = RectF(1.0, 1.0, 0.0, 0.0);
532 destNode->renderContext_ = mockDestContext;
533 srcNode->renderContext_ = mockSrcContext;
534 auto option = std::make_shared<SharedTransitionOption>();
535 SharedTransitionExchange test("test", option);
536 auto flag = test.CreateTranslateAnimation(srcNode, destNode);
537 test.PerformFinishCallback();
538 EXPECT_TRUE(flag);
539 }
540
541 /**
542 * @tc.name: SharedOverlayManagerTest014
543 * @tc.desc: Test the function CreateAnimation of SharedTransitionExchange
544 * @tc.type: FUNC
545 */
546 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest014, TestSize.Level1)
547 {
548 /**
549 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateAnimation
550 */
551 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
552 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
553 auto option = std::make_shared<SharedTransitionOption>();
554 SharedTransitionExchange test("test", option);
555 test.SetSharedNode(nullptr, WeakPtr<FrameNode>(destNode));
556 EXPECT_FALSE(test.CreateAnimation());
557 EXPECT_FALSE(test.Allow());
558 SharedTransitionExchange testTwo("test", option);
559 testTwo.SetSharedNode(WeakPtr<FrameNode>(srcNode), nullptr);
560 EXPECT_FALSE(testTwo.CreateAnimation());
561 EXPECT_FALSE(testTwo.Allow());
562 }
563
564 /**
565 * @tc.name: SharedOverlayManagerTest015
566 * @tc.desc: Test the function CreateAnimation of SharedTransitionExchange
567 * @tc.type: FUNC
568 */
569 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest015, TestSize.Level1)
570 {
571 /**
572 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateAnimation
573 */
574 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
575 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
576 destNode->GetGeometryNode()->SetFrameSize(SizeF(-1.0, -1.0));
577 auto option = std::make_shared<SharedTransitionOption>();
578 SharedTransitionExchange test("test", option);
579 test.SetSharedNode(WeakPtr<FrameNode>(srcNode), WeakPtr<FrameNode>(destNode));
580 test.GetOption()->curve = Curves::EASE_IN_OUT;
581 EXPECT_FALSE(test.CreateAnimation());
582 }
583
584 /**
585 * @tc.name: SharedOverlayManagerTest016
586 * @tc.desc: Test the function CreateOpacityAnimation of SharedTransitionEffect
587 * @tc.type: FUNC
588 */
589 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest016, TestSize.Level1)
590 {
591 /**
592 * @tc.steps: step1. create a SharedTransitionExchange and call function CreateOpacityAnimation
593 */
594 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
595 auto srcNode = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
596 auto option = std::make_shared<SharedTransitionOption>();
597 SharedTransitionStatic test("test", option);
598 test.SetSharedNode(WeakPtr<FrameNode>(srcNode), WeakPtr<FrameNode>(destNode));
599 test.finishCallbacks_.emplace_back(nullptr);
600 auto flag = test.CreateAnimation();
601 auto interpolator = test.GetController()->interpolators_;
602 for (const auto& inter : interpolator) {
603 inter->OnInitNotify(1.0, true);
604 }
605 test.PerformFinishCallback();
606 EXPECT_TRUE(flag);
607 }
608
609 /**
610 * @tc.name: SharedOverlayManagerTest017
611 * @tc.desc: PrepareEachTransition
612 * @tc.type: FUNC
613 */
614 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest017, TestSize.Level1)
615 {
616 /**
617 * @tc.steps: step1. prepare the environment variables for the function.
618 */
619 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
620 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
621 ShareId shareId = "adc";
622 std::shared_ptr<SharedTransitionOption> sharedOption;
623
624 /**
625 * @tc.steps: step2. set different variables to meet the conditional values and test PrepareEachTransition.
626 */
627 sharedOption = std::make_shared<SharedTransitionOption>();
628 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
629 effect->dest_ = nullptr;
630 effect->src_ = nullptr;
631 bool res = sharedOverlayManager->PrepareEachTransition(effect);
632 EXPECT_FALSE(res);
633 }
634
635 /**
636 * @tc.name: SharedOverlayManagerTest018
637 * @tc.desc: CheckAndPrepareTransition
638 * @tc.type: FUNC
639 */
640 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest018, TestSize.Level1)
641 {
642 /**
643 * @tc.steps: step1. prepare the environment variables for the function.
644 */
645 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
646 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
647 ShareId shareId = "adc";
648 ShareId shareId2 = "abc";
649 std::shared_ptr<SharedTransitionOption> sharedOption;
650 std::shared_ptr<SharedTransitionOption> sharedOption2;
651 sharedOption = std::make_shared<SharedTransitionOption>();
652 sharedOption2 = std::make_shared<SharedTransitionOption>();
653
654 /**
655 * @tc.steps: step2. set different variables to meet the conditional values and test ClearAllEffects.
656 */
657 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
658 RefPtr<SharedTransitionEffect> effect2 = AceType::MakeRefPtr<SharedTransitionExchange>(shareId2, sharedOption2);
659 effect->dest_ = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
660 effect->src_ = FrameNode::CreateFrameNode("srcNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
661 bool res = sharedOverlayManager->PrepareEachTransition(effect);
662
663 std::list<RefPtr<SharedTransitionEffect>> effects;
664 std::list<RefPtr<SharedTransitionEffect>> effectiveEffects;
665 effectiveEffects.emplace_back(effect2);
666 effects.emplace_back(effect);
667 sharedOverlayManager->CheckAndPrepareTransition(effects, effectiveEffects);
668 EXPECT_FALSE(res);
669 }
670
671 /**
672 * @tc.name: SharedOverlayManagerTest019
673 * @tc.desc: ClearAllEffects
674 * @tc.type: FUNC
675 */
676 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest019, TestSize.Level1)
677 {
678 /**
679 * @tc.steps: step1. prepare the environment variables for the function.
680 */
681 ShareId shareId = "adc";
682 std::shared_ptr<SharedTransitionOption> sharedOption;
683 sharedOption = std::make_shared<SharedTransitionOption>();
684 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
685 effect->dest_ = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
686 std::list<RefPtr<SharedTransitionEffect>> effects;
687 effects.emplace_back(effect);
688
689 /**
690 * @tc.steps: step2. set different variables to meet the conditional values and test ClearAllEffects.
691 */
692 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
693 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
694 sharedOverlayManager-> effects_ = effects;
695 sharedOverlayManager->ClearAllEffects();
696 EXPECT_FALSE(!sharedOverlayManager->effects_.empty());
697 }
698
699 /**
700 * @tc.name: SharedOverlayManagerTest020
701 * @tc.desc: CheckIn
702 * @tc.type: FUNC
703 */
704 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest020, TestSize.Level1)
705 {
706 /**
707 * @tc.steps: step1. prepare the environment variables for the function.
708 */
709 ShareId shareId = "adc";
710 std::shared_ptr<SharedTransitionOption> sharedOption;
711 sharedOption = std::make_shared<SharedTransitionOption>();
712 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
713 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
714 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
715
716 /**
717 * @tc.steps: step2. test CheckIn.
718 */
719 bool res = sharedOverlayManager->CheckIn(effect);
720 EXPECT_FALSE(res);
721 }
722
723 /**
724 * @tc.name: SharedOverlayManagerTest021
725 * @tc.desc: PassengerAboard
726 * @tc.type: FUNC
727 */
728 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest021, TestSize.Level1)
729 {
730 /**
731 * @tc.steps: step1. prepare the environment variables for the function.
732 */
733 ShareId shareId = "adc";
734 std::shared_ptr<SharedTransitionOption> sharedOption;
735 sharedOption = std::make_shared<SharedTransitionOption>();
736 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
737 auto destNode = FrameNode::CreateFrameNode("destNode", 1, AceType::MakeRefPtr<PagePattern>(nullptr), true);
738
739 /**
740 * @tc.steps: step2. set different variables to meet the conditional values and test PassengerAboard.
741 */
742 std::unique_ptr<MarginProperty> ptr1 = std::make_unique<MarginProperty>();
743 destNode->layoutProperty_->margin_ = std::move(ptr1);
744
745 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
746 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
747 sharedOverlayManager->PassengerAboard(effect, destNode);
748 EXPECT_TRUE(DumpLog::GetInstance().result_.find("Transition passenger"));
749 }
750
751 /**
752 * @tc.name: SharedOverlayManagerTest022
753 * @tc.desc: AboardShuttle
754 * @tc.type: FUNC
755 */
756 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest022, TestSize.Level1)
757 {
758 /**
759 * @tc.steps: step1. prepare the environment variables for the function.
760 */
761 ShareId shareId = "adc";
762 std::shared_ptr<SharedTransitionOption> sharedOption;
763 sharedOption = std::make_shared<SharedTransitionOption>();
764 RefPtr<SharedTransitionEffect> effect = AceType::MakeRefPtr<SharedTransitionExchange>(shareId, sharedOption);
765
766 /**
767 * @tc.steps: step2. set different variables to meet the conditional values and test AboardShuttle.
768 */
769 auto root = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
770 auto sharedOverlayManager = AceType::MakeRefPtr<SharedOverlayManager>(root);
771 bool res = sharedOverlayManager->AboardShuttle(effect);
772 EXPECT_FALSE(res);
773 }
774
775 /**
776 * @tc.name: SharedOverlayManagerTest023
777 * @tc.desc: OnBackPressed
778 * @tc.type: FUNC
779 */
780 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest023, TestSize.Level1)
781 {
782 /**
783 * @tc.steps: step1. prepare the environment variables for the function.
784 */
785 auto destNodeShareId = CreateSharedNode(SHARE_ID1, DEST_DURATION, DEST_SIZE);
786 destNodeShareId->GetRenderContext()->GetSharedTransitionOption()->type =
787 SharedTransitionEffectType::SHARED_EFFECT_STATIC;
788 destPage_->AddChild(destNodeShareId);
789
790 /**
791 * @tc.steps: step2. set different variables to meet the conditional values and test OnBackPressed.
792 */
793 destPage_->GetPattern<PagePattern>()->sharedTransitionMap_.emplace(SHARE_ID1, destNodeShareId);
794 manager_->StartSharedTransition(srcPage_, destPage_);
795 auto effect = *manager_->effects_.begin();
796 auto staticEffect = AceType::DynamicCast<SharedTransitionStatic>(effect);
797 bool res = manager_->OnBackPressed();
798 EXPECT_TRUE(res);
799 }
800 /**
801 * @tc.name: SharedOverlayManagerTest024
802 * @tc.desc: StartSharedTransition
803 * @tc.type: FUNC
804 */
805 HWTEST_F(SharedOverlayManagerTestNg, SharedOverlayManagerTest024, TestSize.Level1)
806 {
807 /**
808 * @tc.steps: step1. prepare the environment variables for the function.
809 */
810 auto destNodeShareId = CreateSharedNode(SHARE_ID1, DEST_DURATION, DEST_SIZE);
811 ASSERT_NE(destNodeShareId, nullptr);
812 auto renderContext = destNodeShareId->GetRenderContext();
813 ASSERT_NE(renderContext, nullptr);
814 auto transitionOption = renderContext->GetSharedTransitionOption();
815 ASSERT_NE(transitionOption, nullptr);
816 transitionOption->type = SharedTransitionEffectType::SHARED_EFFECT_STATIC;
817
818 /**
819 * @tc.steps: step2. verify the animationType of the controller in the effect.
820 */
821 auto pagePattern = destPage_->GetPattern<PagePattern>();
822 ASSERT_NE(pagePattern, nullptr);
823 pagePattern->sharedTransitionMap_.emplace(SHARE_ID1, destNodeShareId);
824 ASSERT_NE(manager_, nullptr);
825 manager_->StartSharedTransition(srcPage_, destPage_);
826 ASSERT_FALSE(manager_->effects_.empty());
827 auto effect = *manager_->effects_.begin();
828 ASSERT_NE(effect, nullptr);
829 auto controller = effect->GetController();
830 ASSERT_NE(controller, nullptr);
831 EXPECT_EQ(controller->GetAnimationType(), AnimationInterface::SHARED_TRANSITION);
832 }
833 } // namespace OHOS::Ace::NG
834