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 <gtest/gtest.h>
17#include <transaction/rs_transaction.h>
18#include "display_manager.h"
19#include "input_window_monitor.h"
20#include "iremote_object_mocker.h"
21#include "minimize_app.h"
22#include "mock_RSIWindowAnimationController.h"
23#include "remote_animation.h"
24#include "starting_window.h"
25#include "window_helper.h"
26using namespace testing;
27using namespace testing::ext;
28
29namespace OHOS {
30namespace Rosen {
31namespace {
32constexpr uint32_t SLEEP_TIME_IN_US = 10000;
33}
34
35class RemoteAnimationTest : public testing::Test {
36public:
37    static void SetUpTestCase();
38    static void TearDownTestCase();
39    void SetUp() override;
40    void TearDown() override;
41    void InitRemoteAnimation();
42    void CreateWindowNodeContainer();
43private:
44    RSSurfaceNode::SharedPtr CreateRSSurfaceNode(uint32_t windowId);
45    sptr<WindowProperty> CreateWindowProperty(uint32_t windowId);
46    Rect GetSurfaceBoundsRect(sptr<WindowNode> node);
47    sptr<RSIWindowAnimationController> animationController_;
48    sptr<WindowRoot> windowRoot_;
49    sptr<WindowController> windowController_;
50    std::shared_ptr<AppExecFwk::EventHandler> wmsTaskHandler_;
51    sptr<WindowTransitionInfo> transitionInfo_ = nullptr;
52    sptr<WindowNode> node_ = nullptr;
53};
54
55void RemoteAnimationTest::SetUpTestCase()
56{
57}
58
59void RemoteAnimationTest::TearDownTestCase()
60{
61}
62
63void RemoteAnimationTest::SetUp()
64{
65    InitRemoteAnimation();
66    CreateWindowNodeContainer();
67    transitionInfo_ = new WindowTransitionInfo();
68    sptr<IRemoteObject> token = new IRemoteObjectMocker();
69    transitionInfo_->SetAbilityToken(token);
70    transitionInfo_->displayId_ = 0;
71    transitionInfo_->supportWindowModes_ = {
72        AppExecFwk::SupportWindowMode::FULLSCREEN,
73        AppExecFwk::SupportWindowMode::SPLIT,
74        AppExecFwk::SupportWindowMode::FLOATING
75    };
76    windowController_->StartingWindow(transitionInfo_, nullptr, 0xFFFFFFFF, true);
77    node_ = windowRoot_->FindWindowNodeWithToken(transitionInfo_->GetAbilityToken());
78    EXPECT_NE(nullptr, node_);
79}
80
81void RemoteAnimationTest::TearDown()
82{
83    if (node_ != nullptr) {
84        windowController_->DestroyWindow(node_->GetWindowId(), false);
85        node_ = nullptr;
86    }
87    animationController_ = nullptr;
88    wmsTaskHandler_ = nullptr;
89    windowRoot_ = nullptr;
90    windowController_ = nullptr;
91    transitionInfo_ = nullptr;
92}
93
94void RemoteAnimationTest::InitRemoteAnimation()
95{
96    animationController_ = new RSIWindowAnimationControllerMocker();
97    EXPECT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(animationController_));
98    RemoteAnimation::isRemoteAnimationEnable_ = true;
99    RemoteAnimation::animationFirst_ = true;
100    windowRoot_ = new WindowRoot([](Event event, const sptr<IRemoteObject>& remoteObject) {});
101    sptr<InputWindowMonitor> inputMonitor = new InputWindowMonitor(windowRoot_);
102    windowController_ = new WindowController(windowRoot_, inputMonitor);
103    RemoteAnimation::SetWindowControllerAndRoot(windowController_, windowRoot_);
104    auto runner = AppExecFwk::EventRunner::Create("RemoteAnimationTest");
105    wmsTaskHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
106    RemoteAnimation::SetMainTaskHandler(wmsTaskHandler_);
107}
108
109void RemoteAnimationTest::CreateWindowNodeContainer()
110{
111    auto display = DisplayManager::GetInstance().GetDefaultDisplay();
112    ASSERT_TRUE((display != nullptr));
113    sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
114    ASSERT_TRUE((displayInfo != nullptr));
115    windowRoot_->CreateWindowNodeContainer(0, displayInfo);
116}
117
118sptr<WindowProperty> RemoteAnimationTest::CreateWindowProperty(uint32_t windowId)
119{
120    sptr<WindowProperty> property = new WindowProperty();
121    property->SetWindowId(windowId);
122    return property;
123}
124
125Rect RemoteAnimationTest::GetSurfaceBoundsRect(sptr<WindowNode> node)
126{
127    if (!node->leashWinSurfaceNode_) {
128        return {0, 0, 0, 0};
129    }
130    auto& stagingProperties = node->leashWinSurfaceNode_->GetStagingProperties();
131    auto bounds = stagingProperties.GetBounds();
132    Rect rect = {bounds[0], bounds[1], bounds[2], bounds[3]}; // 1, 2, 3 is index
133    return rect;
134}
135
136RSSurfaceNode::SharedPtr RemoteAnimationTest::CreateRSSurfaceNode(uint32_t windowId)
137{
138    struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
139    rsSurfaceNodeConfig.SurfaceNodeName = "AppSurfaceNode" + std::to_string(windowId);
140    auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig);
141    return surfaceNode;
142}
143
144namespace {
145/**
146 * @tc.name: IsRemoteAnimationEnabledAndFirst01
147 * @tc.desc: IsRemoteAnimationEnabledAndFirst return false since animationFirst false
148 * @tc.type: FUNC
149 */
150HWTEST_F(RemoteAnimationTest, IsRemoteAnimationEnabledAndFirst01, Function | SmallTest | Level2)
151{
152    RemoteAnimation::SetAnimationFirst(false);
153    EXPECT_EQ(false, RemoteAnimation::animationFirst_);
154    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
155}
156
157/**
158 * @tc.name: IsRemoteAnimationEnabledAndFirst02
159 * @tc.desc: IsRemoteAnimationEnabledAndFirst return true since animationFirst true
160 * @tc.type: FUNC
161 */
162HWTEST_F(RemoteAnimationTest, IsRemoteAnimationEnabledAndFirst02, Function | SmallTest | Level2)
163{
164    EXPECT_EQ(true, RemoteAnimation::animationFirst_);
165    EXPECT_EQ(true, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
166}
167
168/**
169 * @tc.name: IsRemoteAnimationEnabledAndFirst03
170 * @tc.desc: IsRemoteAnimationEnabledAndFirst return false since CheckRemoteAnimationEnabled false
171 * @tc.type: FUNC
172 */
173HWTEST_F(RemoteAnimationTest, IsRemoteAnimationEnabledAndFirst03, Function | SmallTest | Level2)
174{
175    RemoteAnimation::windowRoot_ = nullptr;
176    EXPECT_EQ(false, RemoteAnimation::CheckRemoteAnimationEnabled(0));
177    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
178    RemoteAnimation::windowRoot_ = windowRoot_;
179    auto container = RemoteAnimation::windowRoot_->GetOrCreateWindowNodeContainer(0);
180    EXPECT_NE(nullptr, container);
181    container->isScreenLocked_ = true;
182    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
183}
184
185/**
186 * @tc.name: IsRemoteAnimationEnabledAndFirst04
187 * @tc.desc: return false since CheckRemoteAnimationEnabled false, set animationController nullptr
188 * @tc.type: FUNC
189 */
190HWTEST_F(RemoteAnimationTest, IsRemoteAnimationEnabledAndFirst04, Function | SmallTest | Level2)
191{
192    sptr<RSIWindowAnimationController> controller = nullptr;
193    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(controller));
194    RemoteAnimation::windowAnimationController_ = nullptr;
195    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
196    controller = new RSIWindowAnimationControllerMocker();
197    RemoteAnimation::isRemoteAnimationEnable_ = false;
198    EXPECT_EQ(WMError::WM_ERROR_NO_REMOTE_ANIMATION, RemoteAnimation::SetWindowAnimationController(controller));
199    EXPECT_EQ(false, RemoteAnimation::CheckRemoteAnimationEnabled(0));
200    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
201    RemoteAnimation::isRemoteAnimationEnable_ = true;
202    EXPECT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(controller));
203    EXPECT_EQ(true, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
204    RemoteAnimation::SetAnimationFirst(false);
205    EXPECT_EQ(false, RemoteAnimation::animationFirst_);
206    EXPECT_EQ(false, RemoteAnimation::IsRemoteAnimationEnabledAndFirst(0));
207}
208
209/**
210 * @tc.name: CheckTransition01
211 * @tc.desc: CheckTransition return false
212 * @tc.type: FUNC
213 */
214HWTEST_F(RemoteAnimationTest, CheckTransition01, Function | SmallTest | Level2)
215{
216    const sptr<WindowNode> node = nullptr;
217    EXPECT_EQ(false, RemoteAnimation::CheckTransition(transitionInfo_, node, transitionInfo_, node));
218    sptr<WindowNode> srcNode = StartingWindow::CreateWindowNode(transitionInfo_, 0);
219    ASSERT_NE(nullptr, srcNode);
220    srcNode->leashWinSurfaceNode_ = nullptr; // leash and app surface node is nullptr
221    EXPECT_EQ(false, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, srcNode));
222    srcNode->surfaceNode_ = CreateRSSurfaceNode(0); // leash is null, but surfaceNode is not
223    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, srcNode));
224    srcNode = StartingWindow::CreateWindowNode(transitionInfo_, 0); // leash and app surfaceNode both not nullptr
225    ASSERT_NE(nullptr, srcNode);
226    sptr<WindowNode> dstNode = StartingWindow::CreateWindowNode(transitionInfo_, 1);
227    ASSERT_NE(nullptr, dstNode);
228    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, node, transitionInfo_, dstNode));
229    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, node));
230    dstNode->leashWinSurfaceNode_ = nullptr;
231    EXPECT_EQ(false, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, dstNode));
232    dstNode->surfaceNode_ = CreateRSSurfaceNode(1); // leash is null, but surfaceNode is not
233    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, dstNode));
234}
235
236/**
237 * @tc.name: CheckTransition02
238 * @tc.desc: CheckTransition return false since windowMode not support
239 * @tc.type: FUNC
240 */
241HWTEST_F(RemoteAnimationTest, CheckTransition02, Function | SmallTest | Level2)
242{
243    sptr<WindowNode> srcNode = StartingWindow::CreateWindowNode(transitionInfo_, 0);
244    ASSERT_NE(nullptr, srcNode);
245    sptr<WindowNode> dstNode = StartingWindow::CreateWindowNode(transitionInfo_, 1);
246    ASSERT_NE(nullptr, dstNode);
247    dstNode->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
248    dstNode->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
249    ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(dstNode->GetWindowMode(),
250        dstNode->GetModeSupportInfo(), transitionInfo_));
251    EXPECT_EQ(false, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, dstNode));
252}
253
254/**
255 * @tc.name: CheckTransition03
256 * @tc.desc: CheckTransition return true
257 * @tc.type: FUNC
258 */
259HWTEST_F(RemoteAnimationTest, CheckTransition03, Function | SmallTest | Level2)
260{
261    sptr<WindowNode> srcNode = StartingWindow::CreateWindowNode(transitionInfo_, 0);
262    ASSERT_NE(nullptr, srcNode);
263    sptr<WindowNode> dstNode = StartingWindow::CreateWindowNode(transitionInfo_, 1);
264    ASSERT_NE(nullptr, dstNode);
265    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, nullptr, dstNode));
266    EXPECT_EQ(true, RemoteAnimation::CheckTransition(transitionInfo_, srcNode, transitionInfo_, dstNode));
267}
268
269/**
270 * @tc.name: OnRemoteDieAndCallbackTimeOutProcess01
271 * @tc.desc: OnRemoteDie and setAnimationController nullptr
272 * @tc.type: FUNC
273 */
274HWTEST_F(RemoteAnimationTest, OnRemoteDieAndCallbackTimeOutProcess01, Function | SmallTest | Level2)
275{
276    auto testController = RemoteAnimation::windowAnimationController_;
277    ASSERT_EQ(true, RemoteAnimation::windowAnimationController_->AsObject() == animationController_->AsObject());
278    RemoteAnimation::OnRemoteDie(animationController_->AsObject()); // controller is not nullptr
279    EXPECT_EQ(false, RemoteAnimation::CheckAnimationController());
280    RemoteAnimation::OnRemoteDie(testController->AsObject()); // controller is nullptr
281    RemoteAnimation::SetAnimationFirst(false);
282    RemoteAnimation::OnRemoteDie(testController->AsObject()); // controller is nullptr
283}
284
285/**
286 * @tc.name: OnRemoteDieAndCallbackTimeOutProcess02
287 * @tc.desc: OnRemoteDie and not set animation controller
288 * @tc.type: FUNC
289 */
290HWTEST_F(RemoteAnimationTest, OnRemoteDieAndCallbackTimeOutProcess02, Function | SmallTest | Level2)
291{
292    sptr<IRemoteObject> remoteObject = nullptr;
293    RemoteAnimation::windowRoot_ = nullptr;
294    RemoteAnimation::OnRemoteDie(remoteObject); // controller is not nullptr
295    EXPECT_EQ(true, RemoteAnimation::CheckAnimationController());
296}
297
298/**
299 * @tc.name: OnRemoteDieAndCallbackTimeOutProcess03
300 * @tc.desc: OnRemoteDie and timeout process success
301 * @tc.type: FUNC
302 */
303HWTEST_F(RemoteAnimationTest, OnRemoteDieAndCallbackTimeOutProcess03, Function | SmallTest | Level2)
304{
305    auto root = RemoteAnimation::windowRoot_;
306    node_->stateMachine_.TransitionTo(WindowNodeState::SHOW_ANIMATION_PLAYING);
307    auto testController = RemoteAnimation::windowAnimationController_;
308    RemoteAnimation::OnRemoteDie(testController->AsObject()); // controller is not nullptr
309    EXPECT_EQ(false, RemoteAnimation::CheckAnimationController());
310    EXPECT_EQ(true, node_->stateMachine_.currState_ == WindowNodeState::SHOW_ANIMATION_DONE);
311}
312
313/**
314 * @tc.name: CreateWindowAnimationTarget01
315 * @tc.desc: CreateWindowAnimationTarget with null node/different windowType
316 * @tc.type: FUNC
317 */
318HWTEST_F(RemoteAnimationTest, CreateWindowAnimationTarget01, Function | SmallTest | Level2)
319{
320    sptr<WindowNode> node = nullptr;
321    EXPECT_EQ(nullptr, RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, node));
322    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(1)); // 1 is windowId
323    EXPECT_EQ(nullptr, RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, srcNode)); // no surfaceNode
324    srcNode->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
325    EXPECT_EQ(nullptr, RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, srcNode)); // no surfaceNode
326    EXPECT_NE(nullptr, RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, node_));
327    node_->startingWinSurfaceNode_ = nullptr;
328    EXPECT_NE(nullptr, RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, node_)); // start win null
329}
330
331/**
332 * @tc.name: CreateShowAnimationFinishedCallback01
333 * @tc.desc: CreateShowAnimationFinishedCallback with animationFirst false
334 * @tc.type: FUNC
335 */
336HWTEST_F(RemoteAnimationTest, CreateShowAnimationFinishedCallback01, Function | SmallTest | Level2)
337{
338    RemoteAnimation::SetAnimationFirst(false);
339    auto finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(node_, node_, true);
340    EXPECT_NE(nullptr, finishCallback);
341    finishCallback->OnAnimationFinished(); // not animation playing
342    usleep(SLEEP_TIME_IN_US);
343
344    node_->stateMachine_.TransitionTo(WindowNodeState::SHOW_ANIMATION_PLAYING);
345    finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(node_, node_, true);
346    EXPECT_NE(nullptr, finishCallback);
347    finishCallback->OnAnimationFinished(); // leashSurfaceNode is not nullptr
348    usleep(SLEEP_TIME_IN_US);
349
350    sptr<WindowNode> dstNode = nullptr;
351    finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(node_, dstNode, true);
352    EXPECT_NE(nullptr, finishCallback);
353    finishCallback->OnAnimationFinished(); // dstNode is nullptr
354    usleep(SLEEP_TIME_IN_US);
355
356    dstNode = new WindowNode(CreateWindowProperty(1)); // leashSurfaceNode is nullptr
357    dstNode->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
358    finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(node_, dstNode, true);
359    EXPECT_NE(nullptr, finishCallback);
360    finishCallback->OnAnimationFinished();
361    usleep(SLEEP_TIME_IN_US);
362}
363
364/**
365 * @tc.name: CreateShowAnimationFinishedCallback02
366 * @tc.desc: CreateShowAnimationFinishedCallback with animationFirst true
367 * @tc.type: FUNC
368 */
369HWTEST_F(RemoteAnimationTest, CreateShowAnimationFinishedCallback02, Function | SmallTest | Level2)
370{
371    sptr<WindowNode> dstNode = nullptr;
372    auto finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(node_, dstNode, true);
373    EXPECT_NE(nullptr, finishCallback);
374    finishCallback->OnAnimationFinished(); // dstNode is nullptr
375    usleep(SLEEP_TIME_IN_US);
376
377    sptr<WindowNode> srcNode = nullptr;
378    finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(srcNode, node_, true);
379    EXPECT_NE(nullptr, finishCallback);
380    finishCallback->OnAnimationFinished(); // process srcNode state task with nullptr, node task count < 0
381    usleep(SLEEP_TIME_IN_US);
382
383    srcNode = nullptr;
384    node_->stateMachine_.ResetAnimationTaskCount(2); // 2 is animationCount
385    finishCallback = RemoteAnimation::CreateShowAnimationFinishedCallback(srcNode, node_, false);
386    EXPECT_NE(nullptr, finishCallback);
387    finishCallback->OnAnimationFinished(); // process srcNode state task with nullptr, node task count > 0
388    usleep(SLEEP_TIME_IN_US);
389}
390
391/**
392 * @tc.name: CreateHideAnimationFinishedCallback01
393 * @tc.desc: CreateHideAnimationFinishedCallback with animationFirst false
394 * @tc.type: FUNC
395 */
396HWTEST_F(RemoteAnimationTest, CreateHideAnimationFinishedCallback01, Function | SmallTest | Level2)
397{
398    RemoteAnimation::SetAnimationFirst(false);
399    sptr<WindowNode> srcNode = nullptr;
400    auto finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(srcNode, TransitionEvent::MINIMIZE);
401    EXPECT_NE(nullptr, finishCallback);
402    finishCallback->OnAnimationFinished(); // srcNode is nullptr
403    usleep(SLEEP_TIME_IN_US);
404
405    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::MINIMIZE);
406    EXPECT_NE(nullptr, finishCallback);
407    finishCallback->OnAnimationFinished(); // not hide animation playing
408    usleep(SLEEP_TIME_IN_US);
409    EXPECT_NE(WindowNodeState::HIDE_ANIMATION_DONE, node_->stateMachine_.currState_);
410
411    node_->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
412    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::CLOSE);
413    EXPECT_NE(nullptr, finishCallback);
414    finishCallback->OnAnimationFinished(); // hide animation playing and with close
415    usleep(SLEEP_TIME_IN_US);
416    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, node_->stateMachine_.currState_);
417
418    node_->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
419    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::MINIMIZE);
420    EXPECT_NE(nullptr, finishCallback);
421    finishCallback->OnAnimationFinished(); // hide animation playing and with MINIMIZE
422    usleep(SLEEP_TIME_IN_US);
423    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, node_->stateMachine_.currState_);
424
425    node_->stateMachine_.TransitionTo(WindowNodeState::STARTING_CREATED);
426    node_->abilityToken_ = nullptr;
427    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::MINIMIZE);
428    EXPECT_NE(nullptr, finishCallback);
429    finishCallback->OnAnimationFinished(); // abilityToken is nullptr
430    usleep(SLEEP_TIME_IN_US);
431    EXPECT_EQ(WindowNodeState::STARTING_CREATED, node_->stateMachine_.currState_);
432}
433
434/**
435 * @tc.name: CreateHideAnimationFinishedCallback02
436 * @tc.desc: CreateHideAnimationFinishedCallback with animationFirst true
437 * @tc.type: FUNC
438 */
439HWTEST_F(RemoteAnimationTest, CreateHideAnimationFinishedCallback02, Function | SmallTest | Level2)
440{
441    sptr<WindowNode> srcNode = nullptr;
442    auto finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(srcNode, TransitionEvent::CLOSE);
443    EXPECT_NE(nullptr, finishCallback);
444    finishCallback->OnAnimationFinished(); // srcNode is nullptr
445    usleep(SLEEP_TIME_IN_US);
446
447    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::MINIMIZE);
448    EXPECT_NE(nullptr, finishCallback);
449    finishCallback->OnAnimationFinished(); // with minimize
450    usleep(SLEEP_TIME_IN_US);
451
452    node_->firstFrameAvailable_ = true;
453    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::CLOSE);
454    EXPECT_NE(nullptr, finishCallback);
455    finishCallback->OnAnimationFinished(); // create hide callback with firstFrameAvailable_ true
456    usleep(SLEEP_TIME_IN_US);
457
458    node_->firstFrameAvailable_ = false;
459    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::CLOSE);
460    EXPECT_NE(nullptr, finishCallback);
461    finishCallback->OnAnimationFinished(); // create hide callback with surfaceNode null
462    usleep(SLEEP_TIME_IN_US);
463
464    node_->firstFrameAvailable_ = false;
465    node_->surfaceNode_ = CreateRSSurfaceNode(1);
466    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::CLOSE);
467    EXPECT_NE(nullptr, finishCallback);
468    finishCallback->OnAnimationFinished(); // create hide callback with surfaceNode not null
469    usleep(SLEEP_TIME_IN_US);
470
471    node_->leashWinSurfaceNode_ = CreateRSSurfaceNode(1);
472    finishCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(node_, TransitionEvent::CLOSE);
473    EXPECT_NE(nullptr, finishCallback);
474    finishCallback->OnAnimationFinished(); // create hide callback with leashWinSurfaceNode_ null
475    usleep(SLEEP_TIME_IN_US);
476}
477
478/**
479 * @tc.name: ProcessNodeStateTask01
480 * @tc.desc: ProcessNodeStateTask with different node state
481 * @tc.type: FUNC
482 */
483HWTEST_F(RemoteAnimationTest, ProcessNodeStateTask01, Function | SmallTest | Level2)
484{
485    // ExecuteFinalStateTask with task is nullptr
486    node_->stateMachine_.ResetAnimationTaskCount(1);
487    RemoteAnimation::ProcessNodeStateTask(node_);
488    usleep(SLEEP_TIME_IN_US);
489    EXPECT_EQ(WindowNodeState::STARTING_CREATED, node_->stateMachine_.currState_);
490
491    node_->stateMachine_.ResetAnimationTaskCount(1);
492    node_->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
493    RemoteAnimation::ProcessNodeStateTask(node_); // hide animation playing
494    usleep(SLEEP_TIME_IN_US);
495    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, node_->stateMachine_.currState_);
496
497    RemoteAnimation::windowRoot_ = nullptr;
498    node_->stateMachine_.ResetAnimationTaskCount(1);
499    RemoteAnimation::ProcessNodeStateTask(node_); // hide animation playing and windowRoot is nullptr
500    usleep(SLEEP_TIME_IN_US);
501    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, node_->stateMachine_.currState_);
502
503    RemoteAnimation::windowRoot_ = windowRoot_;
504    node_->stateMachine_.TransitionTo(WindowNodeState::SHOW_ANIMATION_PLAYING);
505    node_->stateMachine_.ResetAnimationTaskCount(1);
506    RemoteAnimation::ProcessNodeStateTask(node_); // show animation playing
507    usleep(SLEEP_TIME_IN_US);
508    EXPECT_EQ(WindowNodeState::SHOW_ANIMATION_DONE, node_->stateMachine_.currState_);
509
510    bool taskExecute = false;
511    node_->stateMachine_.SetDestroyTask([&taskExecute] {taskExecute = true;});
512    node_->stateMachine_.ResetAnimationTaskCount(1);
513    RemoteAnimation::ProcessNodeStateTask(node_); // execute destroy task
514    usleep(SLEEP_TIME_IN_US);
515    EXPECT_EQ(true, taskExecute);
516
517    RemoteAnimation::windowRoot_ = nullptr;
518    node_->stateMachine_.ResetAnimationTaskCount(1);
519    RemoteAnimation::ProcessNodeStateTask(node_); // show animation playing and windowRoot is nullptr
520    usleep(SLEEP_TIME_IN_US);
521    EXPECT_EQ(WindowNodeState::SHOW_ANIMATION_DONE, node_->stateMachine_.currState_);
522
523    wmsTaskHandler_ = nullptr;
524    RemoteAnimation::wmsTaskHandler_ = wmsTaskHandler_;
525    node_->stateMachine_.ResetAnimationTaskCount(1);
526    node_->stateMachine_.SetDestroyTask([&taskExecute] {taskExecute = false;});
527    RemoteAnimation::ExecuteFinalStateTask(node_); // handler is nullptr
528    usleep(SLEEP_TIME_IN_US);
529    EXPECT_EQ(true, taskExecute);
530}
531
532/**
533 * @tc.name: PostProcessShowCallback01
534 * @tc.desc: PostProcessShowCallback with different leashWinSurfaceNode
535 * @tc.type: FUNC
536 */
537HWTEST_F(RemoteAnimationTest, PostProcessShowCallback01, Function | SmallTest | Level2)
538{
539    sptr<WindowNode> dstNode = nullptr;
540    RemoteAnimation::PostProcessShowCallback(dstNode);
541    usleep(SLEEP_TIME_IN_US);
542
543    Rect expectRect = {0, 0, 100, 100}; // 100 is test data
544    node_->SetWindowRect(expectRect);
545    RemoteAnimation::PostProcessShowCallback(node_);
546    usleep(SLEEP_TIME_IN_US);
547    Rect actualRect = GetSurfaceBoundsRect(node_);
548    EXPECT_EQ(expectRect, actualRect);
549    node_->leashWinSurfaceNode_ = nullptr;
550    RemoteAnimation::PostProcessShowCallback(node_);
551}
552
553/**
554 * @tc.name: GetTransitionEvent01
555 * @tc.desc: GetTransitionEvent with reason not ability_transition
556 * @tc.type: FUNC
557 */
558HWTEST_F(RemoteAnimationTest, GetTransitionEvent01, Function | SmallTest | Level2)
559{
560    transitionInfo_->SetTransitionReason(TransitionReason::MINIMIZE);
561    auto event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
562    EXPECT_EQ(TransitionEvent::MINIMIZE, event);
563
564    transitionInfo_->SetTransitionReason(TransitionReason::BACK_TRANSITION);
565    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
566    EXPECT_EQ(TransitionEvent::BACK_TRANSITION, event);
567
568    transitionInfo_->SetTransitionReason(TransitionReason::CLOSE);
569    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
570    EXPECT_EQ(TransitionEvent::CLOSE, event);
571
572    node_->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
573    transitionInfo_->SetTransitionReason(TransitionReason::CLOSE);
574    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
575    EXPECT_EQ(TransitionEvent::UNKNOWN, event);
576}
577
578/**
579 * @tc.name: GetTransitionEvent02
580 * @tc.desc: GetTransitionEvent with reason ability_transition
581 * @tc.type: FUNC
582 */
583HWTEST_F(RemoteAnimationTest, GetTransitionEvent02, Function | SmallTest | Level2)
584{
585    sptr<WindowNode> srcNode = nullptr;
586    transitionInfo_->SetTransitionReason(TransitionReason::ABILITY_TRANSITION);
587    auto event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, srcNode, node_);
588    EXPECT_EQ(TransitionEvent::APP_TRANSITION, event);
589
590    sptr<WindowNode> dstNode = nullptr;
591    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, dstNode);
592    EXPECT_EQ(TransitionEvent::UNKNOWN, event);
593
594    node_->stateMachine_.TransitionTo(WindowNodeState::SHOW_ANIMATION_PLAYING);
595    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
596    EXPECT_EQ(TransitionEvent::UNKNOWN, event);
597
598    transitionInfo_->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
599    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
600    EXPECT_EQ(TransitionEvent::HOME, event);
601
602    transitionInfo_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
603    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, node_);
604    EXPECT_EQ(TransitionEvent::UNKNOWN, event);
605
606    transitionInfo_->SetAbilityToken(nullptr);
607    event = RemoteAnimation::GetTransitionEvent(transitionInfo_, transitionInfo_, node_, dstNode);
608    EXPECT_EQ(TransitionEvent::UNKNOWN, event);
609}
610
611/**
612 * @tc.name: GetExpectRect01
613 * @tc.desc: GetExpectRect
614 * @tc.type: FUNC
615 */
616HWTEST_F(RemoteAnimationTest, GetExpectRect01, Function | SmallTest | Level2)
617{
618    auto target = RemoteAnimation::CreateWindowAnimationTarget(transitionInfo_, node_);
619    RemoteAnimation::GetExpectRect(node_, target);
620    Rect actualRect = GetSurfaceBoundsRect(node_);
621    EXPECT_EQ(node_->GetWindowRect(), actualRect); // avoidRect is empty thus return
622
623    sptr<WindowNode> statusBar = new WindowNode(CreateWindowProperty(0));
624    ASSERT_NE(nullptr, statusBar);
625    statusBar->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
626    statusBar->SetWindowRect({0, 0, 100, 100});
627    windowRoot_->windowNodeMap_[0] = statusBar;
628
629    Rect avoidRect = windowRoot_->GetDisplayRectWithoutSystemBarAreas(node_);
630    EXPECT_FALSE(WindowHelper::IsEmptyRect(avoidRect));
631
632    RemoteAnimation::GetExpectRect(node_, target);
633    actualRect = GetSurfaceBoundsRect(node_);
634    EXPECT_EQ(avoidRect, actualRect); // get expect rect
635
636    node_->leashWinSurfaceNode_ = nullptr;
637    RemoteAnimation::GetExpectRect(node_, target);
638
639    node_->GetWindowProperty()->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
640    RemoteAnimation::GetExpectRect(node_, target);
641    EXPECT_FALSE(WindowHelper::IsMainFullScreenWindow(node_->GetWindowType(), node_->GetWindowMode()));
642
643    RemoteAnimation::windowRoot_ = nullptr;
644    RemoteAnimation::GetExpectRect(node_, target);
645
646    node_->GetWindowProperty()->SetWindowFlags(0);
647    RemoteAnimation::GetExpectRect(node_, target);
648    bool needAvoid = (node_->GetWindowFlags() & static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID));
649    EXPECT_EQ(false, needAvoid);
650}
651
652/**
653 * @tc.name: NotifyAnimationTransition01
654 * @tc.desc: NotifyAnimationTransition failed
655 * @tc.type: FUNC
656 */
657HWTEST_F(RemoteAnimationTest, NotifyAnimationTransition01, Function | SmallTest | Level2)
658{
659    sptr<WindowNode> dstNode = nullptr;
660    WMError ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, node_, dstNode);
661    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret); //
662    dstNode = new WindowNode(CreateWindowProperty(1)); // leashSurfaceNode is nullptr
663    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, node_, dstNode);
664    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // no surfaceNode thus target is nullptr
665}
666
667/**
668 * @tc.name: NotifyAnimationTransition02
669 * @tc.desc: NotifyAnimationTransition with OnAppTransition
670 * @tc.type: FUNC
671 */
672HWTEST_F(RemoteAnimationTest, NotifyAnimationTransition02, Function | SmallTest | Level2)
673{
674    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
675    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::OTHER_WINDOW);
676
677    WMError ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
678    EXPECT_EQ(WMError::WM_OK, ret); //
679    EXPECT_EQ(0, MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::OTHER_WINDOW).size());
680
681    RemoteAnimation::SetAnimationFirst(false);
682    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::OTHER_WINDOW);
683
684    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
685    EXPECT_EQ(WMError::WM_OK, ret); //
686    EXPECT_EQ(1, MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::OTHER_WINDOW).size());
687
688    RemoteAnimation::windowController_ = nullptr;
689    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
690    EXPECT_EQ(WMError::WM_OK, ret);
691}
692
693/**
694 * @tc.name: NotifyAnimationTransition03
695 * @tc.desc: NotifyAnimationTransition with NotifyAnimationStartApp
696 * @tc.type: FUNC
697 */
698HWTEST_F(RemoteAnimationTest, NotifyAnimationTransition03, Function | SmallTest | Level2)
699{
700    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
701    srcNode->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
702    node_->surfaceNode_ = CreateRSSurfaceNode(2);
703    WMError ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
704    EXPECT_EQ(WMError::WM_OK, ret); // srcNode is nullptr, from launcher
705
706    srcNode->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
707    transitionInfo_->SetIsRecent(true);
708    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
709    EXPECT_EQ(WMError::WM_OK, ret); // srcNode is nullptr, from recent
710
711    srcNode = nullptr;
712    transitionInfo_->SetIsRecent(false);
713    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
714    EXPECT_EQ(WMError::WM_OK, ret); // srcNode is null && need minimize false, from other
715
716    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::OTHER_WINDOW);
717    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
718    EXPECT_EQ(WMError::WM_OK, ret); // srcNode is nullptr, but need minimize true, from other
719
720    RemoteAnimation::SetAnimationFirst(false);
721    ret = RemoteAnimation::NotifyAnimationTransition(transitionInfo_, transitionInfo_, srcNode, node_);
722    EXPECT_EQ(WMError::WM_OK, ret); // srcNode is nullptr, but need minimize true, from other
723}
724
725/**
726 * @tc.name: NotifyAnimationMinimize01
727 * @tc.desc: NotifyAnimationMinimize
728 * @tc.type: FUNC
729 */
730HWTEST_F(RemoteAnimationTest, NotifyAnimationMinimize01, Function | SmallTest | Level2)
731{
732    WMError ret = RemoteAnimation::NotifyAnimationMinimize(transitionInfo_, node_);
733    EXPECT_EQ(WMError::WM_OK, ret);
734
735    RemoteAnimation::windowController_ = nullptr;
736    ret = RemoteAnimation::NotifyAnimationMinimize(transitionInfo_, node_);
737    EXPECT_EQ(WMError::WM_OK, ret);
738
739    node_->leashWinSurfaceNode_ = nullptr;
740    ret = RemoteAnimation::NotifyAnimationMinimize(transitionInfo_, node_);
741    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // srcTarget is nullptr
742}
743
744/**
745 * @tc.name: NotifyAnimationClose01
746 * @tc.desc: NotifyAnimationClose
747 * @tc.type: FUNC
748 */
749HWTEST_F(RemoteAnimationTest, NotifyAnimationClose01, Function | SmallTest | Level2)
750{
751    WMError ret = RemoteAnimation::NotifyAnimationClose(transitionInfo_, node_, TransitionEvent::CLOSE);
752    EXPECT_EQ(WMError::WM_OK, ret);
753
754    RemoteAnimation::windowController_ = nullptr;
755    ret = RemoteAnimation::NotifyAnimationClose(transitionInfo_, node_, TransitionEvent::CLOSE);
756    EXPECT_EQ(WMError::WM_OK, ret);
757
758    node_->leashWinSurfaceNode_ = nullptr;
759    ret = RemoteAnimation::NotifyAnimationClose(transitionInfo_, node_, TransitionEvent::CLOSE);
760    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // srcTarget is nullptr
761}
762
763/**
764 * @tc.name: NotifyAnimationBackTransition01
765 * @tc.desc: NotifyAnimationBackTransition failed
766 * @tc.type: FUNC
767 */
768HWTEST_F(RemoteAnimationTest, NotifyAnimationBackTransition01, Function | SmallTest | Level2)
769{
770    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
771    TransitionEvent event = TransitionEvent::BACK_TRANSITION;
772    srcNode->leashWinSurfaceNode_ = nullptr;
773    WMError ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, node_,
774        event);
775    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // only src Target is null
776
777    sptr<WindowNode> dstNode = new WindowNode(CreateWindowProperty(3)); // 3 is windowId
778    dstNode->leashWinSurfaceNode_ = nullptr;
779    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, node_, dstNode, event);
780    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // only dstTarget is null
781
782    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, dstNode, event);
783    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret); // both srcTarget and dstTarget art null
784
785    srcNode = nullptr;
786    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, node_, event);
787    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret); // only srcNode is null
788
789    dstNode = nullptr;
790    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, node_, dstNode, event);
791    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret); // only dstNode is null
792
793    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, dstNode, event);
794    EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret); // both srcNode and dstNode are null
795
796    RemoteAnimation::SetAnimationFirst(false);
797    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, node_, node_, event);
798    EXPECT_EQ(WMError::WM_ERROR_NO_REMOTE_ANIMATION, ret);
799}
800
801/**
802 * @tc.name: NotifyAnimationBackTransition02
803 * @tc.desc: NotifyAnimationBackTransition success
804 * @tc.type: FUNC
805 */
806HWTEST_F(RemoteAnimationTest, NotifyAnimationBackTransition02, Function | SmallTest | Level2)
807{
808    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
809    TransitionEvent event = TransitionEvent::BACK_TRANSITION;
810    srcNode->leashWinSurfaceNode_ = CreateRSSurfaceNode(2); // 2 is windowId
811    WMError ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, node_,
812        event);
813    EXPECT_EQ(WMError::WM_OK, ret);
814    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
815        animationController_.GetRefPtr());
816    EXPECT_NE(nullptr, testController->finishedCallback_);
817    testController->finishedCallback_->OnAnimationFinished();
818    usleep(SLEEP_TIME_IN_US);
819
820    RemoteAnimation::windowController_ = nullptr;
821    ret = RemoteAnimation::NotifyAnimationBackTransition(transitionInfo_, transitionInfo_, srcNode, node_, event);
822    EXPECT_EQ(WMError::WM_OK, ret);
823    testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
824        animationController_.GetRefPtr());
825    EXPECT_NE(nullptr, testController->finishedCallback_);
826    testController->finishedCallback_->OnAnimationFinished();
827    usleep(SLEEP_TIME_IN_US);
828}
829
830/**
831 * @tc.name: NotifyAnimationByHome01
832 * @tc.desc: NotifyAnimationByHome with animationFirst false and create animationTarget failed
833 * @tc.type: FUNC
834 */
835HWTEST_F(RemoteAnimationTest, NotifyAnimationByHome01, Function | SmallTest | Level2)
836{
837    RemoteAnimation::SetAnimationFirst(false);
838    WMError ret = RemoteAnimation::NotifyAnimationByHome();
839    EXPECT_EQ(WMError::WM_OK, ret); // no node need home
840
841    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
842    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::MINIMIZE_ALL);
843    ret = RemoteAnimation::NotifyAnimationByHome();
844    EXPECT_EQ(WMError::WM_OK, ret); // create animationTarget failed with no surface, and no callback
845
846    srcNode->leashWinSurfaceNode_ = CreateRSSurfaceNode(2); // 2 is windowId
847    srcNode->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
848    ret = RemoteAnimation::NotifyAnimationByHome();
849    EXPECT_EQ(WMError::WM_OK, ret); // create animationTarget failed, and no callback
850    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
851        animationController_.GetRefPtr());
852    EXPECT_NE(nullptr, testController->finishedCallback_);
853    testController->finishedCallback_->OnAnimationFinished();
854    usleep(SLEEP_TIME_IN_US);
855    EXPECT_NE(WindowNodeState::HIDE_ANIMATION_DONE, srcNode->stateMachine_.currState_);
856
857    srcNode->stateMachine_.TransitionTo(WindowNodeState::HIDE_ANIMATION_PLAYING);
858    ret = RemoteAnimation::NotifyAnimationByHome();
859    EXPECT_EQ(WMError::WM_OK, ret); // create animationTarget failed, and no callback
860
861    srcNode->GetWindowProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
862    ret = RemoteAnimation::NotifyAnimationByHome();
863    EXPECT_EQ(WMError::WM_OK, ret); // create animationTarget failed, and no callback
864}
865
866/*
867 * @tc.name: NotifyAnimationByHome02
868 * @tc.desc: NotifyAnimationByHome with animationFirst false and create animationTarget success
869 * @tc.type: FUNC
870 */
871HWTEST_F(RemoteAnimationTest, NotifyAnimationByHome02, Function | SmallTest | Level2)
872{
873    RemoteAnimation::SetAnimationFirst(false);
874    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
875    srcNode->leashWinSurfaceNode_ = CreateRSSurfaceNode(2); // 2 is windowId
876    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::MINIMIZE_ALL);
877    WMError ret = RemoteAnimation::NotifyAnimationByHome();
878    EXPECT_EQ(WMError::WM_OK, ret);
879
880    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
881        animationController_.GetRefPtr());
882    EXPECT_NE(nullptr, testController->finishedCallback_);
883    testController->finishedCallback_->OnAnimationFinished();
884    usleep(SLEEP_TIME_IN_US);
885    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, srcNode->stateMachine_.currState_);
886}
887
888/*
889 * @tc.name: NotifyAnimationByHome03
890 * @tc.desc: NotifyAnimationByHome with animationFirst true and create animationTarget success
891 * @tc.type: FUNC
892 */
893HWTEST_F(RemoteAnimationTest, NotifyAnimationByHome03, Function | SmallTest | Level2)
894{
895    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(2)); // 2 is windowId
896    srcNode->leashWinSurfaceNode_ = CreateRSSurfaceNode(2); // 2 is windowId
897    MinimizeApp::AddNeedMinimizeApp(srcNode, MinimizeReason::MINIMIZE_ALL);
898    EXPECT_EQ(1, MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MINIMIZE_ALL).size());
899    WMError ret = RemoteAnimation::NotifyAnimationByHome();
900    EXPECT_EQ(WMError::WM_OK, ret);
901    EXPECT_EQ(0, MinimizeApp::GetNeedMinimizeAppNodesWithReason(MinimizeReason::MINIMIZE_ALL).size());
902
903    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
904        animationController_.GetRefPtr());
905    EXPECT_NE(nullptr, testController->finishedCallback_);
906    testController->finishedCallback_->OnAnimationFinished();
907    usleep(SLEEP_TIME_IN_US);
908    EXPECT_EQ(WindowNodeState::HIDE_ANIMATION_DONE, srcNode->stateMachine_.currState_);
909}
910
911/*
912 * @tc.name: NotifyAnimationTargetsUpdate01
913 * @tc.desc: NotifyAnimationTargetsUpdate failed
914 * @tc.type: FUNC
915 */
916HWTEST_F(RemoteAnimationTest, NotifyAnimationTargetsUpdate01, Function | SmallTest | Level2)
917{
918    std::vector<uint32_t> fullScreenWinIds;
919    std::vector<uint32_t> floatWinIds;
920    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds); // fullScreenAnimationTarget is empty
921    usleep(SLEEP_TIME_IN_US);
922    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
923        animationController_.GetRefPtr());
924    EXPECT_EQ(nullptr, testController->animationTarget_);
925    EXPECT_EQ(0, testController->floatingWindowTargets_.size());
926
927    RemoteAnimation::windowRoot_ = nullptr;
928    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds);
929    usleep(SLEEP_TIME_IN_US);
930    testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
931        animationController_.GetRefPtr());
932    EXPECT_EQ(nullptr, testController->animationTarget_);
933    EXPECT_EQ(0, testController->floatingWindowTargets_.size());
934
935    RemoteAnimation::windowAnimationController_ = nullptr;
936    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds);
937    usleep(SLEEP_TIME_IN_US);
938    testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
939        animationController_.GetRefPtr());
940    EXPECT_EQ(nullptr, testController->animationTarget_);
941    EXPECT_EQ(0, testController->floatingWindowTargets_.size());
942
943    wmsTaskHandler_ = nullptr;
944    RemoteAnimation::wmsTaskHandler_ = wmsTaskHandler_;
945    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds);
946    usleep(SLEEP_TIME_IN_US);
947    testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
948        animationController_.GetRefPtr());
949    EXPECT_EQ(nullptr, testController->animationTarget_);
950    EXPECT_EQ(0, testController->floatingWindowTargets_.size());
951}
952
953/*
954 * @tc.name: NotifyAnimationTargetsUpdate02
955 * @tc.desc: NotifyAnimationTargetsUpdate success
956 * @tc.type: FUNC
957 */
958HWTEST_F(RemoteAnimationTest, NotifyAnimationTargetsUpdate02, Function | SmallTest | Level2)
959{
960    std::vector<uint32_t> fullScreenWinIds;
961    std::vector<uint32_t> floatWinIds;
962    fullScreenWinIds.push_back(2); // 2 is windowId
963    floatWinIds.push_back(2); // 2 is windowId
964    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds); // CreateWindowAnimationTarget nullptr
965    usleep(SLEEP_TIME_IN_US);
966    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
967        animationController_.GetRefPtr());
968    EXPECT_EQ(nullptr, testController->animationTarget_);
969    EXPECT_EQ(0, testController->floatingWindowTargets_.size());
970
971    fullScreenWinIds.push_back(node_->GetWindowId()); // 1, 2 in vector
972    floatWinIds.push_back(node_->GetWindowId()); // CreateWindowAnimationTarget success
973    RemoteAnimation::NotifyAnimationTargetsUpdate(fullScreenWinIds, floatWinIds);
974    usleep(SLEEP_TIME_IN_US);
975    testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
976        animationController_.GetRefPtr());
977    EXPECT_NE(nullptr, testController->animationTarget_);
978    EXPECT_EQ(1, testController->floatingWindowTargets_.size());
979}
980
981/*
982 * @tc.name: NotifyAnimationScreenUnlock01
983 * @tc.desc: NotifyAnimationScreenUnlock success
984 * @tc.type: FUNC
985 */
986HWTEST_F(RemoteAnimationTest, NotifyAnimationScreenUnlock01, Function | SmallTest | Level2)
987{
988    std::function<void(void)> callback = nullptr;
989    WMError ret = RemoteAnimation::NotifyAnimationScreenUnlock(callback, nullptr);
990    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, ret);
991
992    callback = []() {};
993    ret = RemoteAnimation::NotifyAnimationScreenUnlock(callback, node_);
994    EXPECT_EQ(WMError::WM_OK, ret);
995
996    RemoteAnimation::windowAnimationController_ = nullptr;
997    ret = RemoteAnimation::NotifyAnimationScreenUnlock(callback, node_);
998    EXPECT_EQ(WMError::WM_ERROR_NO_REMOTE_ANIMATION, ret);
999}
1000
1001/*
1002 * @tc.name: NotifyAnimationUpdateWallpaper01
1003 * @tc.desc: NotifyAnimationUpdateWallpaper success
1004 * @tc.type: FUNC
1005 */
1006HWTEST_F(RemoteAnimationTest, NotifyAnimationUpdateWallpaper01, Function | SmallTest | Level2)
1007{
1008    RemoteAnimation::NotifyAnimationUpdateWallpaper(node_);
1009    RSIWindowAnimationControllerMocker* testController = reinterpret_cast<RSIWindowAnimationControllerMocker*>(
1010        animationController_.GetRefPtr());
1011    EXPECT_NE(nullptr, testController->animationTarget_);
1012
1013    testController->animationTarget_ = nullptr;
1014    RemoteAnimation::windowAnimationController_ = nullptr;
1015    RemoteAnimation::NotifyAnimationUpdateWallpaper(node_);
1016    EXPECT_EQ(nullptr, testController->animationTarget_);
1017}
1018
1019/*
1020 * @tc.name: CreateAnimationFinishedCallback01
1021 * @tc.desc: CreateAnimationFinishedCallback
1022 * @tc.type: FUNC
1023 */
1024HWTEST_F(RemoteAnimationTest, CreateAnimationFinishedCallback01, Function | SmallTest | Level2)
1025{
1026    std::function<void(void)> callback = nullptr;
1027    EXPECT_EQ(nullptr, RemoteAnimation::CreateAnimationFinishedCallback(callback, node_));
1028
1029    bool testFlag = false;
1030    callback = [&testFlag]() { testFlag = true; };
1031    auto finishCallback = RemoteAnimation::CreateAnimationFinishedCallback(callback, node_);
1032    EXPECT_NE(nullptr, finishCallback);
1033    finishCallback->OnAnimationFinished();
1034    usleep(SLEEP_TIME_IN_US);
1035    EXPECT_EQ(true, testFlag);
1036
1037    wmsTaskHandler_ = nullptr;
1038    RemoteAnimation::wmsTaskHandler_ = wmsTaskHandler_;
1039    callback = [&testFlag]() { testFlag = false; };
1040    finishCallback = RemoteAnimation::CreateAnimationFinishedCallback(callback, node_);
1041    EXPECT_NE(nullptr, finishCallback);
1042    finishCallback->OnAnimationFinished();
1043    usleep(SLEEP_TIME_IN_US);
1044    EXPECT_EQ(true, testFlag);
1045}
1046
1047/*
1048 * @tc.name: GetWindowAnimationTargets01
1049 * @tc.desc: GetWindowAnimationTargets for null window root
1050 * @tc.type: FUNC
1051 */
1052HWTEST_F(RemoteAnimationTest, GetWindowAnimationTargets01, Function | SmallTest | Level2)
1053{
1054    RemoteAnimation::windowRoot_ = nullptr;
1055    std::vector<uint32_t> missionIds;
1056    std::vector<sptr<RSWindowAnimationTarget>> targets;
1057    EXPECT_EQ(WMError::WM_ERROR_NO_MEM, RemoteAnimation::GetWindowAnimationTargets(missionIds, targets));
1058}
1059
1060/*
1061 * @tc.name: GetWindowAnimationTargets02
1062 * @tc.desc: GetWindowAnimationTargets for not exit mission
1063 * @tc.type: FUNC
1064 */
1065HWTEST_F(RemoteAnimationTest, GetWindowAnimationTargets02, Function | SmallTest | Level2)
1066{
1067    std::vector<uint32_t> missionIds;
1068    missionIds.push_back(1);
1069    std::vector<sptr<RSWindowAnimationTarget>> targets;
1070    WMError ret = RemoteAnimation::GetWindowAnimationTargets(missionIds, targets);
1071    EXPECT_EQ(WMError::WM_OK, ret);
1072    EXPECT_EQ(true, targets.empty());
1073}
1074
1075/*
1076 * @tc.name: GetWindowAnimationTargets03
1077 * @tc.desc: GetWindowAnimationTargets successful
1078 * @tc.type: FUNC
1079 */
1080HWTEST_F(RemoteAnimationTest, GetWindowAnimationTargets03, Function | SmallTest | Level2)
1081{
1082    sptr<WindowNode> srcNode = new WindowNode(CreateWindowProperty(1)); // 1 is windowId
1083    srcNode->abilityInfo_.missionId_ = 1;
1084    srcNode->surfaceNode_ = CreateRSSurfaceNode(0);
1085    windowRoot_->windowNodeMap_[1] = srcNode;
1086    std::vector<uint32_t> missionIds;
1087    missionIds.push_back(1);
1088    std::vector<sptr<RSWindowAnimationTarget>> targets;
1089    WMError ret = RemoteAnimation::GetWindowAnimationTargets(missionIds, targets);
1090    EXPECT_EQ(WMError::WM_OK, ret);
1091    ASSERT_GE(targets.size(), 1);
1092    ASSERT_NE(targets[0], nullptr);
1093    EXPECT_EQ(true, targets[0]->missionId_ == 1);
1094    usleep(SLEEP_TIME_IN_US);
1095}
1096
1097/*
1098 * @tc.name: GetAndDrawSnapShot
1099 * @tc.desc: GetWindowAnimationTargets successful
1100 * @tc.type: FUNC
1101 */
1102HWTEST_F(RemoteAnimationTest, GetAndDrawSnapShot, Function | SmallTest | Level2)
1103{
1104    sptr<WindowNode> srcNode = new WindowNode();
1105    std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
1106    bool snapSucc = SurfaceDraw::GetSurfaceSnapshot(srcNode->surfaceNode_, pixelMap, SNAPSHOT_TIMEOUT_MS, 1.0, 1.0);
1107    ASSERT_FALSE(snapSucc);
1108}
1109
1110/*
1111 * @tc.name: GetExpectRect
1112 * @tc.desc: GetWindowAnimationTargets successful
1113 * @tc.type: FUNC
1114 */
1115HWTEST_F(RemoteAnimationTest, GetExpectRect, Function | SmallTest | Level2)
1116{
1117    sptr<WindowNode> dstNode = new WindowNode();
1118    std::vector<uint32_t> missionIds;
1119    sptr<RSWindowAnimationTarget> dstTarget;
1120    std::vector<sptr<RSWindowAnimationTarget>> targets;
1121    auto avoidRect = windowRoot_->GetDisplayRectWithoutSystemBarAreas(dstNode);
1122    auto result = WindowHelper::IsEmptyRect(avoidRect);
1123    ASSERT_FALSE(result);
1124    RemoteAnimation::GetExpectRect(dstNode, dstTarget);
1125}
1126
1127/*
1128 * @tc.name: NotifyAnimationAbilityDied
1129 * @tc.desc: NotifyAnimationAbilityDied for null window root
1130 * @tc.type: FUNC
1131 */
1132HWTEST_F(RemoteAnimationTest, NotifyAnimationAbilityDied, Function | SmallTest | Level2)
1133{
1134    sptr<WindowTransitionInfo> info = new WindowTransitionInfo();
1135    RemoteAnimation::NotifyAnimationAbilityDied(info);
1136    std::vector<sptr<RSWindowAnimationTarget>> targets;
1137    EXPECT_EQ(true, targets.empty());
1138}
1139
1140/*
1141 * @tc.name: NotifyAnimationMinimize
1142 * @tc.desc: NotifyAnimationMinimize
1143 * @tc.type: FUNC
1144 */
1145HWTEST_F(RemoteAnimationTest, NotifyAnimationMinimize, Function | SmallTest | Level2)
1146{
1147    sptr<WindowTransitionInfo> srcInfo = new WindowTransitionInfo();
1148    sptr<WindowNode> srcNode = new WindowNode();
1149    sptr<RSWindowAnimationFinishedCallback> finishedCallback = RemoteAnimation::CreateHideAnimationFinishedCallback(
1150        srcNode, TransitionEvent::MINIMIZE);
1151    finishedCallback = nullptr;
1152    ASSERT_EQ(finishedCallback, nullptr);
1153    auto result = RemoteAnimation::NotifyAnimationMinimize(srcInfo, srcNode);
1154    ASSERT_EQ(result, WMError::WM_ERROR_NO_MEM);
1155}
1156
1157/*
1158 * @tc.name: CreateAnimationFinishedCallback02
1159 * @tc.desc: CreateAnimationFinishedCallback
1160 * @tc.type: FUNC
1161 */
1162HWTEST_F(RemoteAnimationTest, CreateAnimationFinishedCallback02, Function | SmallTest | Level2)
1163{
1164    std::function<void(void)> callback;
1165    sptr<WindowNode> windowNode = new WindowNode();
1166    std::string timeOutTaskName;
1167    wptr<WindowNode> weakNode = windowNode;
1168    auto timeoutFunc = [callback, timeOutTaskName, weakNode]()
1169    {
1170        callback();
1171        auto node = weakNode.promote();
1172    };
1173    std::vector<sptr<RSWindowAnimationTarget>> targets;
1174    EXPECT_EQ(true, targets.empty());
1175}
1176}
1177}
1178}
1179