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"
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 class StartingWindowTest : public testing::Test {
33 public:
34     static void SetUpTestCase();
35     static void TearDownTestCase();
36     void SetUp() override;
37     void TearDown() override;
38 
39     sptr<WindowProperty> CreateWindowProperty();
40 private:
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 
49 sptr<WindowTransitionInfo> StartingWindowTest::transitionInfo_ = nullptr;
50 sptr<RSIWindowAnimationController> StartingWindowTest::animationController_ = nullptr;
51 
SetUpTestCase()52 void StartingWindowTest::SetUpTestCase()
53 {
54 }
55 
TearDownTestCase()56 void StartingWindowTest::TearDownTestCase()
57 {
58 }
59 
SetUp()60 void 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 
TearDown()80 void StartingWindowTest::TearDown()
81 {
82     transitionInfo_ = nullptr;
83     node_ = nullptr;
84 }
85 
ContructPixelMap()86 std::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 
CreateRSSurfaceNode()97 RSSurfaceNode::SharedPtr StartingWindowTest::CreateRSSurfaceNode()
98 {
99     struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
100     rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
101     auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig);
102     return surfaceNode;
103 }
104 
CreateWindowProperty()105 sptr<WindowProperty> StartingWindowTest::CreateWindowProperty()
106 {
107     sptr<WindowProperty> property = new WindowProperty();
108     return property;
109 }
110 namespace {
111 /**
112  * @tc.name: NeedToStopStartingWindow01
113  * @tc.desc: stop starting window test without main App window
114  * @tc.type: FUNC
115  */
116 HWTEST_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->GetWindowModeSupportType(), 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  */
129 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow02, Function | SmallTest | Level2)
130 {
131     sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
132     node->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
133     node->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
134     ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
135         node->GetWindowModeSupportType(), 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  */
143 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow03, Function | SmallTest | Level2)
144 {
145     sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
146     ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
147         node->GetWindowModeSupportType(), 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  */
155 HWTEST_F(StartingWindowTest, NeedToStopStartingWindow04, Function | SmallTest | Level2)
156 {
157     sptr<WindowNode> node = new WindowNode(CreateWindowProperty());
158     transitionInfo_->SetShowFlagWhenLocked(true);
159     node->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY |
160                                    WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_SECONDARY);
161     ASSERT_EQ(false, WindowHelper::CheckSupportWindowMode(node->GetWindowMode(),
162         node->GetWindowModeSupportType(), transitionInfo_));
163 }
164 
165 /**
166  * @tc.name: CreateWindowNode01
167  * @tc.desc: create starting window node test
168  * @tc.type: FUNC
169  */
170 HWTEST_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  */
181 HWTEST_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  */
194 HWTEST_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  */
207 HWTEST_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  */
219 HWTEST_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  */
232 HWTEST_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  */
245 HWTEST_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  */
257 HWTEST_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  */
270 HWTEST_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  */
281 HWTEST_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  */
293 HWTEST_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  */
317 HWTEST_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  */
336 HWTEST_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  */
354 HWTEST_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  */
368 HWTEST_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  */
385 HWTEST_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  */
403 HWTEST_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  */
417 HWTEST_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  */
435 HWTEST_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  */
453 HWTEST_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: IsWindowFollowParent01
469  * @tc.desc: IsWindowFollowParent
470  * @tc.type: FUNC
471  */
472 HWTEST_F(StartingWindowTest, IsWindowFollowParent01, Function | SmallTest | Level2)
473 {
474     if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
475         ASSERT_EQ(false, StartingWindow::IsWindowFollowParent(WindowType::WINDOW_TYPE_DIALOG));
476         ASSERT_EQ(true, StartingWindow::IsWindowFollowParent(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
477     } else {
478         ASSERT_EQ(true, StartingWindow::IsWindowFollowParent(WindowType::WINDOW_TYPE_DIALOG));
479         ASSERT_EQ(true, StartingWindow::IsWindowFollowParent(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
480     }
481     ASSERT_EQ(false, StartingWindow::IsWindowFollowParent(WindowType::WINDOW_TYPE_APP_COMPONENT));
482 }
483 
484 /**
485  * @tc.name: CreateLeashAndStartingSurfaceNode01
486  * @tc.desc: CreateLeashAndStartingSurfaceNode
487  * @tc.type: FUNC
488  */
489 HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode01, Function | SmallTest | Level2)
490 {
491     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode01 start";
492     node_->leashWinSurfaceNode_ = nullptr;
493     ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
494     usleep(10000);
495     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode01 end";
496 }
497 
498 /**
499  * @tc.name: CreateLeashAndStartingSurfaceNode02
500  * @tc.desc: CreateLeashAndStartingSurfaceNode
501  * @tc.type: FUNC
502  */
503 HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode02, Function | SmallTest | Level2)
504 {
505     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode02 start";
506     node_->startingWinSurfaceNode_ = nullptr;
507     ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
508     usleep(10000);
509     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode02 end";
510 }
511 
512 /**
513  * @tc.name: CreateLeashAndStartingSurfaceNode03
514  * @tc.desc: CreateLeashAndStartingSurfaceNode
515  * @tc.type: FUNC
516  */
517 HWTEST_F(StartingWindowTest, CreateLeashAndStartingSurfaceNode03, Function | SmallTest | Level2)
518 {
519     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode03 start";
520     ASSERT_EQ(WMError::WM_OK, StartingWindow::CreateLeashAndStartingSurfaceNode(node_));
521     usleep(10000);
522     GTEST_LOG_(INFO) << "StartingWindow::CreateLeashAndStartingSurfaceNode03 end";
523 }
524 
525 /**
526  * @tc.name: SetDefaultWindowMode
527  * @tc.desc: SetDefaultWindowMode
528  * @tc.type: FUNC
529  */
530 HWTEST_F(StartingWindowTest, SetDefaultWindowMode, Function | SmallTest | Level2)
531 {
532     GTEST_LOG_(INFO) << "StartingWindow::SetDefaultWindowMode start";
533     WindowMode defaultMode = WindowMode::WINDOW_MODE_FULLSCREEN;
534     StartingWindow::SetDefaultWindowMode(defaultMode);
535     GTEST_LOG_(INFO) << "StartingWindow::SetDefaultWindowMode end";
536 }
537 
538 /**
539  * @tc.name: SetAnimationConfig
540  * @tc.desc: SetAnimationConfig
541  * @tc.type: FUNC
542  */
543 HWTEST_F(StartingWindowTest, SetAnimationConfig, Function | SmallTest | Level2)
544 {
545     GTEST_LOG_(INFO) << "StartingWindow::SetAnimationConfig start";
546     auto& animationConfig = WindowNodeContainer::GetAnimationConfigRef();
547     StartingWindow::SetAnimationConfig(animationConfig);
548     GTEST_LOG_(INFO) << "StartingWindow::SetAnimationConfig end";
549 }
550 }
551 }
552 }
553