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 const std::string WATERFALL_WINDOW_EVENT = "scb_waterfall_window_event";
33 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
34 class WindowSceneSessionImplTest4 : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40
41 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
42 std::unique_ptr<Mocker> mocker_ = std::make_unique<Mocker>();
43
44 private:
45 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
46 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
47 static constexpr uint32_t WAIT_SERVERAL_FRAMES = 36000;
48 };
49
SetUpTestCase()50 void WindowSceneSessionImplTest4::SetUpTestCase() {}
51
TearDownTestCase()52 void WindowSceneSessionImplTest4::TearDownTestCase() {}
53
SetUp()54 void WindowSceneSessionImplTest4::SetUp()
55 {
56 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
57 }
58
TearDown()59 void WindowSceneSessionImplTest4::TearDown()
60 {
61 usleep(WAIT_SYNC_IN_NS);
62 abilityContext_ = nullptr;
63 }
64
CreateRSSurfaceNode()65 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest4::CreateRSSurfaceNode()
66 {
67 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
68 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
69 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
70 return surfaceNode;
71 }
72
73 namespace {
74 /**
75 * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
76 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation
77 * @tc.type: FUNC
78 */
79 HWTEST_F(WindowSceneSessionImplTest4, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level2)
80 {
81 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
82 option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
83 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
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 windowSceneSessionImpl->property_->SetPersistentId(1);
92 windowSceneSessionImpl->hostSession_ = session;
93 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
94 windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_END);
95 ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
96 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
97 windowSceneSessionImpl->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
98 ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
99 EXPECT_EQ(WMError::WM_OK, ret);
100 }
101
102 /**
103 * @tc.name: RegisterSessionRecoverListener
104 * @tc.desc: RegisterSessionRecoverListener
105 * @tc.type: FUNC
106 */
107 HWTEST_F(WindowSceneSessionImplTest4, RegisterSessionRecoverListener, Function | SmallTest | Level2)
108 {
109 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
110 option->SetWindowName("RegisterSessionRecoverListener");
111 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
112 int32_t persistentId = windowSceneSessionImpl->property_->GetPersistentId();
113 WindowAdapter& windowAdapter = SingletonContainer::Get<WindowAdapter>();
114 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
115 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
116 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
117
118 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
119 windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::RESERVE_TYPE);
120 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
121 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
122
123 windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
124 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
125 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
126 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
127 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
128
129 windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
130 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
131 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
132 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
133 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
134
135 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
136 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
137 EXPECT_EQ(CollaboratorType::DEFAULT_TYPE, windowSceneSessionImpl->property_->GetCollaboratorType());
138 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
139 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
140 EXPECT_EQ(CollaboratorType::DEFAULT_TYPE, windowSceneSessionImpl->property_->GetCollaboratorType());
141 }
142
143 /**
144 * @tc.name: ConsumePointerEvent
145 * @tc.desc: ConsumePointerEvent
146 * @tc.type: FUNC
147 */
148 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEvent, Function | SmallTest | Level2)
149 {
150 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
151 option->SetWindowName("ConsumePointerEvent");
152 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
153
154 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
155 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
156 windowSceneSessionImpl->hostSession_ = session;
157 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
158 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
159 windowSceneSessionImpl->hostSession_ = nullptr;
160 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
161 pointerEvent = nullptr;
162 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
163 windowSceneSessionImpl->property_->SetTurnScreenOn(true);
164 auto ret = windowSceneSessionImpl->IsTurnScreenOn();
165 EXPECT_EQ(true, ret);
166 windowSceneSessionImpl->property_->SetTurnScreenOn(false);
167 ret = windowSceneSessionImpl->IsTurnScreenOn();
168 EXPECT_EQ(false, ret);
169 }
170
171 /**
172 * @tc.name: GetSystemSizeLimits01
173 * @tc.desc: GetSystemSizeLimits
174 * @tc.type: FUNC
175 */
176 HWTEST_F(WindowSceneSessionImplTest4, GetSystemSizeLimits01, Function | SmallTest | Level2)
177 {
178 uint32_t minMainWidth = 10;
179 uint32_t minMainHeight = 20;
180 uint32_t minSubWidth = 30;
181 uint32_t minSubHeight = 40;
182 uint32_t minDialogWidth = 37;
183 uint32_t minDialogHeight = 43;
184 uint32_t displayWidth = 100;
185 uint32_t displayHeight = 100;
186 float displayVpr = 1.0f;
187 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
188 option->SetWindowName("GetSystemSizeLimits01");
189 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
190 windowSceneSessionImpl->windowSystemConfig_.miniWidthOfMainWindow_ = minMainWidth;
191 windowSceneSessionImpl->windowSystemConfig_.miniHeightOfMainWindow_ = minMainHeight;
192 windowSceneSessionImpl->windowSystemConfig_.miniWidthOfSubWindow_ = minSubWidth;
193 windowSceneSessionImpl->windowSystemConfig_.miniHeightOfSubWindow_ = minSubHeight;
194 windowSceneSessionImpl->windowSystemConfig_.miniWidthOfDialogWindow_ = minDialogWidth;
195 windowSceneSessionImpl->windowSystemConfig_.miniHeightOfDialogWindow_ = minDialogHeight;
196
197 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
198 WindowLimits limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
199 EXPECT_EQ(limits.minWidth_, minMainWidth);
200 EXPECT_EQ(limits.minHeight_, minMainHeight);
201
202 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
203 limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
204 EXPECT_EQ(limits.minWidth_, minSubWidth);
205 EXPECT_EQ(limits.minHeight_, minSubHeight);
206
207 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
208 limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
209 EXPECT_EQ(limits.minWidth_, minDialogWidth);
210 EXPECT_EQ(limits.minHeight_, minDialogHeight);
211 }
212
213 /**
214 * @tc.name: HandlePointDownEvent
215 * @tc.desc: HandlePointDownEvent
216 * @tc.type: FUNC
217 */
218 HWTEST_F(WindowSceneSessionImplTest4, HandlePointDownEvent, Function | SmallTest | Level2)
219 {
220 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
221 option->SetWindowName("HandlePointDownEvent");
222 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
223
224 std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
225 MMI::PointerEvent::PointerItem pointerItem;
226 int32_t sourceType = 1;
227 float vpr = 1.0f;
228 WSRect rect = { 1, 1, 1, 1 };
229
230 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
231 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
232 windowSceneSessionImpl->hostSession_ = session;
233 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
234
235 windowSceneSessionImpl->property_->SetDragEnabled(false);
236 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
237 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
238 auto ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
239 EXPECT_EQ(true, ret);
240
241 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
242 windowSceneSessionImpl->property_->SetDragEnabled(false);
243 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
244 EXPECT_EQ(true, ret);
245 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
246
247 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
248 EXPECT_EQ(true, ret);
249
250 pointerItem.SetWindowX(100);
251 pointerItem.SetWindowY(100);
252 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
253 EXPECT_EQ(true, ret);
254 pointerItem.SetWindowX(1);
255 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
256 EXPECT_EQ(true, ret);
257
258 windowSceneSessionImpl->property_->SetDragEnabled(true);
259 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
260 EXPECT_EQ(false, ret);
261
262 pointerItem.SetWindowX(100);
263 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem, sourceType, vpr, rect);
264 EXPECT_EQ(true, ret);
265 }
266
267 /**
268 * @tc.name: UpdateWindowModeImmediately
269 * @tc.desc: UpdateWindowModeImmediately
270 * @tc.type: FUNC
271 */
272 HWTEST_F(WindowSceneSessionImplTest4, UpdateWindowModeImmediately, Function | SmallTest | Level2)
273 {
274 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
275 option->SetWindowName("UpdateWindowModeImmediately");
276 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
277
278 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
279 auto ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
280 EXPECT_EQ(WMError::WM_OK, ret);
281 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, windowSceneSessionImpl->property_->GetWindowMode());
282
283 windowSceneSessionImpl->state_ = WindowState::STATE_HIDDEN;
284 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
285 EXPECT_EQ(WMError::WM_OK, ret);
286 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, windowSceneSessionImpl->property_->GetWindowMode());
287
288 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
289 windowSceneSessionImpl->hostSession_ = nullptr;
290 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
291 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
292 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
293 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
294 windowSceneSessionImpl->property_->SetPersistentId(1);
295 windowSceneSessionImpl->hostSession_ = session;
296 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
297 EXPECT_EQ(WMError::WM_OK, ret);
298 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowSceneSessionImpl->property_->GetWindowMode());
299
300 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
301 EXPECT_EQ(WMError::WM_OK, ret);
302 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowSceneSessionImpl->property_->GetWindowMode());
303
304 windowSceneSessionImpl->state_ = WindowState::STATE_UNFROZEN;
305 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
306 EXPECT_EQ(WMError::WM_OK, ret);
307 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowSceneSessionImpl->property_->GetWindowMode());
308 }
309
310 /**
311 * @tc.name: AdjustWindowAnimationFlag
312 * @tc.desc: AdjustWindowAnimationFlag
313 * @tc.type: FUNC
314 */
315 HWTEST_F(WindowSceneSessionImplTest4, AdjustWindowAnimationFlag, Function | SmallTest | Level2)
316 {
317 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
318 option->SetWindowName("AdjustWindowAnimationFlag");
319 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
320 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
321 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
322 windowSceneSessionImpl->property_->SetPersistentId(1);
323 windowSceneSessionImpl->hostSession_ = session;
324 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
325
326 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
327 windowSceneSessionImpl->animationTransitionController_ = sptr<IAnimationTransitionController>::MakeSptr();
328 windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
329 auto ret = windowSceneSessionImpl->property_->GetAnimationFlag();
330 EXPECT_EQ(3, ret);
331 windowSceneSessionImpl->animationTransitionController_ = nullptr;
332 windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
333 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
334 EXPECT_EQ(1, ret);
335 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
336 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
337 EXPECT_EQ(0, ret);
338 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
339 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
340 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
341 EXPECT_EQ(1, ret);
342 windowSceneSessionImpl->enableDefaultAnimation_ = false;
343 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
344 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
345 EXPECT_EQ(0, ret);
346 }
347
348 /**
349 * @tc.name: UpdateConfigurationForAll
350 * @tc.desc: UpdateConfigurationForAll
351 * @tc.type: FUNC
352 */
353 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationForAll, Function | SmallTest | Level2)
354 {
355 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
356 option->SetWindowName("UpdateConfigurationForAll");
357 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
358
359 std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
360 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
361 SessionInfo sessionInfo = { "CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1" };
362 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
363 windowSession->hostSession_ = session;
364 windowSession->property_->SetPersistentId(1);
365 windowSession->state_ = WindowState::STATE_SHOWN;
366 ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
367 windowSceneSessionImpl->UpdateConfigurationForAll(configuration);
368 ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
369 }
370
371 /**
372 * @tc.name: SetWindowFlags
373 * @tc.desc: SetWindowFlags
374 * @tc.type: FUNC
375 */
376 HWTEST_F(WindowSceneSessionImplTest4, SetWindowFlags, Function | SmallTest | Level2)
377 {
378 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
379 option->SetWindowName("SetWindowFlags");
380 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
381
382 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
383 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
384 windowSceneSessionImpl->property_->SetPersistentId(1);
385 windowSceneSessionImpl->hostSession_ = session;
386 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
387 windowSceneSessionImpl->SetWindowFlags(1);
388 auto ret = windowSceneSessionImpl->SetWindowFlags(1);
389 EXPECT_EQ(WMError::WM_OK, ret);
390 ret = windowSceneSessionImpl->SetWindowFlags(2);
391 EXPECT_EQ(WMError::WM_OK, ret);
392 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
393 ret = windowSceneSessionImpl->NotifyPrepareClosePiPWindow();
394 EXPECT_EQ(WMError::WM_OK, ret);
395 }
396
397 /**
398 * @tc.name: ResetSuperFoldDisplayY
399 * @tc.desc: ResetSuperFoldDisplayY
400 * @tc.type: FUNC
401 */
402 HWTEST_F(WindowSceneSessionImplTest4, ResetSuperFoldDisplayY, Function | SmallTest | Level2)
403 {
404 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
405 option->SetWindowName("ResetSuperFoldDisplayY");
406 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
407
408 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
409 windowSceneSessionImpl->superFoldOffsetY_ = 150;
410 MMI::PointerEvent::PointerItem pointerItem;
411 pointerItem.SetDisplayY(100);
412 pointerEvent->AddPointerItem(pointerItem);
413 int32_t originalDisplayY = pointerItem.GetDisplayY();
414 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
415 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
416 int32_t updatedDisplayY = pointerItem.GetDisplayY();
417 ASSERT_EQ(updatedDisplayY, originalDisplayY);
418
419 pointerItem.SetDisplayY(150);
420 pointerEvent->AddPointerItem(pointerItem);
421 originalDisplayY = pointerItem.GetDisplayY();
422 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
423 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
424 updatedDisplayY = pointerItem.GetDisplayY();
425 ASSERT_EQ(updatedDisplayY, originalDisplayY - 150);
426 }
427
428 /**
429 * @tc.name: ConsumePointerEventInner
430 * @tc.desc: ConsumePointerEventInner
431 * @tc.type: FUNC
432 */
433 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEventInner, Function | SmallTest | Level2)
434 {
435 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
436 option->SetWindowName("ConsumePointerEventInner");
437 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
438
439 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
440 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
441 windowSceneSessionImpl->property_->SetPersistentId(1);
442 windowSceneSessionImpl->hostSession_ = session;
443 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
444 ASSERT_NE(nullptr, pointerEvent);
445 MMI::PointerEvent::PointerItem pointerItem;
446 pointerEvent->SetPointerAction(10);
447 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
448 pointerEvent->SetPointerAction(4);
449 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
450 pointerEvent->SetPointerAction(2);
451 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
452 }
453
454 /**
455 * @tc.name: HandleEventForCompatibleMode
456 * @tc.desc: HandleEventForCompatibleMode
457 * @tc.type: FUNC
458 */
459 HWTEST_F(WindowSceneSessionImplTest4, HandleEventForCompatibleMode, Function | SmallTest | Level2)
460 {
461 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
462 option->SetWindowName("HandleEventForCompatibleMode");
463 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
464
465 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
466 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
467 windowSceneSessionImpl->property_->SetPersistentId(1);
468 windowSceneSessionImpl->hostSession_ = session;
469 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
470 ASSERT_NE(nullptr, pointerEvent);
471 MMI::PointerEvent::PointerItem pointerItem;
472 pointerEvent->SetPointerAction(2);
473 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
474 pointerEvent->SetPointerAction(3);
475 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
476 pointerEvent->SetPointerAction(4);
477 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
478 }
479
480 /**
481 * @tc.name: HandleDownForCompatibleMode
482 * @tc.desc: HandleDownForCompatibleMode
483 * @tc.type: FUNC
484 */
485 HWTEST_F(WindowSceneSessionImplTest4, HandleDownForCompatibleMode, Function | SmallTest | Level2)
486 {
487 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
488 option->SetWindowName("HandleDownForCompatibleMode");
489 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
490
491 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
492 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
493 windowSceneSessionImpl->property_->SetPersistentId(1);
494 windowSceneSessionImpl->hostSession_ = session;
495 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
496 ASSERT_NE(nullptr, pointerEvent);
497 MMI::PointerEvent::PointerItem pointerItem;
498 pointerEvent->SetPointerAction(2);
499 windowSceneSessionImpl->HandleDownForCompatibleMode(pointerEvent, pointerItem);
500 }
501
502 /**
503 * @tc.name: HandleMoveForCompatibleMode
504 * @tc.desc: HandleMoveForCompatibleMode
505 * @tc.type: FUNC
506 */
507 HWTEST_F(WindowSceneSessionImplTest4, HandleMoveForCompatibleMode, Function | SmallTest | Level2)
508 {
509 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
510 option->SetWindowName("HandleMoveForCompatibleMode");
511 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
512
513 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
514 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
515 windowSceneSessionImpl->property_->SetPersistentId(1);
516 windowSceneSessionImpl->hostSession_ = session;
517 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
518 ASSERT_NE(nullptr, pointerEvent);
519 MMI::PointerEvent::PointerItem pointerItem;
520 pointerEvent->SetPointerAction(3);
521 windowSceneSessionImpl->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
522 }
523
524 /**
525 * @tc.name: HandleUpForCompatibleMode
526 * @tc.desc: HandleUpForCompatibleMode
527 * @tc.type: FUNC
528 */
529 HWTEST_F(WindowSceneSessionImplTest4, HandleUpForCompatibleMode, Function | SmallTest | Level2)
530 {
531 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
532 option->SetWindowName("HandleUpForCompatibleMode");
533 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
534
535 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
536 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
537 windowSceneSessionImpl->property_->SetPersistentId(1);
538 windowSceneSessionImpl->hostSession_ = session;
539 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
540 ASSERT_NE(nullptr, pointerEvent);
541 MMI::PointerEvent::PointerItem pointerItem;
542 pointerEvent->SetPointerAction(4);
543 windowSceneSessionImpl->HandleUpForCompatibleMode(pointerEvent, pointerItem);
544 }
545
546 /**
547 * @tc.name: ConvertPointForCompatibleMode
548 * @tc.desc: ConvertPointForCompatibleMode
549 * @tc.type: FUNC
550 */
551 HWTEST_F(WindowSceneSessionImplTest4, ConvertPointForCompatibleMode, Function | SmallTest | Level2)
552 {
553 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
554 option->SetWindowName("ConvertPointForCompatibleMode");
555 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
556
557 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
558 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
559 windowSceneSessionImpl->property_->SetPersistentId(1);
560 windowSceneSessionImpl->hostSession_ = session;
561 int32_t transferX = 800;
562 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
563 ASSERT_NE(nullptr, pointerEvent);
564 MMI::PointerEvent::PointerItem pointerItem;
565 pointerEvent->SetPointerAction(2);
566 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
567 pointerEvent->SetPointerAction(3);
568 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
569 pointerEvent->SetPointerAction(4);
570 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
571 }
572
573 /**
574 * @tc.name: IsInMappingRegionForCompatibleMode
575 * @tc.desc: IsInMappingRegionForCompatibleMode
576 * @tc.type: FUNC
577 */
578 HWTEST_F(WindowSceneSessionImplTest4, IsInMappingRegionForCompatibleMode, Function | SmallTest | Level2)
579 {
580 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
581 option->SetWindowName("IsInMappingRegionForCompatibleMode");
582 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
583
584 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
585 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
586 windowSceneSessionImpl->property_->SetPersistentId(1);
587 windowSceneSessionImpl->hostSession_ = session;
588 windowSceneSessionImpl->property_->SetWindowRect({ 880, 0, 800, 1600 });
589 int32_t displayX = 400;
590 int32_t displayY = 400;
591 bool ret = windowSceneSessionImpl->IsInMappingRegionForCompatibleMode(displayX, displayY);
592 EXPECT_EQ(true, ret);
593 displayX = 1000;
594 displayY = 1000;
595 ret = windowSceneSessionImpl->IsInMappingRegionForCompatibleMode(displayX, displayY);
596 EXPECT_EQ(false, ret);
597 }
598
599 /**
600 * @tc.name: CheckTouchSlop
601 * @tc.desc: CheckTouchSlop
602 * @tc.type: FUNC
603 */
604 HWTEST_F(WindowSceneSessionImplTest4, CheckTouchSlop, Function | SmallTest | Level2)
605 {
606 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
607 option->SetWindowName("CheckTouchSlop");
608 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
609
610 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
611 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
612 windowSceneSessionImpl->property_->SetPersistentId(1);
613 windowSceneSessionImpl->hostSession_ = session;
614 int32_t pointerId = 0;
615 int32_t displayX = 400;
616 int32_t displayY = 400;
617 int32_t threshold = 50;
618 bool ret = windowSceneSessionImpl->CheckTouchSlop(pointerId, displayX, displayY, threshold);
619 EXPECT_EQ(false, ret);
620 }
621
622 /**
623 * @tc.name: IgnoreClickEvent
624 * @tc.desc: IgnoreClickEvent
625 * @tc.type: FUNC
626 */
627 HWTEST_F(WindowSceneSessionImplTest4, IgnoreClickEvent, Function | SmallTest | Level2)
628 {
629 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
630 option->SetWindowName("IgnoreClickEvent");
631 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
632
633 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
634 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
635 windowSceneSessionImpl->property_->SetPersistentId(1);
636 windowSceneSessionImpl->hostSession_ = session;
637 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
638 ASSERT_NE(nullptr, pointerEvent);
639 pointerEvent->SetPointerAction(3);
640 windowSceneSessionImpl->IgnoreClickEvent(pointerEvent);
641 pointerEvent->SetPointerAction(4);
642 windowSceneSessionImpl->IgnoreClickEvent(pointerEvent);
643 }
644
645 /**
646 * @tc.name: RegisterKeyboardPanelInfoChangeListener
647 * @tc.desc: RegisterKeyboardPanelInfoChangeListener
648 * @tc.type: FUNC
649 */
650 HWTEST_F(WindowSceneSessionImplTest4, RegisterKeyboardPanelInfoChangeListener, Function | SmallTest | Level2)
651 {
652 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
653 option->SetWindowName("RegisterKeyboardPanelInfoChangeListener");
654 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
655 windowSceneSessionImpl->keyboardPanelInfoChangeListeners_ = sptr<IKeyboardPanelInfoChangeListener>::MakeSptr();
656 sptr<IKeyboardPanelInfoChangeListener> listener = nullptr;
657 auto ret = windowSceneSessionImpl->RegisterKeyboardPanelInfoChangeListener(listener);
658 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
659 }
660
661 /**
662 * @tc.name: GetSystemBarPropertyByType
663 * @tc.desc: GetSystemBarPropertyByType
664 * @tc.type: FUNC
665 */
666 HWTEST_F(WindowSceneSessionImplTest4, GetSystemBarPropertyByType, Function | SmallTest | Level2)
667 {
668 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
669 option->SetWindowName("GetSystemBarPropertyByType");
670 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
671 SystemBarProperty prop;
672 prop.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
673 windowSceneSessionImpl->property_->SetPersistentId(1);
674 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
675 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
676 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
677 windowSceneSessionImpl->hostSession_ = session;
678 ASSERT_EQ(WMError::WM_OK, windowSceneSessionImpl->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, prop));
679 auto prop2 = windowSceneSessionImpl->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
680 ASSERT_EQ(prop2, prop);
681 }
682
683 /**
684 * @tc.name: SetSpecificBarProperty
685 * @tc.desc: SetSpecificBarProperty
686 * @tc.type: FUNC
687 */
688 HWTEST_F(WindowSceneSessionImplTest4, SetSpecificBarProperty, Function | SmallTest | Level2)
689 {
690 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
691 option->SetWindowName("SetSpecificBarProperty");
692 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
693
694 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
695 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
696 windowSceneSessionImpl->hostSession_ = session;
697 SystemBarProperty property;
698 windowSceneSessionImpl->property_->SetPersistentId(1);
699 windowSceneSessionImpl->state_ = WindowState::STATE_INITIAL;
700 auto type = WindowType::WINDOW_TYPE_STATUS_BAR;
701 auto ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
702 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
703 windowSceneSessionImpl->state_ = WindowState::STATE_BOTTOM;
704 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
705 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
706 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
707 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
708 EXPECT_EQ(WMError::WM_OK, ret);
709 property = SystemBarProperty();
710 property.settingFlag_ = SystemBarSettingFlag::DEFAULT_SETTING;
711 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
712 EXPECT_EQ(WMError::WM_OK, ret);
713 property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
714 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
715 EXPECT_EQ(WMError::WM_OK, ret);
716 }
717
718 /**
719 * @tc.name: NotifyDialogStateChange
720 * @tc.desc: NotifyDialogStateChange
721 * @tc.type: FUNC
722 */
723 HWTEST_F(WindowSceneSessionImplTest4, NotifyDialogStateChange, Function | SmallTest | Level2)
724 {
725 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
726 option->SetWindowName("NotifyDialogStateChange");
727 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
728
729 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
730 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
731 windowSceneSessionImpl->property_->SetPersistentId(1);
732 windowSceneSessionImpl->hostSession_ = session;
733 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
734 auto ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
735 EXPECT_EQ(WSError::WS_OK, ret);
736 ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
737 EXPECT_EQ(WSError::WS_OK, ret);
738 ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
739 EXPECT_EQ(WSError::WS_OK, ret);
740 ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
741 EXPECT_EQ(WSError::WS_OK, ret);
742 windowSceneSessionImpl->property_->SetPersistentId(0);
743 windowSceneSessionImpl->hostSession_ = nullptr;
744 windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
745 ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
746 EXPECT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ret);
747 }
748
749 /**
750 * @tc.name: GetWindowStatus01
751 * @tc.desc: GetWindowStatus
752 * @tc.type: FUNC
753 */
754 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus01, Function | SmallTest | Level2)
755 {
756 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
757 option->SetWindowName("GetWindowStatus01");
758 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
759 window->property_->SetPersistentId(1);
760 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
761 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
762 window->hostSession_ = session;
763
764 WindowStatus windowStatus;
765 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
766 ASSERT_EQ(WindowStatus::WINDOW_STATUS_UNDEFINED, windowStatus);
767 }
768
769 /**
770 * @tc.name: GetWindowStatus02
771 * @tc.desc: GetWindowStatus
772 * @tc.type: FUNC
773 */
774 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus02, Function | SmallTest | Level2)
775 {
776 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
777 option->SetWindowName("GetWindowStatus02");
778 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
779 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
780 window->property_->SetPersistentId(1);
781 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
782 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
783 window->hostSession_ = session;
784
785 WindowStatus windowStatus;
786 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
787 ASSERT_EQ(WindowStatus::WINDOW_STATUS_SPLITSCREEN, windowStatus);
788 }
789
790 /**
791 * @tc.name: GetWindowStatus03
792 * @tc.desc: GetWindowStatus
793 * @tc.type: FUNC
794 */
795 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus03, Function | SmallTest | Level2)
796 {
797 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
798 option->SetWindowName("GetWindowStatus03");
799 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
800 option->SetDisplayId(0);
801 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
802 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
803 window->property_->SetPersistentId(1);
804 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
805 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
806 window->hostSession_ = session;
807
808 WindowStatus windowStatus;
809 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
810 ASSERT_EQ(WindowStatus::WINDOW_STATUS_FLOATING, windowStatus);
811 window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
812 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
813 ASSERT_EQ(WindowStatus::WINDOW_STATUS_MAXIMIZE, windowStatus);
814 window->state_ = WindowState::STATE_HIDDEN;
815 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
816 ASSERT_EQ(WindowStatus::WINDOW_STATUS_MINIMIZE, windowStatus);
817 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
818 window->state_ = WindowState::STATE_SHOWN;
819 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
820 ASSERT_EQ(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus);
821 }
822
823 /**
824 * @tc.name: SetWindowTitle
825 * @tc.desc: SetWindowTitle Test
826 * @tc.type: FUNC
827 */
828 HWTEST_F(WindowSceneSessionImplTest4, SetWindowTitle, Function | SmallTest | Level2)
829 {
830 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
831 option->SetWindowName("SetWindowTitle");
832 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
833 option->SetDisplayId(0);
834 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
835 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
836 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
837 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
838 window->hostSession_ = session;
839 window->property_->SetPersistentId(1);
840 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
841 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
842 window->windowSystemConfig_.isSystemDecorEnable_ = false;
843 std::string title = "SetWindowTitle";
844 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_INVALID_WINDOW);
845 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
846 window->windowSystemConfig_.isSystemDecorEnable_ = true;
847 window->property_->SetDecorEnable(true);
848 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_NULLPTR);
849 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
850 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_OK);
851 window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
852 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_INVALID_WINDOW);
853 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
854 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_NULLPTR);
855 EXPECT_EQ(window->Create(abilityContext_, session), WMError::WM_OK);
856 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_OK);
857 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
858 }
859
860 /**
861 * @tc.name: AddSubWindowMapForExtensionWindow
862 * @tc.desc: AddSubWindowMapForExtensionWindow Test
863 * @tc.type: FUNC
864 */
865 HWTEST_F(WindowSceneSessionImplTest4, AddSubWindowMapForExtensionWindow, Function | SmallTest | Level2)
866 {
867 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
868 option->SetWindowName("AddSubWindowMapForExtensionWindow");
869 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
870 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
871 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
872 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
873 window->hostSession_ = session;
874 window->property_->SetPersistentId(1);
875 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
876 window->AddSubWindowMapForExtensionWindow();
877 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
878 }
879
880 /**
881 * @tc.name: IsPcOrPadCapabilityEnabled
882 * @tc.desc: IsPcOrPadCapabilityEnabled Test
883 * @tc.type: FUNC
884 */
885 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrPadCapabilityEnabled, Function | SmallTest | Level2)
886 {
887 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
888 option->SetWindowName("IsPcOrPadCapabilityEnabled");
889 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
890 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
891 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
892 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
893 window->hostSession_ = session;
894 window->property_->SetPersistentId(1);
895 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
896 EXPECT_EQ(true, window->IsPcOrPadCapabilityEnabled());
897 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
898 EXPECT_EQ(false, window->IsPcOrPadCapabilityEnabled());
899 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
900 EXPECT_EQ(false, window->IsPcOrPadCapabilityEnabled());
901 window->property_->SetIsUIExtFirstSubWindow(true);
902 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
903 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
904 EXPECT_EQ(true, window->IsPcOrPadCapabilityEnabled());
905 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
906 }
907
908 /**
909 * @tc.name: GetParentSessionAndVerify
910 * @tc.desc: GetParentSessionAndVerify Test
911 * @tc.type: FUNC
912 */
913 HWTEST_F(WindowSceneSessionImplTest4, GetParentSessionAndVerify, Function | SmallTest | Level2)
914 {
915 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
916 option->SetWindowName("GetParentSessionAndVerify");
917 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
918 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
919 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
920 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
921 window->hostSession_ = session;
922 window->property_->SetPersistentId(1);
923 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
924 sptr<WindowSessionImpl> parentSession = nullptr;
925 auto res = window->GetParentSessionAndVerify(false, parentSession);
926 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
927 res = window->GetParentSessionAndVerify(true, parentSession);
928 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
929
930 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
931 subOption->SetWindowName("GetParentSessionAndVerify2");
932 subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
933 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
934 SessionInfo subSessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
935 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
936 subWindow->hostSession_ = subSession;
937 subWindow->property_->SetPersistentId(2);
938 subWindow->property_->SetParentId(1);
939 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
940 std::vector<sptr<WindowSessionImpl>> vec;
941 WindowSceneSessionImpl::subWindowSessionMap_.insert(
942 std::pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1, vec));
943 WindowSceneSessionImpl::subWindowSessionMap_[1].push_back(subWindow);
944 res = subWindow->GetParentSessionAndVerify(false, parentSession);
945 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
946 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
947 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
948 res = subWindow->GetParentSessionAndVerify(false, parentSession);
949 EXPECT_EQ(WMError::WM_OK, res);
950 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
951 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
952 }
953
954 /**
955 * @tc.name: MainWindowCloseInner
956 * @tc.desc: MainWindowCloseInner Test
957 * @tc.type: FUNC
958 */
959 HWTEST_F(WindowSceneSessionImplTest4, MainWindowCloseInner, Function | SmallTest | Level2)
960 {
961 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
962 option->SetWindowName("MainWindowCloseInner");
963 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
964 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
965 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
966 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
967 window->hostSession_ = session;
968 window->property_->SetPersistentId(1);
969 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
970 EXPECT_EQ(WMError::WM_OK, window->MainWindowCloseInner());
971 }
972
973 /**
974 * @tc.name: SetWindowMode01
975 * @tc.desc: SetWindowMode
976 * @tc.type: FUNC
977 */
978 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode01, Function | SmallTest | Level2)
979 {
980 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
981 subOption->SetWindowName("SetWindowMode01");
982 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
983 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
984 subWindow->property_->SetPersistentId(1007);
985 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
986 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
987 subWindow->hostSession_ = subSession;
988 subWindow->property_->SetWindowModeSupportType(0);
989 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
990 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, ret);
991 }
992
993 /**
994 * @tc.name: SetWindowMode02
995 * @tc.desc: SetWindowMode
996 * @tc.type: FUNC
997 */
998 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode02, Function | SmallTest | Level2)
999 {
1000 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1001 subOption->SetWindowName("SetWindowMode02");
1002 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1003 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1004 subWindow->property_->SetPersistentId(1007);
1005 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1006 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1007 subWindow->hostSession_ = subSession;
1008 subWindow->property_->SetWindowModeSupportType(1);
1009 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1010 EXPECT_EQ(WMError::WM_OK, ret);
1011 }
1012
1013 /**
1014 * @tc.name: SetWindowMode03
1015 * @tc.desc: SetWindowMode
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode03, Function | SmallTest | Level2)
1019 {
1020 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1021 subOption->SetWindowName("SetWindowMode03");
1022 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1023 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1024 subWindow->property_->SetPersistentId(0);
1025 SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1026 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1027 subWindow->hostSession_ = subSession;
1028 subWindow->property_->SetWindowModeSupportType(1);
1029 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1030 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1031 }
1032
1033 /**
1034 * @tc.name: UpdateNewSize01
1035 * @tc.desc: UpdateNewSize
1036 * @tc.type: FUNC
1037 */
1038 HWTEST_F(WindowSceneSessionImplTest4, UpdateNewSize01, Function | SmallTest | Level2)
1039 {
1040 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1041 subOption->SetWindowName("UpdateNewSize01SubWindow");
1042 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1043 subWindow->property_->SetPersistentId(1003);
1044 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1045 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1046 subWindow->hostSession_ = subSession;
1047 subWindow->UpdateNewSize();
1048 Rect windowRect = { 0, 0, 0, 0 };
1049 WindowLimits windowLimits = { 0, 0, 0, 0, 0.0, 0, 0 };
1050 subWindow->property_->SetRequestRect(windowRect);
1051 subWindow->property_->SetWindowRect(windowRect);
1052 subWindow->property_->SetWindowLimits(windowLimits);
1053 subWindow->UpdateNewSize();
1054 windowRect.width_ = 10;
1055 windowRect.height_ = 10;
1056 subWindow->UpdateNewSize();
1057 windowRect.width_ = 0;
1058 windowRect.height_ = 0;
1059 ASSERT_NE(nullptr, subWindow->property_);
1060 subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1061 subWindow->UpdateNewSize();
1062 Rect windowRect1 = { 10, 10, 10, 10 };
1063 WindowLimits windowLimits1 = { 100, 100, 100, 100, 0.0, 0, 0 };
1064 subWindow->property_->SetRequestRect(windowRect1);
1065 subWindow->property_->SetWindowLimits(windowLimits1);
1066 subWindow->UpdateNewSize();
1067 Rect windowRect2 = { 200, 200, 200, 200 };
1068 subWindow->property_->SetRequestRect(windowRect2);
1069 subWindow->UpdateNewSize();
1070 }
1071
1072 /**
1073 * @tc.name: UpdateSubWindowStateAndNotify01
1074 * @tc.desc: UpdateSubWindowStateAndNotify
1075 * @tc.type: FUNC
1076 */
1077 HWTEST_F(WindowSceneSessionImplTest4, UpdateSubWindowStateAndNotify01, Function | SmallTest | Level2)
1078 {
1079 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1080 subOption->SetWindowName("UpdateSubWindowStateAndNotify01");
1081 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1082 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1083 subWindow->property_->SetPersistentId(1005);
1084 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1085 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1086 subWindow->hostSession_ = subSession;
1087
1088 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1089 option->SetWindowName("UpdateSubWindowStateAndNotify02");
1090 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1091 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1092 window->property_->SetPersistentId(1006);
1093 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1094 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1095 window->hostSession_ = session;
1096 std::vector<sptr<WindowSessionImpl>> vec;
1097 WindowSceneSessionImpl::subWindowSessionMap_.insert(
1098 std::pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1006, vec));
1099 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1100 WindowSceneSessionImpl::subWindowSessionMap_[1006].push_back(subWindow);
1101 subWindow->state_ = WindowState::STATE_SHOWN;
1102 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1103 subWindow->state_ = WindowState::STATE_HIDDEN;
1104 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1105 subWindow->state_ = WindowState::STATE_SHOWN;
1106 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1107 subWindow->state_ = WindowState::STATE_SHOWN;
1108 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1109 ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1110 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1111 }
1112
1113 /**
1114 * @tc.name: PreLayoutOnShow01
1115 * @tc.desc: PreLayoutOnShow
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(WindowSceneSessionImplTest4, PreLayoutOnShow01, Function | SmallTest | Level2)
1119 {
1120 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1121 option->SetWindowName("PreLayoutOnShow01");
1122 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1123 window->property_->SetPersistentId(2345);
1124 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1125 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1126 window->hostSession_ = nullptr;
1127 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1128 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1129 ASSERT_NE(nullptr, window->uiContent_);
1130 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
1131 window->hostSession_ = session;
1132 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
1133 }
1134
1135 /**
1136 * @tc.name: KeepKeyboardOnFocus01
1137 * @tc.desc: KeepKeyboardOnFocus
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(WindowSceneSessionImplTest4, KeepKeyboardOnFocus01, Function | SmallTest | Level2)
1141 {
1142 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1143 keyboardOption->SetWindowName("KeepKeyboardOnFocus01");
1144 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1145 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1146 keyboardWindow->KeepKeyboardOnFocus(false);
1147 ASSERT_EQ(keyboardWindow->property_->keepKeyboardFlag_, false);
1148
1149 keyboardWindow->KeepKeyboardOnFocus(true);
1150 ASSERT_EQ(keyboardWindow->property_->keepKeyboardFlag_, true);
1151 }
1152
1153 /**
1154 * @tc.name: MoveAndResizeKeyboard01
1155 * @tc.desc: MoveAndResizeKeyboard
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(WindowSceneSessionImplTest4, MoveAndResizeKeyboard01, Function | SmallTest | Level2)
1159 {
1160 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1161 keyboardOption->SetWindowName("MoveAndResizeKeyboard01");
1162 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1163 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1164
1165 bool isLandscape = false;
1166 keyboardWindow->property_->displayId_ = 0;
1167 auto display = SingletonContainer::Get<DisplayManager>().GetDisplayById(0);
1168 if (display != nullptr) {
1169 isLandscape = display->GetWidth() > display->GetHeight();
1170 }
1171 KeyboardLayoutParams param;
1172 param.LandscapeKeyboardRect_ = { 100, 100, 100, 200 };
1173 param.PortraitKeyboardRect_ = { 200, 200, 200, 100 };
1174 auto result = keyboardWindow->MoveAndResizeKeyboard(param);
1175 auto expectRect = isLandscape ? param.LandscapeKeyboardRect_ : param.PortraitKeyboardRect_;
1176 ASSERT_EQ(keyboardWindow->property_->requestRect_, expectRect);
1177 ASSERT_EQ(result, WMError::WM_OK);
1178 }
1179
1180 /**
1181 * @tc.name: MoveAndResizeKeyboard02
1182 * @tc.desc: MoveAndResizeKeyboard
1183 * @tc.type: FUNC
1184 */
1185 HWTEST_F(WindowSceneSessionImplTest4, MoveAndResizeKeyboard02, Function | SmallTest | Level2)
1186 {
1187 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1188 keyboardOption->SetWindowName("MoveAndResizeKeyboard02");
1189 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1190 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1191
1192 bool isLandscape = false;
1193 keyboardWindow->property_->displayId_ = DISPLAY_ID_INVALID;
1194 auto defaultDisplayInfo = DisplayManager::GetInstance().GetDefaultDisplay();
1195 if (defaultDisplayInfo != nullptr) {
1196 isLandscape = defaultDisplayInfo->GetWidth() > defaultDisplayInfo->GetHeight();
1197 }
1198 KeyboardLayoutParams param;
1199 param.LandscapeKeyboardRect_ = { 100, 100, 100, 200 };
1200 param.PortraitKeyboardRect_ = { 200, 200, 200, 100 };
1201 auto result = keyboardWindow->MoveAndResizeKeyboard(param);
1202 auto expectRect = isLandscape ? param.LandscapeKeyboardRect_ : param.PortraitKeyboardRect_;
1203 ASSERT_EQ(keyboardWindow->property_->requestRect_, expectRect);
1204 ASSERT_EQ(result, WMError::WM_OK);
1205 }
1206
CreateWindow(std::string windowName,WindowType type,int32_t id)1207 static sptr<WindowSceneSessionImpl> CreateWindow(std::string windowName, WindowType type, int32_t id)
1208 {
1209 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1210 option->SetWindowName(windowName);
1211 option->SetWindowType(type);
1212 auto window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1213 window->property_->SetPersistentId(id);
1214 return window;
1215 }
1216
1217 /**
1218 * @tc.name: GetParentMainWindowId
1219 * @tc.desc: GetParentMainWindowId
1220 * @tc.type: FUNC
1221 */
1222 HWTEST_F(WindowSceneSessionImplTest4, GetParentMainWindowId001, Function | SmallTest | Level2)
1223 {
1224 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1225 // toastSubWindow is function caller
1226 sptr<WindowSceneSessionImpl> toastWindow = CreateWindow("toastWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 99);
1227 toastWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
1228 toastWindow->windowSessionMap_["toastWindow"] = SessionPair(toastWindow->GetPersistentId(), toastWindow);
1229 int32_t res = 0;
1230 res = toastWindow->GetParentMainWindowId(0);
1231 ASSERT_EQ(res, 0);
1232
1233 sptr<WindowSceneSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1234 ASSERT_NE(mainWindow, nullptr);
1235 toastWindow->windowSessionMap_["mainWindow"] = SessionPair(mainWindow->GetPersistentId(), mainWindow);
1236 toastWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1237 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1238 ASSERT_EQ(res, mainWindow->GetPersistentId());
1239 res = 0;
1240
1241 sptr<WindowSceneSessionImpl> subWindow = CreateWindow("subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 101);
1242 ASSERT_NE(subWindow, nullptr);
1243 subWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1244 toastWindow->property_->SetParentPersistentId(subWindow->GetPersistentId());
1245 toastWindow->windowSessionMap_["subWindow"] = SessionPair(subWindow->GetPersistentId(), subWindow);
1246 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1247 ASSERT_EQ(res, mainWindow->GetPersistentId());
1248 res = 0;
1249
1250 sptr<WindowSceneSessionImpl> dialogWindow = CreateWindow("dialogWindow", WindowType::WINDOW_TYPE_DIALOG, 102);
1251 ASSERT_NE(dialogWindow, nullptr);
1252 dialogWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1253 toastWindow->property_->SetParentPersistentId(dialogWindow->GetPersistentId());
1254 toastWindow->windowSessionMap_["dialogWindow"] = SessionPair(dialogWindow->GetPersistentId(), dialogWindow);
1255 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1256 ASSERT_EQ(res, mainWindow->GetPersistentId());
1257 res = 0;
1258
1259 sptr<WindowSceneSessionImpl> pipWindow = CreateWindow("dialogWindow", WindowType::WINDOW_TYPE_PIP, 103);
1260 ASSERT_NE(pipWindow, nullptr);
1261 pipWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1262 toastWindow->property_->SetParentPersistentId(pipWindow->GetPersistentId());
1263 toastWindow->windowSessionMap_.insert(std::make_pair(
1264 "dialogWindow", std::pair<uint64_t, sptr<WindowSessionImpl>>(pipWindow->GetPersistentId(), pipWindow)));
1265 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1266 ASSERT_EQ(res, 0);
1267 }
1268
1269 /**
1270 * @tc.name: FindParentMainSession001
1271 * @tc.desc: FindParentMainSession001
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(WindowSceneSessionImplTest4, FindParentMainSession001, Function | SmallTest | Level2)
1275 {
1276 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1277 // toastSubWindow is function caller
1278 sptr<WindowSceneSessionImpl> toastWindow = CreateWindow("toastWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 99);
1279 toastWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
1280 ASSERT_NE(toastWindow, nullptr);
1281 toastWindow->windowSessionMap_["toastWindow"] = SessionPair(toastWindow->GetPersistentId(), toastWindow);
1282 sptr<WindowSessionImpl> result = nullptr;
1283
1284 result = toastWindow->FindParentMainSession(0, toastWindow->windowSessionMap_);
1285 ASSERT_EQ(result, nullptr);
1286
1287 // mainWindow need to be found
1288 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1289 ASSERT_NE(mainWindow, nullptr);
1290 toastWindow->windowSessionMap_["mainWindow"] = SessionPair(mainWindow->GetPersistentId(), mainWindow);
1291 toastWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1292 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1293 ASSERT_EQ(result, mainWindow);
1294 result = nullptr;
1295
1296 sptr<WindowSessionImpl> subWindow = CreateWindow("subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 101);
1297 ASSERT_NE(subWindow, nullptr);
1298 subWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1299 toastWindow->property_->SetParentPersistentId(subWindow->GetPersistentId());
1300 toastWindow->windowSessionMap_["subWindow"] = SessionPair(subWindow->GetPersistentId(), subWindow);
1301 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1302 ASSERT_EQ(result, mainWindow);
1303 result = nullptr;
1304
1305 sptr<WindowSessionImpl> floatWindow = CreateWindow("floatWindow", WindowType::WINDOW_TYPE_FLOAT, 105);
1306 ASSERT_NE(subWindow, nullptr);
1307 toastWindow->property_->SetParentPersistentId(floatWindow->GetPersistentId());
1308 floatWindow->property_->SetParentPersistentId(0);
1309 toastWindow->windowSessionMap_["floatWindow"] = SessionPair(floatWindow->GetPersistentId(), floatWindow);
1310 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1311 ASSERT_EQ(result, floatWindow);
1312 result = nullptr;
1313
1314 floatWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1315 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1316 ASSERT_EQ(result, mainWindow);
1317 }
1318
1319 /**
1320 * @tc.name: IsPcOrPadFreeMultiWindowMode
1321 * @tc.desc: IsPcOrPadFreeMultiWindowMode
1322 * @tc.type: FUNC
1323 */
1324 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrPadFreeMultiWindowMode, Function | SmallTest | Level2)
1325 {
1326 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1327 ASSERT_NE(mainWindow, nullptr);
1328 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1329 ASSERT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
1330 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1331 ASSERT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
1332 }
1333
1334 /**
1335 * @tc.name: IsPcOrPadFreeMultiWindowMode
1336 * @tc.desc: uitype = padwindow
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrPadFreeMultiWindowMode002, Function | SmallTest | Level2)
1340 {
1341 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1342 ASSERT_NE(mainWindow, nullptr);
1343 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1344 mainWindow->SetFreeMultiWindowMode(true);
1345 ASSERT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
1346 mainWindow->SetFreeMultiWindowMode(false);
1347 ASSERT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
1348 }
1349
CreateWindowWithDisplayId(std::string windowName,WindowType type,int64_t displayId=DISPLAY_ID_INVALID,uint32_t parentId=INVALID_WINDOW_ID)1350 static sptr<WindowSceneSessionImpl> CreateWindowWithDisplayId(std::string windowName,
1351 WindowType type,
1352 int64_t displayId = DISPLAY_ID_INVALID,
1353 uint32_t parentId = INVALID_WINDOW_ID)
1354 {
1355 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1356 static uint32_t windowPersistentId = 106;
1357 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1358 option->SetWindowName(windowName);
1359 option->SetWindowType(type);
1360 option->SetParentId(parentId);
1361 option->SetDisplayId(displayId);
1362 auto window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1363 window->property_->SetPersistentId(windowPersistentId++);
1364 WindowSessionImpl::windowSessionMap_[std::move(windowName)] = SessionPair(window->GetPersistentId(), window);
1365 return window;
1366 }
1367
1368 /**
1369 * @tc.name: SetSpecificDisplayId01
1370 * @tc.desc: SetSpecificDisplayId01
1371 * @tc.type: FUNC
1372 */
1373 HWTEST_F(WindowSceneSessionImplTest4, SetSpecificDisplayId01, Function | SmallTest | Level2)
1374 {
1375 // create main window
1376 int64_t displayId = 12;
1377 auto mainWindowContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1378 sptr<WindowSceneSessionImpl> mainWindow =
1379 CreateWindowWithDisplayId("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, displayId);
1380 mainWindow->context_ = mainWindowContext;
1381 // create sub window
1382 sptr<WindowSceneSessionImpl> subWindow = CreateWindowWithDisplayId(
1383 "subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, DISPLAY_ID_INVALID, mainWindow->GetPersistentId());
1384
1385 // create float window
1386 sptr<WindowSceneSessionImpl> floatWindow = CreateWindowWithDisplayId("floatWindow", WindowType::WINDOW_TYPE_FLOAT);
1387 floatWindow->context_ = mainWindow->context_;
1388 // create other window
1389 uint64_t globalSearchDisplayId = 5678;
1390 sptr<WindowSceneSessionImpl> globalSearchWindow =
1391 CreateWindowWithDisplayId("globalWindow", WindowType::WINDOW_TYPE_GLOBAL_SEARCH, globalSearchDisplayId);
1392 // test display id
1393 subWindow->CreateAndConnectSpecificSession();
1394 ASSERT_EQ(subWindow->property_->GetDisplayId(), displayId);
1395 floatWindow->CreateSystemWindow(WindowType::WINDOW_TYPE_FLOAT);
1396 ASSERT_EQ(floatWindow->property_->GetDisplayId(), displayId);
1397 globalSearchWindow->CreateSystemWindow(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1398 ASSERT_EQ(globalSearchWindow->property_->GetDisplayId(), globalSearchDisplayId);
1399 }
1400
1401 /**
1402 * @tc.name: SetFullScreenWaterfallMode
1403 * @tc.desc: test SetFullScreenWaterfallMode
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(WindowSceneSessionImplTest4, SetFullScreenWaterfallMode, Function | SmallTest | Level2)
1407 {
1408 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1409 option->SetWindowName("SetFullScreenWaterfallMode");
1410 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1411 window->property_->windowMode_ = WindowMode::WINDOW_MODE_FULLSCREEN;
1412 EXPECT_EQ(WSError::WS_OK, window->SetFullScreenWaterfallMode(true));
1413 EXPECT_EQ(WSError::WS_DO_NOTHING, window->SetFullScreenWaterfallMode(true));
1414 EXPECT_TRUE(window->isFullScreenWaterfallMode_.load());
1415 EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->lastWindowModeBeforeWaterfall_.load());
1416 EXPECT_EQ(WSError::WS_OK, window->SetFullScreenWaterfallMode(false));
1417 EXPECT_FALSE(window->isFullScreenWaterfallMode_.load());
1418 EXPECT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->lastWindowModeBeforeWaterfall_.load());
1419 }
1420
1421 /**
1422 * @tc.name: SetSupportEnterWaterfallMode
1423 * @tc.desc: test SetSupportEnterWaterfallMode
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(WindowSceneSessionImplTest4, SetSupportEnterWaterfallMode, Function | SmallTest | Level2)
1427 {
1428 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1429 option->SetWindowName("SetSupportEnterWaterfallMode");
1430 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1431 ASSERT_EQ(WSError::WS_OK, window->SetSupportEnterWaterfallMode(true));
1432 }
1433
1434 /**
1435 * @tc.name: OnContainerModalEvent
1436 * @tc.desc: test OnContainerModalEvent
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(WindowSceneSessionImplTest4, OnContainerModalEvent, Function | SmallTest | Level2)
1440 {
1441 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1442 option->SetWindowName("OnContainerModalEvent");
1443 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1444 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->OnContainerModalEvent("not_waterfall_window_event", ""));
1445 }
1446
1447 /**
1448 * @tc.name: UpdateConfigurationSyncForAll
1449 * @tc.desc: UpdateConfigurationSyncForAll
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationSyncForAll, Function | SmallTest | Level2)
1453 {
1454 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1455 option->SetWindowName("UpdateConfigurationSyncForAll");
1456 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1457
1458 std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
1459 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1460 SessionInfo sessionInfo = { "CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1" };
1461 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1462 windowSession->hostSession_ = session;
1463 windowSession->property_->SetPersistentId(1);
1464 windowSession->state_ = WindowState::STATE_SHOWN;
1465 ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
1466 windowSceneSessionImpl->UpdateConfigurationSyncForAll(configuration);
1467 ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
1468 }
1469
1470 /**
1471 * @tc.name: NotifyDrawingCompleted
1472 * @tc.desc: NotifyDrawingCompleted
1473 * @tc.type: FUNC
1474 */
1475 HWTEST_F(WindowSceneSessionImplTest4, NotifyDrawingCompleted, Function | SmallTest | Level2)
1476 {
1477 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1478 option->SetWindowName("NotifyDrawingCompleted");
1479 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1480 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1481 windowSessionImpl->hostSession_ = nullptr;
1482 auto ret = window->NotifyDrawingCompleted();
1483 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1484 }
1485
1486 /**
1487 * @tc.name: NotifyDrawingCompleted01
1488 * @tc.desc: NotifyDrawingCompleted
1489 * @tc.type: FUNC
1490 */
1491 HWTEST_F(WindowSceneSessionImplTest4, NotifyDrawingCompleted01, Function | SmallTest | Level2)
1492 {
1493 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1494 option->SetWindowName("NotifyDrawingCompleted01");
1495 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1496 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1497 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1498 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1499 windowSessionImpl->hostSession_ = session;
1500 WindowSessionProperty windowSessionProperty;
1501 windowSessionProperty.SetPersistentId(1);
1502
1503 auto ret = window->NotifyDrawingCompleted();
1504 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1505 }
1506
1507 /**
1508 * @tc.name: MoveTo
1509 * @tc.desc: MoveTo
1510 * @tc.type: FUNC
1511 */
1512 HWTEST_F(WindowSceneSessionImplTest4, MoveTo, Function | SmallTest | Level2)
1513 {
1514 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1515 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1516 option->SetWindowName("MoveTo");
1517 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1518 MoveConfiguration moveConfiguration;
1519
1520 windowSessionImpl->hostSession_ = nullptr;
1521 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1522 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1523
1524 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1525 ret = window->MoveTo(0, 0, true, moveConfiguration);
1526 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1527
1528 windowSessionImpl->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
1529 window->MoveTo(0, 0, true, moveConfiguration);
1530 }
1531
1532 /**
1533 * @tc.name: MoveTo
1534 * @tc.desc: MoveTo
1535 * @tc.type: FUNC
1536 */
1537 HWTEST_F(WindowSceneSessionImplTest4, MoveTo002, Function | SmallTest | Level2)
1538 {
1539 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1540 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1541 option->SetWindowName("MoveTo002");
1542 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1543 MoveConfiguration moveConfiguration;
1544 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1545
1546 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1547 window->state_ = WindowState::STATE_INITIAL;
1548 window->property_->SetPersistentId(1);
1549 ret = window->MoveTo(0, 0, true, moveConfiguration);
1550 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1551 }
1552
1553 /**
1554 * @tc.name: MoveTo
1555 * @tc.desc: MoveTo
1556 * @tc.type: FUNC
1557 */
1558 HWTEST_F(WindowSceneSessionImplTest4, MoveTo003, Function | SmallTest | Level2)
1559 {
1560 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1561 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1562 option->SetWindowName("MoveTo002");
1563 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1564 MoveConfiguration moveConfiguration;
1565 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1566
1567 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1568 window->state_ = WindowState::STATE_INITIAL;
1569 ret = window->MoveTo(0, 0, true, moveConfiguration);
1570 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1571
1572 windowSessionImpl->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
1573 int64_t displayId = 12;
1574 auto mainWindowContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1575 sptr<WindowSceneSessionImpl> mainWindow =
1576 CreateWindowWithDisplayId("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, displayId);
1577 mainWindow->context_ = mainWindowContext;
1578 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1579 ret = window->MoveTo(0, 0, true, moveConfiguration);
1580 ASSERT_EQ(ret, WMError::WM_OK);
1581 }
1582
1583 /**
1584 * @tc.name: MoveWindowToGlobal
1585 * @tc.desc: MoveWindowToGlobal
1586 * @tc.type: FUNC
1587 */
1588 HWTEST_F(WindowSceneSessionImplTest4, MoveWindowToGlobal, Function | SmallTest | Level2)
1589 {
1590 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1591 option->SetWindowName("MoveWindowToGlobal");
1592 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1593
1594 MoveConfiguration moveConfiguration;
1595 window->hostSession_ = nullptr;
1596 auto ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
1597 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1598
1599 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1600 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1601
1602 window->hostSession_ = session;
1603 window->property_->SetPersistentId(1);
1604 window->state_ = WindowState::STATE_INITIAL;
1605
1606 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1607 ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
1608 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS);
1609
1610 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1611 window->MoveWindowToGlobal(0, 0, moveConfiguration);
1612 }
1613
1614 /**
1615 * @tc.name: MoveWindowToGlobal01
1616 * @tc.desc: MoveWindowToGlobal
1617 * @tc.type: FUNC
1618 */
1619 HWTEST_F(WindowSceneSessionImplTest4, MoveWindowToGlobal01, Function | SmallTest | Level2)
1620 {
1621 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1622 option->SetWindowName("MoveWindowToGlobal01");
1623 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1624
1625 MoveConfiguration moveConfiguration;
1626 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1627 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1628 window->hostSession_ = session;
1629 window->property_->SetPersistentId(1);
1630 window->state_ = WindowState::STATE_INITIAL;
1631 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1632 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1633
1634 auto ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
1635 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
1636 }
1637
1638 /**
1639 * @tc.name: OnContainerModalEvent01
1640 * @tc.desc: OnContainerModalEvent
1641 * @tc.type: FUNC
1642 */
1643 HWTEST_F(WindowSceneSessionImplTest4, OnContainerModalEvent01, Function | SmallTest | Level2)
1644 {
1645 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1646 option->SetWindowName("VerifySubWindowLevel01");
1647 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1648
1649 std::string eventName = "window_scene_session_impl_test4";
1650 std::string value = "window_scene_session_impl_test4";
1651 auto ret = window->OnContainerModalEvent(eventName, value);
1652 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
1653
1654 eventName = "scb_waterfall_window_event";
1655 window->hostSession_ = nullptr;
1656 ret = window->OnContainerModalEvent(eventName, value);
1657 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1658 }
1659
1660 /**
1661 * @tc.name: IsSystemDensityChanged01
1662 * @tc.desc: IsSystemDensityChanged
1663 * @tc.type: FUNC
1664 */
1665 HWTEST_F(WindowSceneSessionImplTest4, IsSystemDensityChanged01, Function | SmallTest | Level2)
1666 {
1667 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1668 option->SetWindowName("IsSystemDensityChanged01");
1669 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1670
1671 auto displayInfo = sptr<DisplayInfo>::MakeSptr();
1672 displayInfo->SetVirtualPixelRatio(1.5f);
1673 auto ret = window->IsSystemDensityChanged(displayInfo);
1674 ASSERT_EQ(true, ret);
1675
1676 window->lastSystemDensity_ = 1.5f;
1677 ret = window->IsSystemDensityChanged(displayInfo);
1678 ASSERT_EQ(false, ret);
1679 }
1680 } // namespace
1681 } // namespace Rosen
1682 } // namespace OHOS