1 /*
2  * Copyright (c) 2024 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 <parameters.h>
18 #include "ability_context_impl.h"
19 #include "display_info.h"
20 #include "mock_session.h"
21 #include "mock_uicontent.h"
22 #include "mock_window_adapter.h"
23 #include "singleton_mocker.h"
24 #include "window_scene_session_impl.h"
25 #include "window_session_impl.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Rosen {
32 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
33 class WindowSceneSessionImplTest4 : public testing::Test {
34 public:
35     static void SetUpTestCase();
36     static void TearDownTestCase();
37     void SetUp() override;
38     void TearDown() override;
39 
40     std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
41     std::unique_ptr<Mocker> mocker_ = std::make_unique<Mocker>();
42 
43 private:
44     RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
45     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
46 };
47 
SetUpTestCase()48 void WindowSceneSessionImplTest4::SetUpTestCase() {}
49 
TearDownTestCase()50 void WindowSceneSessionImplTest4::TearDownTestCase() {}
51 
SetUp()52 void WindowSceneSessionImplTest4::SetUp()
53 {
54     abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
55 }
56 
TearDown()57 void WindowSceneSessionImplTest4::TearDown()
58 {
59     usleep(WAIT_SYNC_IN_NS);
60     abilityContext_ = nullptr;
61 }
62 
CreateRSSurfaceNode()63 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest4::CreateRSSurfaceNode()
64 {
65     struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
66     rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
67     auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
68     return surfaceNode;
69 }
70 
71 namespace {
72 /**
73  * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
74  * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation
75  * @tc.type: FUNC
76  */
77 HWTEST_F(WindowSceneSessionImplTest4, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level2)
78 {
79     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
80     ASSERT_NE(nullptr, option);
81     option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
82     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
83     ASSERT_NE(nullptr, windowSceneSessionImpl);
84 
85     windowSceneSessionImpl->hostSession_ = nullptr;
86     auto ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
87     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
88 
89     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
90     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
91     ASSERT_NE(nullptr, session);
92     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
93     windowSceneSessionImpl->property_->SetPersistentId(1);
94     windowSceneSessionImpl->hostSession_ = session;
95     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
96     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
97     windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_END);
98     ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
99     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
100     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
101     windowSceneSessionImpl->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
102     ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
103     EXPECT_EQ(WMError::WM_OK, ret);
104 }
105 
106 /**
107  * @tc.name: RegisterSessionRecoverListener
108  * @tc.desc: RegisterSessionRecoverListener
109  * @tc.type: FUNC
110  */
111 HWTEST_F(WindowSceneSessionImplTest4, RegisterSessionRecoverListener, Function | SmallTest | Level2)
112 {
113     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
114     ASSERT_NE(nullptr, option);
115     option->SetWindowName("RegisterSessionRecoverListener");
116     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
117     ASSERT_NE(nullptr, windowSceneSessionImpl);
118 
119     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
120     windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
121     windowSceneSessionImpl->RegisterSessionRecoverListener(true);
122     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
123     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
124     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
125     windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::RESERVE_TYPE);
126     windowSceneSessionImpl->RegisterSessionRecoverListener(true);
127     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
128     windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
129     windowSceneSessionImpl->RegisterSessionRecoverListener(true);
130     windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
131     windowSceneSessionImpl->RegisterSessionRecoverListener(true);
132     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
133     windowSceneSessionImpl->RegisterSessionRecoverListener(true);
134 }
135 
136 /**
137  * @tc.name: ConsumePointerEvent
138  * @tc.desc: ConsumePointerEvent
139  * @tc.type: FUNC
140  */
141 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEvent, Function | SmallTest | Level2)
142 {
143     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
144     ASSERT_NE(nullptr, option);
145     option->SetWindowName("ConsumePointerEvent");
146     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
147     ASSERT_NE(nullptr, windowSceneSessionImpl);
148 
149     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
150     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
151     ASSERT_NE(nullptr, session);
152     windowSceneSessionImpl->hostSession_ = session;
153     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
154     ASSERT_NE(nullptr, pointerEvent);
155     windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
156     windowSceneSessionImpl->hostSession_ = nullptr;
157     windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
158     pointerEvent = nullptr;
159     windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
160     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
161     windowSceneSessionImpl->property_->SetTurnScreenOn(true);
162     auto ret = windowSceneSessionImpl->IsTurnScreenOn();
163     EXPECT_EQ(true, ret);
164     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
165     windowSceneSessionImpl->property_->SetTurnScreenOn(false);
166     ret = windowSceneSessionImpl->IsTurnScreenOn();
167     EXPECT_EQ(false, ret);
168 }
169 
170 /**
171  * @tc.name: GetSystemSizeLimits01
172  * @tc.desc: GetSystemSizeLimits
173  * @tc.type: FUNC
174  */
175 HWTEST_F(WindowSceneSessionImplTest4, GetSystemSizeLimits01, Function | SmallTest | Level2)
176 {
177     uint32_t minMainWidth = 10;
178     uint32_t minMainHeight = 20;
179     uint32_t minSubWidth = 30;
180     uint32_t minSubHeight = 40;
181     uint32_t displayWidth = 100;
182     uint32_t displayHeight = 100;
183     float displayVpr = 1.0f;
184     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
185     ASSERT_NE(nullptr, option);
186     option->SetWindowName("GetSystemSizeLimits01");
187     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
188     ASSERT_NE(nullptr, windowSceneSessionImpl);
189     windowSceneSessionImpl->windowSystemConfig_.miniWidthOfMainWindow_ = minMainWidth;
190     windowSceneSessionImpl->windowSystemConfig_.miniHeightOfMainWindow_ = minMainHeight;
191     windowSceneSessionImpl->windowSystemConfig_.miniWidthOfSubWindow_ = minSubWidth;
192     windowSceneSessionImpl->windowSystemConfig_.miniHeightOfSubWindow_ = minSubHeight;
193 
194     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
195     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
196     WindowLimits limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
197     EXPECT_EQ(limits.minWidth_, minMainWidth);
198     EXPECT_EQ(limits.minHeight_, minMainHeight);
199 
200     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
201     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
202     limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
203     EXPECT_EQ(limits.minWidth_, minSubWidth);
204     EXPECT_EQ(limits.minHeight_, minSubHeight);
205 
206     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
207     windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
208     limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
209     EXPECT_EQ(limits.minWidth_, MIN_FLOATING_WIDTH);
210     EXPECT_EQ(limits.minHeight_, MIN_FLOATING_HEIGHT);
211 }
212 
213 /**
214  * @tc.name: CalculateNewLimitsByRatio
215  * @tc.desc: CalculateNewLimitsByRatio
216  * @tc.type: FUNC
217  */
218 HWTEST_F(WindowSceneSessionImplTest4, CalculateNewLimitsByRatio, Function | SmallTest | Level2)
219 {
220     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
221     ASSERT_NE(nullptr, option);
222     option->SetWindowName("CalculateNewLimitsByRatio");
223     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
224     ASSERT_NE(nullptr, windowSceneSessionImpl);
225 
226     WindowLimits newLimits = {0, 0, 0, 0, 0.0, 0.0};
227     WindowLimits customizedLimits = {3, 3, 3, 3, 0.0, 0.0};
228     windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
229     newLimits = {500, 500, 500, 500, 0.0, 0.0};
230     customizedLimits = {3, 3, 3, 3, 2.0, 2.0};
231     windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
232     customizedLimits = {3, 3, 3, 3, 1.0, 1.0};
233     windowSceneSessionImpl->CalculateNewLimitsByRatio(newLimits, customizedLimits);
234     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
235     windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_END);
236     auto ret = windowSceneSessionImpl->UpdateAnimationFlagProperty(true);
237     EXPECT_EQ(WMError::WM_OK, ret);
238     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
239     windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
240     ret = windowSceneSessionImpl->UpdateAnimationFlagProperty(true);
241     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
242 }
243 
244 /**
245  * @tc.name: HandlePointDownEvent
246  * @tc.desc: HandlePointDownEvent
247  * @tc.type: FUNC
248  */
249 HWTEST_F(WindowSceneSessionImplTest4, HandlePointDownEvent, Function | SmallTest | Level2)
250 {
251     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
252     ASSERT_NE(nullptr, option);
253     option->SetWindowName("HandlePointDownEvent");
254     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
255     ASSERT_NE(nullptr, windowSceneSessionImpl);
256 
257     std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
258     MMI::PointerEvent::PointerItem pointerItem;
259     int32_t sourceType = 1;
260     float vpr = 1.0f;
261     WSRect rect = {1, 1, 1, 1};
262 
263     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
264     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
265     ASSERT_NE(nullptr, session);
266     windowSceneSessionImpl->hostSession_ = session;
267     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
268     windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
269 
270     windowSceneSessionImpl->property_->SetDragEnabled(false);
271     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
272     windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
273     auto ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
274     EXPECT_EQ(true, ret);
275 
276     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
277     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
278     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
279     windowSceneSessionImpl->property_->SetDragEnabled(false);
280     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
281     EXPECT_EQ(true, ret);
282     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
283     windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
284     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
285 
286     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
287     EXPECT_EQ(true, ret);
288     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
289 
290     pointerItem.SetWindowX(100);
291     pointerItem.SetWindowY(100);
292     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
293     EXPECT_EQ(true, ret);
294     pointerItem.SetWindowX(1);
295     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
296     EXPECT_EQ(true, ret);
297 
298     windowSceneSessionImpl->property_->SetDragEnabled(true);
299     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
300     EXPECT_EQ(false, ret);
301 
302     pointerItem.SetWindowX(100);
303     ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
304     EXPECT_EQ(true, ret);
305 }
306 
307 /**
308  * @tc.name: UpdateWindowModeImmediately
309  * @tc.desc: UpdateWindowModeImmediately
310  * @tc.type: FUNC
311  */
312 HWTEST_F(WindowSceneSessionImplTest4, UpdateWindowModeImmediately, Function | SmallTest | Level2)
313 {
314     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
315     ASSERT_NE(nullptr, option);
316     option->SetWindowName("UpdateWindowModeImmediately");
317     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
318     ASSERT_NE(nullptr, windowSceneSessionImpl);
319 
320     windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
321     auto ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
322     EXPECT_EQ(WMError::WM_OK, ret);
323     windowSceneSessionImpl->state_ = WindowState::STATE_HIDDEN;
324     ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
325     EXPECT_EQ(WMError::WM_OK, ret);
326     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
327     windowSceneSessionImpl->hostSession_ = nullptr;
328     ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
329     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
330     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
331     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
332     ASSERT_NE(nullptr, session);
333     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
334     windowSceneSessionImpl->property_->SetPersistentId(1);
335     windowSceneSessionImpl->hostSession_ = session;
336     ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
337     EXPECT_EQ(WMError::WM_OK, ret);
338     ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
339     EXPECT_EQ(WMError::WM_OK, ret);
340     windowSceneSessionImpl->state_ = WindowState::STATE_UNFROZEN;
341     ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
342     EXPECT_EQ(WMError::WM_OK, ret);
343 }
344 
345 /**
346  * @tc.name: AdjustWindowAnimationFlag
347  * @tc.desc: AdjustWindowAnimationFlag
348  * @tc.type: FUNC
349  */
350 HWTEST_F(WindowSceneSessionImplTest4, AdjustWindowAnimationFlag, Function | SmallTest | Level2)
351 {
352     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
353     ASSERT_NE(nullptr, option);
354     option->SetWindowName("AdjustWindowAnimationFlag");
355     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
356     ASSERT_NE(nullptr, windowSceneSessionImpl);
357     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
358     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
359     ASSERT_NE(nullptr, session);
360     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
361     windowSceneSessionImpl->property_->SetPersistentId(1);
362     windowSceneSessionImpl->hostSession_ = session;
363     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
364 
365     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
366     windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
367     windowSceneSessionImpl->animationTransitionController_ = sptr<IAnimationTransitionController>::MakeSptr();
368     ASSERT_NE(nullptr, windowSceneSessionImpl->animationTransitionController_);
369     windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
370     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
371     auto ret = windowSceneSessionImpl->property_->GetAnimationFlag();
372     EXPECT_EQ(3, ret);
373     windowSceneSessionImpl->animationTransitionController_ = nullptr;
374     windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
375     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
376     ret = windowSceneSessionImpl->property_->GetAnimationFlag();
377     EXPECT_EQ(1, ret);
378     windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
379     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
380     ret = windowSceneSessionImpl->property_->GetAnimationFlag();
381     EXPECT_EQ(0, ret);
382     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
383     windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
384     windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
385     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
386     ret = windowSceneSessionImpl->property_->GetAnimationFlag();
387     EXPECT_EQ(1, ret);
388     windowSceneSessionImpl->enableDefaultAnimation_ = false;
389     windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
390     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
391     ret = windowSceneSessionImpl->property_->GetAnimationFlag();
392     EXPECT_EQ(0, ret);
393 }
394 
395 /**
396  * @tc.name: UpdateConfigurationForAll
397  * @tc.desc: UpdateConfigurationForAll
398  * @tc.type: FUNC
399  */
400 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationForAll, Function | SmallTest | Level2)
401 {
402     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
403     ASSERT_NE(nullptr, option);
404     option->SetWindowName("UpdateConfigurationForAll");
405     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
406     ASSERT_NE(nullptr, windowSceneSessionImpl);
407 
408     std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
409     ASSERT_NE(nullptr, configuration);
410     sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
411     ASSERT_NE(nullptr, windowSession);
412     SessionInfo sessionInfo = {"CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1"};
413     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
414     ASSERT_NE(nullptr, session);
415     windowSession->hostSession_ = session;
416     ASSERT_NE(nullptr, windowSession->property_);
417     windowSession->property_->SetPersistentId(1);
418     windowSession->state_ = WindowState::STATE_SHOWN;
419     ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
420     windowSceneSessionImpl->UpdateConfigurationForAll(configuration);
421     ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
422 }
423 
424 /**
425  * @tc.name: SetWindowFlags
426  * @tc.desc: SetWindowFlags
427  * @tc.type: FUNC
428  */
429 HWTEST_F(WindowSceneSessionImplTest4, SetWindowFlags, Function | SmallTest | Level2)
430 {
431     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
432     ASSERT_NE(nullptr, option);
433     option->SetWindowName("SetWindowFlags");
434     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
435     ASSERT_NE(nullptr, windowSceneSessionImpl);
436 
437     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
438     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
439     ASSERT_NE(nullptr, session);
440     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
441     windowSceneSessionImpl->property_->SetPersistentId(1);
442     windowSceneSessionImpl->hostSession_ = session;
443     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
444     windowSceneSessionImpl->SetWindowFlags(1);
445     auto ret = windowSceneSessionImpl->SetWindowFlags(1);
446     EXPECT_EQ(WMError::WM_OK, ret);
447     ret = windowSceneSessionImpl->SetWindowFlags(2);
448     EXPECT_EQ(WMError::WM_OK, ret);
449     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
450     windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
451     ret = windowSceneSessionImpl->NotifyPrepareClosePiPWindow();
452     EXPECT_EQ(WMError::WM_OK, ret);
453 }
454 
455 /**
456  * @tc.name: ConsumePointerEventInner
457  * @tc.desc: ConsumePointerEventInner
458  * @tc.type: FUNC
459  */
460 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEventInner, Function | SmallTest | Level2)
461 {
462     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
463     ASSERT_NE(nullptr, option);
464     option->SetWindowName("ConsumePointerEventInner");
465     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
466     ASSERT_NE(nullptr, windowSceneSessionImpl);
467 
468     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
469     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
470     ASSERT_NE(nullptr, session);
471     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
472     windowSceneSessionImpl->property_->SetPersistentId(1);
473     windowSceneSessionImpl->hostSession_ = session;
474     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
475     ASSERT_NE(nullptr, pointerEvent);
476     MMI::PointerEvent::PointerItem pointerItem;
477     pointerEvent->SetPointerAction(10);
478     windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
479     pointerEvent->SetPointerAction(4);
480     windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
481     pointerEvent->SetPointerAction(2);
482     windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
483 }
484 
485 /**
486  * @tc.name: RegisterKeyboardPanelInfoChangeListener
487  * @tc.desc: RegisterKeyboardPanelInfoChangeListener
488  * @tc.type: FUNC
489  */
490 HWTEST_F(WindowSceneSessionImplTest4, RegisterKeyboardPanelInfoChangeListener, Function | SmallTest | Level2)
491 {
492     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
493     ASSERT_NE(nullptr, option);
494     option->SetWindowName("RegisterKeyboardPanelInfoChangeListener");
495     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
496     ASSERT_NE(nullptr, windowSceneSessionImpl);
497 
498     windowSceneSessionImpl->keyboardPanelInfoChangeListeners_ = sptr<IKeyboardPanelInfoChangeListener>::MakeSptr();
499     ASSERT_NE(nullptr, windowSceneSessionImpl->keyboardPanelInfoChangeListeners_);
500     sptr<IKeyboardPanelInfoChangeListener> listener = nullptr;
501     auto ret = windowSceneSessionImpl->RegisterKeyboardPanelInfoChangeListener(listener);
502     EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
503 }
504 
505 /**
506  * @tc.name: GetSystemBarPropertyByType
507  * @tc.desc: GetSystemBarPropertyByType
508  * @tc.type: FUNC
509  */
510 HWTEST_F(WindowSceneSessionImplTest4, GetSystemBarPropertyByType, Function | SmallTest | Level2)
511 {
512     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
513     ASSERT_NE(nullptr, option);
514     option->SetWindowName("GetSystemBarPropertyByType");
515     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
516     ASSERT_NE(nullptr, windowSceneSessionImpl);
517 
518     windowSceneSessionImpl->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
519 }
520 
521 /**
522  * @tc.name: SetSpecificBarProperty
523  * @tc.desc: SetSpecificBarProperty
524  * @tc.type: FUNC
525  */
526 HWTEST_F(WindowSceneSessionImplTest4, SetSpecificBarProperty, Function | SmallTest | Level2)
527 {
528     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
529     ASSERT_NE(nullptr, option);
530     option->SetWindowName("SetSpecificBarProperty");
531     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
532     ASSERT_NE(nullptr, windowSceneSessionImpl);
533 
534     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
535     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
536     ASSERT_NE(nullptr, session);
537     windowSceneSessionImpl->hostSession_ = session;
538     SystemBarProperty property;
539     windowSceneSessionImpl->property_->SetPersistentId(1);
540     windowSceneSessionImpl->state_ = WindowState::STATE_INITIAL;
541     auto type = WindowType::WINDOW_TYPE_STATUS_BAR;
542     auto ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
543     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
544     windowSceneSessionImpl->state_ = WindowState::STATE_BOTTOM;
545     ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
546     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
547     windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
548     ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
549     EXPECT_EQ(WMError::WM_OK, ret);
550     property = SystemBarProperty();
551     property.settingFlag_ = SystemBarSettingFlag::DEFAULT_SETTING;
552     ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
553     EXPECT_EQ(WMError::WM_OK, ret);
554     property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
555     ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
556     EXPECT_EQ(WMError::WM_OK, ret);
557 }
558 
559 /**
560  * @tc.name: MoveToAsync01
561  * @tc.desc: MoveToAsync
562  * @tc.type: FUNC
563  */
564 HWTEST_F(WindowSceneSessionImplTest4, MoveToAsync01, Function | SmallTest | Level2)
565 {
566     sptr<WindowOption> option = new (std::nothrow) WindowOption();
567     ASSERT_NE(nullptr, option);
568     option->SetWindowName("MoveToAsync01");
569     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
570     option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
571     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
572     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveToAsync(10, 10));
573 
574     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
575     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
576     window->hostSession_ = session;
577     window->property_->SetPersistentId(1);
578     ASSERT_EQ(WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS, window->MoveToAsync(10, 10));
579 }
580 
581 /**
582  * @tc.name: MoveToAsync02
583  * @tc.desc: MoveToAsync
584  * @tc.type: FUNC
585  */
586 HWTEST_F(WindowSceneSessionImplTest4, MoveToAsync02, Function | SmallTest | Level2)
587 {
588     sptr<WindowOption> option = new (std::nothrow) WindowOption();
589     ASSERT_NE(nullptr, option);
590     option->SetWindowName("MoveToAsync02");
591     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
592     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
593     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
594     ASSERT_NE(nullptr, window);
595     window->property_->SetPersistentId(998);
596     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
597     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
598     ASSERT_NE(nullptr, session);
599     window->hostSession_ = session;
600 
601     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
602     ASSERT_NE(nullptr, subOption);
603     subOption->SetWindowName("subMoveToAsync02");
604     subOption->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
605     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
606     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
607     ASSERT_NE(nullptr, subWindow);
608     subWindow->property_->SetPersistentId(999);
609     SessionInfo subSessionInfo = { "subCreateTestBundle", "subCreateTestModule", "subCreateTestAbility" };
610     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
611     ASSERT_NE(nullptr, subSession);
612     subWindow->hostSession_ = subSession;
613     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
614 
615     ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
616     ASSERT_EQ(WMError::WM_OK, subWindow->Create(abilityContext_, subSession));
617     subWindow->windowSessionMap_.insert(std::make_pair("MoveToAsync02", std::make_pair(998, window)));
618     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
619     window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
620     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
621     window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
622     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
623     Rect request = { 100, 100, 100, 100 };
624     subWindow->property_->SetRequestRect(request);
625     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
626     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
627     subWindow->state_ = WindowState::STATE_HIDDEN;
628     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
629     subWindow->state_ = WindowState::STATE_SHOWN;
630     ASSERT_EQ(WMError::WM_OK, subWindow->MoveToAsync(10, 10));
631     ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
632     ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
633 }
634 
635 /**
636  * @tc.name: ResizeAsync01
637  * @tc.desc: ResizeAsync
638  * @tc.type: FUNC
639  */
640 HWTEST_F(WindowSceneSessionImplTest4, ResizeAsync01, Function | SmallTest | Level2)
641 {
642     sptr<WindowOption> option = new (std::nothrow) WindowOption();
643     ASSERT_NE(nullptr, option);
644     option->SetWindowName("ResizeAsync01");
645     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
646     option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
647     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
648     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
649     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
650     window->hostSession_ = session;
651     window->property_->SetPersistentId(1);
652     ASSERT_EQ(WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS, window->ResizeAsync(500, 500));
653 }
654 
655 /**
656  * @tc.name: ResizeAsync02
657  * @tc.desc: ResizeAsync
658  * @tc.type: FUNC
659  */
660 HWTEST_F(WindowSceneSessionImplTest4, ResizeAsync02, Function | SmallTest | Level2)
661 {
662     sptr<WindowOption> option = new (std::nothrow) WindowOption();
663     ASSERT_NE(nullptr, option);
664     option->SetWindowName("ResizeAsync02");
665     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
666     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
667     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
668     ASSERT_NE(nullptr, window);
669     window->property_->SetPersistentId(991);
670     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
671     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
672     ASSERT_NE(nullptr, session);
673     window->hostSession_ = session;
674 
675     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
676     ASSERT_NE(nullptr, subOption);
677     subOption->SetWindowName("subResizeAsync02");
678     subOption->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
679     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
680     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
681     ASSERT_NE(nullptr, subWindow);
682     subWindow->property_->SetPersistentId(992);
683     SessionInfo subSessionInfo = { "subCreateTestBundle", "subCreateTestModule", "subCreateTestAbility" };
684     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
685     ASSERT_NE(nullptr, subSession);
686     subWindow->hostSession_ = subSession;
687     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
688 
689     ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
690     ASSERT_EQ(WMError::WM_OK, subWindow->Create(abilityContext_, subSession));
691     subWindow->windowSessionMap_.insert(std::make_pair("ResizeAsync02", std::make_pair(998, window)));
692     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
693     window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
694     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
695     window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
696     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
697     Rect request = { 100, 100, 600, 600 };
698     subWindow->property_->SetRequestRect(request);
699     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
700     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
701     subWindow->state_ = WindowState::STATE_HIDDEN;
702     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
703     subWindow->state_ = WindowState::STATE_SHOWN;
704     ASSERT_EQ(WMError::WM_OK, subWindow->ResizeAsync(500, 500));
705     ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
706     ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
707 }
708 
709 /**
710  * @tc.name: NotifyDialogStateChange
711  * @tc.desc: NotifyDialogStateChange
712  * @tc.type: FUNC
713  */
714 HWTEST_F(WindowSceneSessionImplTest4, NotifyDialogStateChange, Function | SmallTest | Level2)
715 {
716     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
717     ASSERT_NE(nullptr, option);
718     option->SetWindowName("NotifyDialogStateChange");
719     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
720     ASSERT_NE(nullptr, windowSceneSessionImpl);
721 
722     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
723     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
724     ASSERT_NE(nullptr, session);
725     ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
726     windowSceneSessionImpl->property_->SetPersistentId(1);
727     windowSceneSessionImpl->hostSession_ = session;
728     windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
729     auto ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
730     EXPECT_EQ(WSError::WS_OK, ret);
731     ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
732     EXPECT_EQ(WSError::WS_OK, ret);
733     ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
734     EXPECT_EQ(WSError::WS_OK, ret);
735     ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
736     EXPECT_EQ(WSError::WS_OK, ret);
737     windowSceneSessionImpl->property_->SetPersistentId(0);
738     windowSceneSessionImpl->hostSession_ = nullptr;
739     windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
740     ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
741     EXPECT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ret);
742 }
743 
744 /**
745  * @tc.name: MoveTo02
746  * @tc.desc: MoveTo
747  * @tc.type: FUNC
748  */
749 HWTEST_F(WindowSceneSessionImplTest4, MoveTo02, Function | SmallTest | Level2)
750 {
751     sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
752     ASSERT_NE(nullptr, subOption);
753     subOption->SetWindowName("MoveTo02SubWindow");
754     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
755     sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
756     ASSERT_NE(nullptr, subWindow);
757     ASSERT_NE(nullptr, subWindow->property_);
758     subWindow->property_->SetPersistentId(1001);
759     SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
760     sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
761     ASSERT_NE(nullptr, subSession);
762     subWindow->hostSession_ = subSession;
763     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(2, 2));
764 
765     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
766     ASSERT_NE(nullptr, option);
767     option->SetWindowName("MoveTo02");
768     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
769     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
770     ASSERT_NE(nullptr, window);
771     ASSERT_NE(nullptr, window->property_);
772     window->property_->SetPersistentId(1);
773     SessionInfo sessionInfo = {"CreateTestBundle2", "CreateTestModule2", "CreateTestAbility2"};
774     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
775     ASSERT_NE(nullptr, session);
776     window->hostSession_ = session;
777     window->state_ = WindowState::STATE_SHOWN;
778     ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
779     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
780     ASSERT_NE(nullptr, window->property_);
781     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
782     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
783     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 4));
784     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
785     ASSERT_NE(nullptr, window->property_);
786     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
787     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
788     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 5));
789     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 5));
790     ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
791 }
792 
793 /**
794  * @tc.name: GetWindowStatus01
795  * @tc.desc: GetWindowStatus
796  * @tc.type: FUNC
797  */
798 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus01, Function | SmallTest | Level2)
799 {
800     sptr<WindowOption> option = new (std::nothrow) WindowOption();
801     ASSERT_NE(nullptr, option);
802     option->SetWindowName("GetWindowStatus01");
803     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
804     ASSERT_NE(nullptr, window);
805     window->property_->SetPersistentId(1);
806     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
807     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
808     ASSERT_NE(nullptr, session);
809     window->hostSession_ = session;
810 
811     WindowStatus windowStatus;
812     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
813     ASSERT_EQ(WindowStatus::WINDOW_STATUS_UNDEFINED, windowStatus);
814 }
815 
816 /**
817  * @tc.name: GetWindowStatus02
818  * @tc.desc: GetWindowStatus
819  * @tc.type: FUNC
820  */
821 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus02, Function | SmallTest | Level2)
822 {
823     sptr<WindowOption> option = new (std::nothrow) WindowOption();
824     ASSERT_NE(nullptr, option);
825     option->SetWindowName("GetWindowStatus02");
826     option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
827     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
828     ASSERT_NE(nullptr, window);
829     window->property_->SetPersistentId(1);
830     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
831     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
832     ASSERT_NE(nullptr, session);
833     window->hostSession_ = session;
834 
835     WindowStatus windowStatus;
836     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
837     ASSERT_EQ(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus);
838 }
839 
840 /**
841  * @tc.name: GetWindowStatus03
842  * @tc.desc: GetWindowStatus
843  * @tc.type: FUNC
844  */
845 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus03, Function | SmallTest | Level2)
846 {
847     sptr<WindowOption> option = new (std::nothrow) WindowOption();
848     ASSERT_NE(nullptr, option);
849     option->SetWindowName("GetWindowStatus03");
850     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
851     option->SetDisplayId(0);
852     option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
853     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
854     ASSERT_NE(nullptr, window);
855     window->property_->SetPersistentId(1);
856     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
857     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
858     ASSERT_NE(nullptr, session);
859     window->hostSession_ = session;
860 
861     WindowStatus windowStatus;
862     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
863     ASSERT_EQ(WindowStatus::WINDOW_STATUS_FLOATING, windowStatus);
864     window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
865     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
866     ASSERT_EQ(WindowStatus::WINDOW_STATUS_MAXIMIZE, windowStatus);
867     window->state_ = WindowState::STATE_HIDDEN;
868     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
869     ASSERT_EQ(WindowStatus::WINDOW_STATUS_MINIMIZE, windowStatus);
870     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
871     window->state_ = WindowState::STATE_SHOWN;
872     ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
873     ASSERT_EQ(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus);
874 }
875 
876 /**
877  * @tc.name: PreLayoutOnShow01
878  * @tc.desc: PreLayoutOnShow
879  * @tc.type: FUNC
880  */
881 HWTEST_F(WindowSceneSessionImplTest4, PreLayoutOnShow01, Function | SmallTest | Level2)
882 {
883     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
884     option->SetWindowName("PreLayoutOnShow01");
885     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
886     window->property_->SetPersistentId(2345);
887     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
888     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
889     window->hostSession_ = nullptr;
890     sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
891     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
892     ASSERT_NE(nullptr, window->uiContent_);
893     window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
894     window->hostSession_ = session;
895     window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
896 }
897 
898 /**
899  * @tc.name: VerifySubWindowLevel
900  * @tc.desc: VerifySubWindowLevel Test
901  * @tc.type: FUNC
902  */
903 HWTEST_F(WindowSceneSessionImplTest4, VerifySubWindowLevel, Function | SmallTest | Level2)
904 {
905     sptr<WindowOption> option = new (std::nothrow) WindowOption();
906     EXPECT_NE(nullptr, option);
907     option->SetWindowName("VerifySubWindowLevel");
908     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
909     option->SetDisplayId(0);
910     option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
911     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
912     EXPECT_NE(nullptr, window);
913     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
914     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
915     EXPECT_NE(nullptr, session);
916     window->hostSession_ = session;
917     ASSERT_EQ(false, window->VerifySubWindowLevel(window->GetParentId()));
918 }
919 
920 /**
921  * @tc.name: AddSubWindowMapForExtensionWindow
922  * @tc.desc: AddSubWindowMapForExtensionWindow Test
923  * @tc.type: FUNC
924  */
925 HWTEST_F(WindowSceneSessionImplTest4, AddSubWindowMapForExtensionWindow, Function | SmallTest | Level2)
926 {
927     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
928     ASSERT_NE(nullptr, option);
929     option->SetWindowName("AddSubWindowMapForExtensionWindow");
930     option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
931     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
932     ASSERT_NE(nullptr, window);
933     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
934     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
935     ASSERT_NE(nullptr, session);
936     window->hostSession_ = session;
937     ASSERT_NE(nullptr, window->property_);
938     window->property_->SetPersistentId(1);
939     window->windowSystemConfig_.uiType_ = "pc";
940     window->AddSubWindowMapForExtensionWindow();
941     EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
942 }
943 
944 /**
945  * @tc.name: GetParentSessionAndVerify
946  * @tc.desc: GetParentSessionAndVerify Test
947  * @tc.type: FUNC
948  */
949 HWTEST_F(WindowSceneSessionImplTest4, GetParentSessionAndVerify, Function | SmallTest | Level2)
950 {
951     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
952     ASSERT_NE(nullptr, option);
953     option->SetWindowName("GetParentSessionAndVerify");
954     option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
955     sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
956     ASSERT_NE(nullptr, window);
957     SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
958     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
959     ASSERT_NE(nullptr, session);
960     window->hostSession_ = session;
961     ASSERT_NE(nullptr, window->property_);
962     window->property_->SetPersistentId(1);
963     window->windowSystemConfig_.uiType_ = "pc";
964     sptr<WindowSessionImpl> parentSession = nullptr;
965     auto res = window->GetParentSessionAndVerify(false, parentSession);
966     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
967     res = window->GetParentSessionAndVerify(true, parentSession);
968     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
969 
970     sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
971     ASSERT_NE(nullptr, subOption);
972     subOption->SetWindowName("GetParentSessionAndVerify2");
973     subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
974     sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
975     ASSERT_NE(nullptr, subWindow);
976     SessionInfo subSessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
977     sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
978     ASSERT_NE(nullptr, subSession);
979     subWindow->hostSession_ = subSession;
980     ASSERT_NE(nullptr, subWindow->property_);
981     subWindow->property_->SetPersistentId(2);
982     subWindow->property_->SetParentId(1);
983     window->windowSystemConfig_.uiType_ = "pc";
984     std::vector<sptr<WindowSessionImpl>> vec;
985     WindowSceneSessionImpl::subWindowSessionMap_.insert(std::pair<int32_t,
986         std::vector<sptr<WindowSessionImpl>>>(1, vec));
987     WindowSceneSessionImpl::subWindowSessionMap_[1].push_back(subWindow);
988     res = subWindow->GetParentSessionAndVerify(false, parentSession);
989     EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
990     WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
991         std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
992     res = subWindow->GetParentSessionAndVerify(false, parentSession);
993     EXPECT_EQ(WMError::WM_OK, res);
994     EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
995     EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
996 }
997 
998 /**
999  * @tc.name: MoveTo03
1000  * @tc.desc: MoveTo
1001  * @tc.type: FUNC
1002  */
1003 HWTEST_F(WindowSceneSessionImplTest4, MoveTo03, Function | SmallTest | Level2)
1004 {
1005     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1006     ASSERT_NE(nullptr, subOption);
1007     subOption->SetWindowName("MoveTo01SubWindow");
1008     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1009     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1010     ASSERT_NE(nullptr, subWindow);
1011     ASSERT_NE(nullptr, subWindow->property_);
1012     subWindow->property_->SetPersistentId(1001);
1013     SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1014     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
1015     ASSERT_NE(nullptr, subSession);
1016     subWindow->hostSession_ = subSession;
1017     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(2, 2));
1018 
1019     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1020     ASSERT_NE(nullptr, option);
1021     option->SetWindowName("MoveTo02");
1022     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1023     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1024     ASSERT_NE(nullptr, window);
1025     ASSERT_NE(nullptr, window->property_);
1026     window->property_->SetPersistentId(1);
1027     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1028     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1029     ASSERT_NE(nullptr, session);
1030     window->hostSession_ = session;
1031     WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
1032         std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1033     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(3, 3));
1034     ASSERT_NE(nullptr, window->property_);
1035     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1036     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 3));
1037     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(4, 4));
1038     ASSERT_NE(nullptr, window->property_);
1039     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1040     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 4));
1041     ASSERT_EQ(WMError::WM_OK, subWindow->MoveTo(5, 4));
1042     WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1043 }
1044 
1045 /**
1046  * @tc.name: SetWindowMode01
1047  * @tc.desc: SetWindowMode
1048  * @tc.type: FUNC
1049  */
1050 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode01, Function | SmallTest | Level2)
1051 {
1052     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1053     ASSERT_NE(nullptr, subOption);
1054     subOption->SetWindowName("SetWindowMode01");
1055     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1056     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1057     ASSERT_NE(nullptr, subWindow);
1058     ASSERT_NE(nullptr, subWindow->property_);
1059     subWindow->property_->SetPersistentId(1007);
1060     SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1061     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
1062     ASSERT_NE(nullptr, subSession);
1063     subWindow->hostSession_ = subSession;
1064     subWindow->property_->SetWindowModeSupportType(0);
1065     auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1066     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, ret);
1067 }
1068 
1069 /**
1070  * @tc.name: UpdateNewSize01
1071  * @tc.desc: UpdateNewSize
1072  * @tc.type: FUNC
1073  */
1074 HWTEST_F(WindowSceneSessionImplTest4, UpdateNewSize01, Function | SmallTest | Level2)
1075 {
1076     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1077     ASSERT_NE(nullptr, subOption);
1078     subOption->SetWindowName("UpdateNewSize01SubWindow");
1079     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1080     ASSERT_NE(nullptr, subWindow);
1081     ASSERT_NE(nullptr, subWindow->property_);
1082     subWindow->property_->SetPersistentId(1003);
1083     SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1084     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
1085     ASSERT_NE(nullptr, subSession);
1086     subWindow->hostSession_ = subSession;
1087     subWindow->UpdateNewSize();
1088     Rect windowRect = { 0, 0, 0, 0 };
1089     WindowLimits windowLimits = { 0, 0, 0, 0, 0.0, 0, 0 };
1090     subWindow->property_->SetRequestRect(windowRect);
1091     subWindow->property_->SetWindowRect(windowRect);
1092     subWindow->property_->SetWindowLimits(windowLimits);
1093     subWindow->UpdateNewSize();
1094     windowRect.width_ = 10;
1095     windowRect.height_ = 10;
1096     subWindow->UpdateNewSize();
1097     windowRect.width_ = 0;
1098     windowRect.height_ = 0;
1099     ASSERT_NE(nullptr, subWindow->property_);
1100     subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1101     subWindow->UpdateNewSize();
1102     Rect windowRect1 = { 10, 10, 10, 10 };
1103     WindowLimits windowLimits1 = { 100, 100, 100, 100, 0.0, 0, 0 };
1104     subWindow->property_->SetRequestRect(windowRect1);
1105     subWindow->property_->SetWindowLimits(windowLimits1);
1106     subWindow->UpdateNewSize();
1107     Rect windowRect2 = { 200, 200, 200, 200 };
1108     subWindow->property_->SetRequestRect(windowRect2);
1109     subWindow->UpdateNewSize();
1110 }
1111 
1112 /**
1113  * @tc.name: UpdateSubWindowStateAndNotify01
1114  * @tc.desc: UpdateSubWindowStateAndNotify
1115  * @tc.type: FUNC
1116  */
1117 HWTEST_F(WindowSceneSessionImplTest4, UpdateSubWindowStateAndNotify01, Function | SmallTest | Level2)
1118 {
1119     sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1120     ASSERT_NE(nullptr, subOption);
1121     subOption->SetWindowName("UpdateSubWindowStateAndNotify01");
1122     subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1123     sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1124     ASSERT_NE(nullptr, subWindow);
1125     ASSERT_NE(nullptr, subWindow->property_);
1126     subWindow->property_->SetPersistentId(1005);
1127     SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1128     sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
1129     ASSERT_NE(nullptr, subSession);
1130     subWindow->hostSession_ = subSession;
1131 
1132     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1133     option->SetWindowName("UpdateSubWindowStateAndNotify02");
1134     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1135     sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1136     ASSERT_NE(nullptr, window);
1137     ASSERT_NE(nullptr, window->property_);
1138     window->property_->SetPersistentId(1006);
1139     SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1140     sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1141     ASSERT_NE(nullptr, session);
1142     window->hostSession_ = session;
1143     std::vector<sptr<WindowSessionImpl>> vec;
1144     WindowSceneSessionImpl::subWindowSessionMap_.insert(std::pair<int32_t,
1145             std::vector<sptr<WindowSessionImpl>>>(1006, vec));
1146     subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1147     WindowSceneSessionImpl::subWindowSessionMap_[1006].push_back(subWindow);
1148     subWindow->state_ = WindowState::STATE_SHOWN;
1149     subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1150     subWindow->state_ = WindowState::STATE_HIDDEN;
1151     subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1152     subWindow->state_ = WindowState::STATE_SHOWN;
1153     subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1154     subWindow->state_ = WindowState::STATE_SHOWN;
1155     subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1156     ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1157     ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1158 }
1159 
1160 /**
1161  * @tc.name: UpdateConfigurationSyncForAll
1162  * @tc.desc: UpdateConfigurationSyncForAll
1163  * @tc.type: FUNC
1164  */
1165 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationSyncForAll, Function | SmallTest | Level2)
1166 {
1167     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1168     ASSERT_NE(nullptr, option);
1169     option->SetWindowName("UpdateConfigurationSyncForAll");
1170     sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1171     ASSERT_NE(nullptr, windowSceneSessionImpl);
1172 
1173     std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
1174     ASSERT_NE(nullptr, configuration);
1175     sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1176     ASSERT_NE(nullptr, windowSession);
1177     SessionInfo sessionInfo = {"CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1"};
1178     sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1179     ASSERT_NE(nullptr, session);
1180     windowSession->hostSession_ = session;
1181     windowSession->property_->SetPersistentId(1);
1182     windowSession->state_ = WindowState::STATE_SHOWN;
1183     ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
1184     windowSceneSessionImpl->UpdateConfigurationSyncForAll(configuration);
1185     ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
1186 }
1187 }
1188 } // namespace Rosen
1189 } // namespace OHOS