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
19#include "display_manager.h"
20#include "iremote_object_mocker.h"
21#include "mock_RSIWindowAnimationController.h"
22#include "remote_animation.h"
23#include "starting_window.h"
24#include "window_helper.h"
25#include "window_transition_info.h"
26#include "scene_board_judgement.h"
27using namespace testing;
28using namespace testing::ext;
29
30namespace OHOS {
31namespace Rosen {
32class StartingWindowTest : public testing::Test {
33public:
34    static void SetUpTestCase();
35    static void TearDownTestCase();
36    void SetUp() override;
37    void TearDown() override;
38
39    sptr<WindowProperty> CreateWindowProperty();
40private:
41    static sptr<WindowTransitionInfo> transitionInfo_;
42    RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
43    std::shared_ptr<Media::PixelMap> ContructPixelMap();
44    static sptr<RSIWindowAnimationController> animationController_;
45    sptr<WindowNode> node_;
46    AnimationConfig animationConfig_;
47};
48
49sptr<WindowTransitionInfo> StartingWindowTest::transitionInfo_ = nullptr;
50sptr<RSIWindowAnimationController> StartingWindowTest::animationController_ = nullptr;
51
52void StartingWindowTest::SetUpTestCase()
53{
54}
55
56void StartingWindowTest::TearDownTestCase()
57{
58}
59
60void StartingWindowTest::SetUp()
61{
62    auto display = DisplayManager::GetInstance().GetDefaultDisplay();
63    ASSERT_TRUE((display != nullptr));
64    sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
65    ASSERT_TRUE((displayInfo != nullptr));
66    transitionInfo_ = new WindowTransitionInfo();
67    animationController_ = new RSIWindowAnimationControllerMocker();
68    ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(animationController_));
69    transitionInfo_->supportWindowModes_ = {
70        AppExecFwk::SupportWindowMode::FULLSCREEN,
71        AppExecFwk::SupportWindowMode::SPLIT,
72        AppExecFwk::SupportWindowMode::FLOATING
73    };
74    node_ = StartingWindow::CreateWindowNode(transitionInfo_, 101); // 101 is windowId
75    node_->SetWindowRect({0, 0, 100, 100}); // 100 test data
76    StartingWindow::SetAnimationConfig(animationConfig_);
77    StartingWindow::transAnimateEnable_ = true;
78}
79
80void StartingWindowTest::TearDown()
81{
82    transitionInfo_ = nullptr;
83    node_ = nullptr;
84}
85
86std::shared_ptr<Media::PixelMap> StartingWindowTest::ContructPixelMap()
87{
88    Media::InitializationOptions opts;
89    opts.size.width = 200;  // 200： test width
90    opts.size.height = 300; // 300： test height
91    opts.pixelFormat = Media::PixelFormat::ARGB_8888;
92    opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
93    std::unique_ptr<Media::PixelMap> pixelMapPtr = Media::PixelMap::Create(opts);
94    return std::shared_ptr<Media::PixelMap>(pixelMapPtr.release());
95}
96
97RSSurfaceNode::SharedPtr StartingWindowTest::CreateRSSurfaceNode()
98{
99    struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
100    rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
101    auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig);
102    return surfaceNode;
103}
104
105sptr<WindowProperty> StartingWindowTest::CreateWindowProperty()
106{
107    sptr<WindowProperty> property = new WindowProperty();
108    return property;
109}
110namespace {
111/**
112 * @tc.name: NeedToStopStartingWindow01
113 * @tc.desc: stop starting window test without main App window
114 * @tc.type: FUNC
115 */
116HWTEST_F(StartingWindowTest, NeedToStopStartingWindow01, Function | SmallTest | Level2)
117{
118    transitionInfo_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
119    sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
120    ASSERT_EQ(true, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
121        node->GetModeSupportInfo(), transitionInfo_));
122}
123
124/**
125 * @tc.name: NeedToStopStartingWindow02
126 * @tc.desc: need to stop starting window test with unsupport mode
127 * @tc.type: FUNC
128 */
129HWTEST_F(StartingWindowTest, NeedToStopStartingWindow02, Function | SmallTest | Level2)
130{
131    sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
132    node->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
133    node->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
134    ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
135        node->GetModeSupportInfo(), transitionInfo_));
136}
137
138/**
139 * @tc.name: NeedToStopStartingWindow03
140 * @tc.desc: need to stop starting window test with support mode
141 * @tc.type: FUNC
142 */
143HWTEST_F(StartingWindowTest, NeedToStopStartingWindow03, Function | SmallTest | Level2)
144{
145    sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
146    ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
147        node->GetModeSupportInfo(), transitionInfo_));
148}
149
150/**
151 * @tc.name: NeedToStopStartingWindow04
152 * @tc.desc: need to stop starting window test with support mode
153 * @tc.type: FUNC
154 */
155HWTEST_F(StartingWindowTest, NeedToStopStartingWindow04, Function | SmallTest | Level2)
156{
157    sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
158    transitionInfo_->SetShowFlagWhenLocked(true);
159    node->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY |
160                             WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_SECONDARY);
161    ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
162        node->GetModeSupportInfo(), transitionInfo_));
163}
164
165/**
166 * @tc.name: CreateWindowNode01
167 * @tc.desc: create starting window node test
168 * @tc.type: FUNC
169 */
170HWTEST_F(StartingWindowTest, CreateWindowNode01, Function | SmallTest | Level2)
171{
172    sptr<WindowTransitionInfo> info = nullptr;
173    ASSERT_EQ(nullptr, StartingWindow::CreateWindowNode(info, 0));
174}
175
176/**
177 * @tc.name: CreateWindowNode02
178 * @tc.desc: create starting window node test
179 * @tc.type: FUNC
180 */
181HWTEST_F(StartingWindowTest, CreateWindowNode02, Function | SmallTest | Level2)
182{
183    transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
184    sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
185    ASSERT_NE(nullptr, node);
186    ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, node->GetWindowMode());
187}
188
189/**
190 * @tc.name: CreateWindowNode03
191 * @tc.desc: create starting window node test
192 * @tc.type: FUNC
193 */
194HWTEST_F(StartingWindowTest, CreateWindowNode03, Function | SmallTest | Level2)
195{
196    transitionInfo_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
197    sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
198    ASSERT_NE(nullptr, node);
199    ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, node->GetWindowMode());
200}
201
202/**
203 * @tc.name: CreateWindowNode04
204 * @tc.desc: create starting window node test
205 * @tc.type: FUNC
206 */
207HWTEST_F(StartingWindowTest, CreateWindowNode04, Function | SmallTest | Level2)
208{
209    transitionInfo_->SetShowFlagWhenLocked(true);
210    sptr<WindowNode> node = StartingWindow::CreateWindowNode(transitionInfo_, 0);
211    ASSERT_NE(nullptr, node);
212}
213
214/**
215 * @tc.name: DrawStartingWindow01
216 * @tc.desc: draw starting window node
217 * @tc.type: FUNC
218 */
219HWTEST_F(StartingWindowTest, DrawStartingWindow01, Function | SmallTest | Level2)
220{
221    std::shared_ptr<Media::PixelMap> pixelMap = ContructPixelMap();
222    sptr<WindowNode> node = nullptr;
223    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::DrawStartingWindow(node, pixelMap, 0x00FFFFFF, true));
224    usleep(10000);
225}
226
227/**
228 * @tc.name: DrawStartingWindow02
229 * @tc.desc: draw starting window node
230 * @tc.type: FUNC
231 */
232HWTEST_F(StartingWindowTest, DrawStartingWindow02, Function | SmallTest | Level2)
233{
234    node_->leashWinSurfaceNode_ = nullptr;
235    std::shared_ptr<Media::PixelMap> pixelMap = ContructPixelMap();
236    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
237    usleep(10000);
238}
239
240/**
241 * @tc.name: DrawStartingWindow03
242 * @tc.desc: draw starting window node
243 * @tc.type: FUNC
244 */
245HWTEST_F(StartingWindowTest, DrawStartingWindow03, Function | SmallTest | Level2)
246{
247    std::shared_ptr<Media::PixelMap> pixelMap = ContructPixelMap();
248    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, false));
249    usleep(10000);
250}
251
252/**
253 * @tc.name: DrawStartingWindow04
254 * @tc.desc: draw starting window node
255 * @tc.type: FUNC
256 */
257HWTEST_F(StartingWindowTest, DrawStartingWindow04, Function | SmallTest | Level2)
258{
259    node_->startingWinSurfaceNode_ = nullptr;
260    std::shared_ptr<Media::PixelMap> pixelMap = ContructPixelMap();
261    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
262    usleep(10000);
263}
264
265/**
266 * @tc.name: DrawStartingWindow05
267 * @tc.desc: draw starting window node
268 * @tc.type: FUNC
269 */
270HWTEST_F(StartingWindowTest, DrawStartingWindow05, Function | SmallTest | Level2)
271{
272    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x00FFFFFF, true));
273    usleep(10000);
274}
275
276/**
277 * @tc.name: DrawStartingWindow06
278 * @tc.desc: draw starting window node
279 * @tc.type: FUNC
280 */
281HWTEST_F(StartingWindowTest, DrawStartingWindow06, Function | SmallTest | Level2)
282{
283    std::shared_ptr<Media::PixelMap> pixelMap = ContructPixelMap();
284    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, pixelMap, 0x00FFFFFF, true));
285    usleep(10000);
286}
287
288/**
289 * @tc.name: HandleClientWindowCreateAndRelease01
290 * @tc.desc: handle client window create
291 * @tc.type: FUNC
292 */
293HWTEST_F(StartingWindowTest, HandleClientWindowCreateAndRelease01, Function | SmallTest | Level2)
294{
295    sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
296    sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
297    ASSERT_NE(nullptr, iWindow);
298    uint32_t windowId = 0;
299    auto surfaceNode = CreateRSSurfaceNode();
300    ASSERT_NE(nullptr, surfaceNode);
301    sptr<WindowProperty> windowProperty = new WindowProperty();
302    StartingWindow::HandleClientWindowCreate(node_, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
303    ASSERT_EQ(node_->GetWindowId(), windowId);
304    usleep(200000);
305    StartingWindow::transAnimateEnable_ = false;
306    StartingWindow::HandleClientWindowCreate(node_, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
307    ASSERT_EQ(node_->GetWindowId(), windowId);
308    usleep(200000);
309    StartingWindow::ReleaseStartWinSurfaceNode(node_);
310}
311
312/**
313 * @tc.name: HandleClientWindowCreate02
314 * @tc.desc: handle client window create
315 * @tc.type: FUNC
316 */
317HWTEST_F(StartingWindowTest, HandleClientWindowCreate02, Function | SmallTest | Level2)
318{
319    sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
320    sptr<IWindow> iWindow = iface_cast<IWindow>(iRemoteObjectMocker);
321    ASSERT_NE(nullptr, iWindow);
322    uint32_t windowId = 0;
323    auto surfaceNode = CreateRSSurfaceNode();
324    ASSERT_NE(nullptr, surfaceNode);
325    sptr<WindowProperty> windowProperty = new WindowProperty();
326    sptr<WindowNode> node = nullptr;
327    StartingWindow::HandleClientWindowCreate(node, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
328    usleep(200000);
329}
330
331/**
332 * @tc.name: HandleClientWindowCreateAndRelease03
333 * @tc.desc: handle client window create and Release with null leashNode
334 * @tc.type: FUNC
335 */
336HWTEST_F(StartingWindowTest, HandleClientWindowCreateAndRelease03, Function | SmallTest | Level2)
337{
338    node_->leashWinSurfaceNode_ = nullptr;
339    uint32_t windowId = 0;
340    auto surfaceNode = CreateRSSurfaceNode();
341    ASSERT_NE(nullptr, surfaceNode);
342    sptr<WindowProperty> windowProperty = new WindowProperty();
343    sptr<IWindow> iWindow = nullptr;
344    StartingWindow::HandleClientWindowCreate(node_, iWindow, windowId, surfaceNode, windowProperty, 0, 0);
345    usleep(200000);
346    StartingWindow::ReleaseStartWinSurfaceNode(node_);
347}
348
349/**
350 * @tc.name: AddNodeOnRSTree01
351 * @tc.desc: Add node on rs tree test with surfaceNode nullptr and hot start
352 * @tc.type: FUNC
353 */
354HWTEST_F(StartingWindowTest, AddNodeOnRSTree01, Function | SmallTest | Level2)
355{
356    sptr<RSIWindowAnimationController> testController = nullptr;
357    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
358    StartingWindow::AddNodeOnRSTree(node_, true);
359    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
360    usleep(200000);
361}
362
363/**
364 * @tc.name: AddNodeOnRSTree02
365 * @tc.desc: Add node on rs tree test with hot start and surfaceNode
366 * @tc.type: FUNC
367 */
368HWTEST_F(StartingWindowTest, AddNodeOnRSTree02, Function | SmallTest | Level2)
369{
370    auto surfaceNode = CreateRSSurfaceNode();
371    ASSERT_NE(nullptr, surfaceNode);
372    node_->surfaceNode_ = surfaceNode;
373    sptr<RSIWindowAnimationController> testController = nullptr;
374    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
375    StartingWindow::AddNodeOnRSTree(node_, true);
376    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
377    usleep(200000);
378}
379
380/**
381 * @tc.name: AddNodeOnRSTree03
382 * @tc.desc: Add node on rs tree test
383 * @tc.type: FUNC
384 */
385HWTEST_F(StartingWindowTest, AddNodeOnRSTree03, Function | SmallTest | Level2)
386{
387    auto surfaceNode = CreateRSSurfaceNode();
388    ASSERT_NE(nullptr, surfaceNode);
389    node_->surfaceNode_ = surfaceNode;
390    node_->leashWinSurfaceNode_ = nullptr;
391    sptr<RSIWindowAnimationController> testController = nullptr;
392    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, RemoteAnimation::SetWindowAnimationController(testController));
393    StartingWindow::AddNodeOnRSTree(node_, true);
394    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
395    usleep(200000);
396}
397
398/**
399 * @tc.name: AddNodeOnRSTree04
400 * @tc.desc: Add node on rs tree test with surfaceNode nullptr, with animation controller
401 * @tc.type: FUNC
402 */
403HWTEST_F(StartingWindowTest, AddNodeOnRSTree04, Function | SmallTest | Level2)
404{
405    sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
406    ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
407    StartingWindow::AddNodeOnRSTree(node_, true);
408    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
409    usleep(200000);
410}
411
412/**
413 * @tc.name: AddNodeOnRSTree05
414 * @tc.desc: Add node on rs tree test
415 * @tc.type: FUNC
416 */
417HWTEST_F(StartingWindowTest, AddNodeOnRSTree05, Function | SmallTest | Level2)
418{
419    auto surfaceNode = CreateRSSurfaceNode();
420    ASSERT_NE(nullptr, surfaceNode);
421    node_->surfaceNode_ = surfaceNode;
422    sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
423    ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
424    AnimationConfig config;
425    StartingWindow::AddNodeOnRSTree(node_, true);
426    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
427    usleep(200000);
428}
429
430/**
431 * @tc.name: AddNodeOnRSTree06
432 * @tc.desc: Add node on rs tree test
433 * @tc.type: FUNC
434 */
435HWTEST_F(StartingWindowTest, AddNodeOnRSTree06, Function | SmallTest | Level2)
436{
437    auto surfaceNode = CreateRSSurfaceNode();
438    ASSERT_NE(nullptr, surfaceNode);
439    node_->surfaceNode_ = surfaceNode;
440    node_->leashWinSurfaceNode_ = nullptr;
441    sptr<RSIWindowAnimationController> testController = new RSIWindowAnimationControllerMocker();
442    ASSERT_EQ(WMError::WM_OK, RemoteAnimation::SetWindowAnimationController(testController));
443    StartingWindow::AddNodeOnRSTree(node_, true);
444    ASSERT_EQ(WMError::WM_OK, StartingWindow::DrawStartingWindow(node_, nullptr, 0x66FFFFFF, false));
445    usleep(200000);
446}
447
448/**
449 * @tc.name: SetStartingWindowAnimation
450 * @tc.desc: set starting window animation with different parameter
451 * @tc.type: FUNC
452 */
453HWTEST_F(StartingWindowTest, SetStartingWindowAnimation01, Function | SmallTest | Level2)
454{
455    sptr<WindowNode> windowNode = nullptr;
456    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::SetStartingWindowAnimation(windowNode));
457
458    ASSERT_EQ(WMError::WM_OK, StartingWindow::SetStartingWindowAnimation(node_));
459
460    node_->leashWinSurfaceNode_ = nullptr;
461    ASSERT_EQ(WMError::WM_OK, StartingWindow::SetStartingWindowAnimation(node_));
462
463    node_->startingWinSurfaceNode_ = nullptr;
464    ASSERT_EQ(WMError::WM_ERROR_NULLPTR, StartingWindow::SetStartingWindowAnimation(node_));
465}
466
467/**
468 * @tc.name: CreateLeashAndStartingSurfaceNode01
469 * @tc.desc: CreateLeashAndStartingSurfaceNode
470 * @tc.type: FUNC
471 */
472HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode01, Function | SmallTest | Level2)
473{
474    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode01 start";
475    node_->leashWinSurfaceNode_ = nullptr;
476    ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
477    usleep(10000);
478    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode01 end";
479}
480
481/**
482 * @tc.name: CreateLeashAndStartingSurfaceNode02
483 * @tc.desc: CreateLeashAndStartingSurfaceNode
484 * @tc.type: FUNC
485 */
486HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode02, Function | SmallTest | Level2)
487{
488    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode02 start";
489    node_->startingWinSurfaceNode_ = nullptr;
490    ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
491    usleep(10000);
492    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode02 end";
493}
494
495/**
496 * @tc.name: CreateLeashAndStartingSurfaceNode03
497 * @tc.desc: CreateLeashAndStartingSurfaceNode
498 * @tc.type: FUNC
499 */
500HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode03, Function | SmallTest | Level2)
501{
502    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode03 start";
503    ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
504    usleep(10000);
505    GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode03 end";
506}
507
508/**
509 * @tc.name: SetDefaultWindowMode
510 * @tc.desc: SetDefaultWindowMode
511 * @tc.type: FUNC
512 */
513HWTEST_F(StartingWindowTest, SetDefaultWindowMode, Function | SmallTest | Level2)
514{
515    GTEST_LOG_(INFO) << "StartingWindow::SetDefaultWindowMode start";
516    WindowMode defaultMode = WindowMode::WINDOW_MODE_FULLSCREEN;
517    StartingWindow::SetDefaultWindowMode(defaultMode);
518    GTEST_LOG_(INFO) << "StartingWindow::SetDefaultWindowMode end";
519}
520
521/**
522 * @tc.name: SetAnimationConfig
523 * @tc.desc: SetAnimationConfig
524 * @tc.type: FUNC
525 */
526HWTEST_F(StartingWindowTest, SetAnimationConfig, Function | SmallTest | Level2)
527{
528    GTEST_LOG_(INFO) << "StartingWindow::SetAnimationConfig start";
529    auto& animationConfig = WindowNodeContainer::GetAnimationConfigRef();
530    StartingWindow::SetAnimationConfig(animationConfig);
531    GTEST_LOG_(INFO) << "StartingWindow::SetAnimationConfig end";
532}
533}
534}
535}
536