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_ability_context_impl.h"
21 #include "mock_session.h"
22 #include "mock_uicontent.h"
23 #include "mock_window_adapter.h"
24 #include "parameters.h"
25 #include "singleton_mocker.h"
26 #include "window_scene_session_impl.h"
27 #include "window_session_impl.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 const std::string WATERFALL_WINDOW_EVENT = "scb_waterfall_window_event";
35 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
36 class WindowSceneSessionImplTest4 : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42
43 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
44 std::unique_ptr<Mocker> mocker_ = std::make_unique<Mocker>();
45
46 private:
47 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
48 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
49 static constexpr uint32_t WAIT_SERVERAL_FRAMES = 36000;
50 };
51
SetUpTestCase()52 void WindowSceneSessionImplTest4::SetUpTestCase() {}
53
TearDownTestCase()54 void WindowSceneSessionImplTest4::TearDownTestCase() {}
55
SetUp()56 void WindowSceneSessionImplTest4::SetUp()
57 {
58 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
59 }
60
TearDown()61 void WindowSceneSessionImplTest4::TearDown()
62 {
63 usleep(WAIT_SYNC_IN_NS);
64 abilityContext_ = nullptr;
65 }
66
CreateRSSurfaceNode()67 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest4::CreateRSSurfaceNode()
68 {
69 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
70 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
71 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
72 return surfaceNode;
73 }
74
75 namespace {
76 /**
77 * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
78 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation
79 * @tc.type: FUNC
80 */
81 HWTEST_F(WindowSceneSessionImplTest4, UpdateSurfaceNodeAfterCustomAnimation, TestSize.Level1)
82 {
83 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
84 option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
85 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
86
87 windowSceneSessionImpl->hostSession_ = nullptr;
88 auto ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
89 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
90
91 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
92 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
93 windowSceneSessionImpl->property_->SetPersistentId(1);
94 windowSceneSessionImpl->hostSession_ = session;
95 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
96 windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_END);
97 ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
98 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
99 windowSceneSessionImpl->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
100 ret = windowSceneSessionImpl->UpdateSurfaceNodeAfterCustomAnimation(true);
101 EXPECT_EQ(WMError::WM_OK, ret);
102 }
103
104 /**
105 * @tc.name: ConsumePointerEvent
106 * @tc.desc: ConsumePointerEvent
107 * @tc.type: FUNC
108 */
109 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEvent, TestSize.Level1)
110 {
111 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
112 option->SetWindowName("ConsumePointerEvent");
113 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
114
115 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
116 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
117 windowSceneSessionImpl->hostSession_ = session;
118 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
119 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
120 windowSceneSessionImpl->hostSession_ = nullptr;
121 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
122 pointerEvent = nullptr;
123 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
124 windowSceneSessionImpl->property_->SetTurnScreenOn(true);
125 auto ret = windowSceneSessionImpl->IsTurnScreenOn();
126 EXPECT_EQ(true, ret);
127 windowSceneSessionImpl->property_->SetTurnScreenOn(false);
128 ret = windowSceneSessionImpl->IsTurnScreenOn();
129 EXPECT_EQ(false, ret);
130 }
131
132 /**
133 * @tc.name: ConsumePointerEvent02
134 * @tc.desc: ConsumePointerEvent02
135 * @tc.type: FUNC
136 */
137 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEvent02, TestSize.Level1)
138 {
139 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
140 option->SetWindowName("ConsumePointerEvent");
141 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
142 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
143 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
144 windowSceneSessionImpl->hostSession_ = session;
145 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
146
147 int32_t pointerId = 0;
148 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
149 pointerEvent->SetPointerId(pointerId);
150 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
151 pointerEvent->SetSourceType(1);
152 MMI::PointerEvent::PointerItem pointerItem;
153 pointerItem.SetPointerId(pointerId);
154 pointerItem.SetOriginPointerId(pointerId);
155 pointerEvent->AddPointerItem(pointerItem);
156
157 windowSceneSessionImpl->property_->SetWindowDelayRaiseEnabled(false);
158 EXPECT_EQ(false, windowSceneSessionImpl->property_->IsWindowDelayRaiseEnabled());
159 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
160
161 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, 1.0f);
162 Rect rect = {1, 1, 1, 1};
163 windowSceneSessionImpl->property_->SetWindowRect(rect);
164 pointerItem.SetWindowX(1);
165 pointerItem.SetWindowY(1);
166 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
167 windowSceneSessionImpl->property_->SetWindowDelayRaiseEnabled(true);
168 EXPECT_EQ(true, windowSceneSessionImpl->property_->IsWindowDelayRaiseEnabled());
169 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
170 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
171 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
172 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
173 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
174 AAFwk::Want want;
175 windowSceneSessionImpl->uiContent_ = nullptr;
176 windowSceneSessionImpl->OnNewWant(want);
177 EXPECT_EQ(windowSceneSessionImpl->GetUIContentSharedPtr(), nullptr);
178 windowSceneSessionImpl->ConsumePointerEvent(pointerEvent);
179 }
180
181 /**
182 * @tc.name: GetSystemSizeLimits01
183 * @tc.desc: GetSystemSizeLimits
184 * @tc.type: FUNC
185 */
186 HWTEST_F(WindowSceneSessionImplTest4, GetSystemSizeLimits01, TestSize.Level1)
187 {
188 uint32_t minMainWidth = 10;
189 uint32_t minMainHeight = 20;
190 uint32_t minSubWidth = 30;
191 uint32_t minSubHeight = 40;
192 uint32_t displayWidth = 100;
193 uint32_t displayHeight = 100;
194 float displayVpr = 1.0f;
195 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
196 option->SetWindowName("GetSystemSizeLimits01");
197 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
198 windowSceneSessionImpl->windowSystemConfig_.miniWidthOfMainWindow_ = minMainWidth;
199 windowSceneSessionImpl->windowSystemConfig_.miniHeightOfMainWindow_ = minMainHeight;
200 windowSceneSessionImpl->windowSystemConfig_.miniWidthOfSubWindow_ = minSubWidth;
201 windowSceneSessionImpl->windowSystemConfig_.miniHeightOfSubWindow_ = minSubHeight;
202
203 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
204 WindowLimits limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
205 EXPECT_EQ(limits.minWidth_, minMainWidth);
206 EXPECT_EQ(limits.minHeight_, minMainHeight);
207
208 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
209 limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
210 EXPECT_EQ(limits.minWidth_, minSubWidth);
211 EXPECT_EQ(limits.minHeight_, minSubHeight);
212
213 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
214 limits = windowSceneSessionImpl->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
215 EXPECT_EQ(limits.minWidth_, static_cast<uint32_t>(MIN_FLOATING_WIDTH * displayVpr));
216 EXPECT_EQ(limits.minHeight_, static_cast<uint32_t>(MIN_FLOATING_HEIGHT * displayVpr));
217 }
218
219 /**
220 * @tc.name: HandlePointDownEvent
221 * @tc.desc: HandlePointDownEvent
222 * @tc.type: FUNC
223 */
224 HWTEST_F(WindowSceneSessionImplTest4, HandlePointDownEvent, TestSize.Level1)
225 {
226 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
227 option->SetWindowName("HandlePointDownEvent");
228 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
229
230 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
231 ASSERT_NE(nullptr, pointerEvent);
232 pointerEvent->SetSourceType(1);
233 MMI::PointerEvent::PointerItem pointerItem;
234 float vpr = 1.0f;
235
236 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
237 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
238 windowSceneSessionImpl->hostSession_ = session;
239 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, vpr);
240 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
241
242 windowSceneSessionImpl->property_->SetDragEnabled(false);
243 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
244 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
245 auto ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
246 EXPECT_EQ(true, ret);
247
248 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
249 windowSceneSessionImpl->property_->SetDragEnabled(false);
250 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
251 EXPECT_EQ(true, ret);
252 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
253
254 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
255 EXPECT_EQ(true, ret);
256
257 pointerItem.SetWindowX(100);
258 pointerItem.SetWindowY(100);
259 Rect rect = {1, 1, 1, 1};
260 windowSceneSessionImpl->property_->SetWindowRect(rect);
261 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
262 EXPECT_EQ(true, ret);
263 pointerItem.SetWindowX(1);
264 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
265 EXPECT_EQ(true, ret);
266
267 windowSceneSessionImpl->property_->SetDragEnabled(true);
268 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
269 EXPECT_EQ(false, ret);
270
271 pointerItem.SetWindowX(100);
272 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
273 EXPECT_EQ(true, ret);
274
275 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_UI_EXTENSION);
276 pointerItem.SetDisplayX(100);
277 pointerItem.SetDisplayY(100);
278 ret = windowSceneSessionImpl->HandlePointDownEvent(pointerEvent, pointerItem);
279 EXPECT_EQ(true, ret);
280 }
281
282 /**
283 * @tc.name: UpdateWindowModeImmediately
284 * @tc.desc: UpdateWindowModeImmediately
285 * @tc.type: FUNC
286 */
287 HWTEST_F(WindowSceneSessionImplTest4, UpdateWindowModeImmediately, TestSize.Level1)
288 {
289 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
290 option->SetWindowName("UpdateWindowModeImmediately");
291 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
292
293 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
294 auto ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
295 EXPECT_EQ(WMError::WM_OK, ret);
296 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, windowSceneSessionImpl->property_->GetWindowMode());
297
298 windowSceneSessionImpl->state_ = WindowState::STATE_HIDDEN;
299 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_FLOATING);
300 EXPECT_EQ(WMError::WM_OK, ret);
301 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, windowSceneSessionImpl->property_->GetWindowMode());
302
303 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
304 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
305 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
306 windowSceneSessionImpl->property_->SetPersistentId(1);
307 windowSceneSessionImpl->hostSession_ = session;
308 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
309 EXPECT_EQ(WMError::WM_OK, ret);
310 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, windowSceneSessionImpl->property_->GetWindowMode());
311
312 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
313 EXPECT_EQ(WMError::WM_OK, ret);
314 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowSceneSessionImpl->property_->GetWindowMode());
315
316 windowSceneSessionImpl->state_ = WindowState::STATE_UNFROZEN;
317 ret = windowSceneSessionImpl->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
318 EXPECT_EQ(WMError::WM_OK, ret);
319 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, windowSceneSessionImpl->property_->GetWindowMode());
320 }
321
322 /**
323 * @tc.name: AdjustWindowAnimationFlag
324 * @tc.desc: AdjustWindowAnimationFlag
325 * @tc.type: FUNC
326 */
327 HWTEST_F(WindowSceneSessionImplTest4, AdjustWindowAnimationFlag, TestSize.Level1)
328 {
329 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
330 option->SetWindowName("AdjustWindowAnimationFlag");
331 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
332 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
333 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
334 windowSceneSessionImpl->property_->SetPersistentId(1);
335 windowSceneSessionImpl->hostSession_ = session;
336 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
337
338 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
339 windowSceneSessionImpl->animationTransitionController_ = sptr<IAnimationTransitionController>::MakeSptr();
340 windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
341 auto ret = windowSceneSessionImpl->property_->GetAnimationFlag();
342 EXPECT_EQ(3, ret);
343 windowSceneSessionImpl->animationTransitionController_ = nullptr;
344 windowSceneSessionImpl->AdjustWindowAnimationFlag(true);
345 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
346 EXPECT_EQ(1, ret);
347 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
348 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
349 EXPECT_EQ(0, ret);
350 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
351 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
352 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
353 EXPECT_EQ(1, ret);
354 windowSceneSessionImpl->enableDefaultAnimation_ = false;
355 windowSceneSessionImpl->AdjustWindowAnimationFlag(false);
356 ret = windowSceneSessionImpl->property_->GetAnimationFlag();
357 EXPECT_EQ(0, ret);
358 }
359
360 /**
361 * @tc.name: UpdateConfigurationForAll
362 * @tc.desc: UpdateConfigurationForAll
363 * @tc.type: FUNC
364 */
365 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationForAll, TestSize.Level1)
366 {
367 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
368 option->SetWindowName("UpdateConfigurationForAll");
369 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
370
371 std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
372 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
373 SessionInfo sessionInfo = { "CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1" };
374 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
375 windowSession->hostSession_ = session;
376 windowSession->property_->SetPersistentId(1);
377 windowSession->state_ = WindowState::STATE_SHOWN;
378 ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
379 windowSceneSessionImpl->UpdateConfigurationForAll(configuration);
380 ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
381 }
382
383 /**
384 * @tc.name: SetWindowFlags
385 * @tc.desc: SetWindowFlags
386 * @tc.type: FUNC
387 */
388 HWTEST_F(WindowSceneSessionImplTest4, SetWindowFlags, TestSize.Level1)
389 {
390 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
391 option->SetWindowName("SetWindowFlags");
392 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
393
394 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
395 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
396 windowSceneSessionImpl->property_->SetPersistentId(1);
397 windowSceneSessionImpl->hostSession_ = session;
398 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
399 windowSceneSessionImpl->SetWindowFlags(1);
400 auto ret = windowSceneSessionImpl->SetWindowFlags(1);
401 EXPECT_EQ(WMError::WM_OK, ret);
402 ret = windowSceneSessionImpl->SetWindowFlags(2);
403 EXPECT_EQ(WMError::WM_OK, ret);
404 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
405 ret = windowSceneSessionImpl->NotifyPrepareClosePiPWindow();
406 EXPECT_EQ(WMError::WM_OK, ret);
407 }
408
409 /**
410 * @tc.name: ResetSuperFoldDisplayY
411 * @tc.desc: ResetSuperFoldDisplayY
412 * @tc.type: FUNC
413 */
414 HWTEST_F(WindowSceneSessionImplTest4, ResetSuperFoldDisplayY, TestSize.Level1)
415 {
416 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
417 option->SetWindowName("ResetSuperFoldDisplayY");
418 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
419
420 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
421 windowSceneSessionImpl->superFoldOffsetY_ = 150;
422 MMI::PointerEvent::PointerItem pointerItem;
423 pointerItem.SetDisplayY(100);
424 pointerEvent->AddPointerItem(pointerItem);
425 int32_t originalDisplayY = pointerItem.GetDisplayY();
426 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
427 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
428 int32_t updatedDisplayY = pointerItem.GetDisplayY();
429
430 pointerItem.SetDisplayY(150);
431 pointerEvent->AddPointerItem(pointerItem);
432 originalDisplayY = pointerItem.GetDisplayY();
433 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
434 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
435 updatedDisplayY = pointerItem.GetDisplayY();
436 ASSERT_EQ(updatedDisplayY, originalDisplayY - 150);
437 }
438
439 /**
440 * @tc.name: ResetSuperFoldDisplayY01
441 * @tc.desc: ResetSuperFoldDisplayY01
442 * @tc.type: FUNC
443 */
444 HWTEST_F(WindowSceneSessionImplTest4, ResetSuperFoldDisplayY01, TestSize.Level1)
445 {
446 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
447 option->SetWindowName("ResetSuperFoldDisplayY01");
448 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
449
450 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
451 windowSceneSessionImpl->superFoldOffsetY_ = 150;
452 MMI::PointerEvent::PointerItem pointerItem;
453 pointerItem.SetDisplayYPos(100);
454 pointerEvent->AddPointerItem(pointerItem);
455 auto originalDisplayY = pointerItem.GetDisplayYPos();
456 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
457 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
458 auto updatedDisplayY = pointerItem.GetDisplayYPos();
459 ASSERT_EQ(updatedDisplayY, originalDisplayY);
460
461 pointerItem.SetDisplayYPos(150);
462 pointerEvent->AddPointerItem(pointerItem);
463 originalDisplayY = pointerItem.GetDisplayYPos();
464 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
465 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
466 updatedDisplayY = pointerItem.GetDisplayYPos();
467 ASSERT_EQ(updatedDisplayY, originalDisplayY - 150);
468
469 pointerItem.SetDisplayYPos(150.001);
470 pointerEvent->AddPointerItem(pointerItem);
471 originalDisplayY = pointerItem.GetDisplayYPos();
472 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
473 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
474 updatedDisplayY = pointerItem.GetDisplayYPos();
475 ASSERT_EQ(updatedDisplayY, originalDisplayY - 150);
476
477 pointerItem.SetDisplayYPos(151.001);
478 pointerEvent->AddPointerItem(pointerItem);
479 originalDisplayY = pointerItem.GetDisplayYPos();
480 windowSceneSessionImpl->ResetSuperFoldDisplayY(pointerEvent);
481 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
482 updatedDisplayY = pointerItem.GetDisplayYPos();
483 ASSERT_EQ(updatedDisplayY, originalDisplayY - 150);
484 }
485
486 /**
487 * @tc.name: ConsumePointerEventInner
488 * @tc.desc: ConsumePointerEventInner
489 * @tc.type: FUNC
490 */
491 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEventInner, TestSize.Level0)
492 {
493 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
494 option->SetWindowName("ConsumePointerEventInner");
495 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
496
497 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
498 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
499 windowSceneSessionImpl->property_->SetPersistentId(1);
500 windowSceneSessionImpl->hostSession_ = session;
501 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
502 ASSERT_NE(nullptr, pointerEvent);
503 MMI::PointerEvent::PointerItem pointerItem;
504 pointerEvent->SetPointerAction(10);
505 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
506 pointerEvent->SetPointerAction(4);
507 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
508 pointerEvent->SetPointerAction(2);
509 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem);
510 }
511
512 /**
513 * @tc.name: ConsumePointerEventInner02
514 * @tc.desc: ConsumePointerEventInner02
515 * @tc.type: FUNC
516 */
517 HWTEST_F(WindowSceneSessionImplTest4, ConsumePointerEventInner02, TestSize.Level1)
518 {
519 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
520 option->SetWindowName("ConsumePointerEventInner");
521 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
522 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
523 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
524 windowSceneSessionImpl->hostSession_ = session;
525 windowSceneSessionImpl->property_->SetWindowDelayRaiseEnabled(true);
526 windowSceneSessionImpl->property_->SetPersistentId(1);
527 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
528 ASSERT_NE(nullptr, pointerEvent);
529 MMI::PointerEvent::PointerItem pointerItem;
530 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
531 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem, true);
532 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
533 windowSceneSessionImpl->ConsumePointerEventInner(pointerEvent, pointerItem, true);
534 }
535
536 /**
537 * @tc.name: HandleEventForCompatibleMode
538 * @tc.desc: HandleEventForCompatibleMode
539 * @tc.type: FUNC
540 */
541 HWTEST_F(WindowSceneSessionImplTest4, HandleEventForCompatibleMode, TestSize.Level1)
542 {
543 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
544 option->SetWindowName("HandleEventForCompatibleMode");
545 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
546
547 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
548 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
549 windowSceneSessionImpl->property_->SetPersistentId(1);
550 windowSceneSessionImpl->hostSession_ = session;
551 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
552 ASSERT_NE(nullptr, pointerEvent);
553 MMI::PointerEvent::PointerItem pointerItem;
554 pointerEvent->SetPointerAction(2);
555 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
556 pointerEvent->SetPointerAction(3);
557 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
558 pointerEvent->SetPointerAction(4);
559 windowSceneSessionImpl->HandleEventForCompatibleMode(pointerEvent, pointerItem);
560 }
561
562 /**
563 * @tc.name: HandleDownForCompatibleMode
564 * @tc.desc: HandleDownForCompatibleMode
565 * @tc.type: FUNC
566 */
567 HWTEST_F(WindowSceneSessionImplTest4, HandleDownForCompatibleMode, TestSize.Level1)
568 {
569 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
570 option->SetWindowName("HandleDownForCompatibleMode");
571 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
572
573 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
574 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
575 windowSceneSessionImpl->property_->SetPersistentId(1);
576 windowSceneSessionImpl->hostSession_ = session;
577 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
578 ASSERT_NE(nullptr, pointerEvent);
579 MMI::PointerEvent::PointerItem pointerItem;
580 pointerEvent->SetPointerAction(2);
581 windowSceneSessionImpl->HandleDownForCompatibleMode(pointerEvent, pointerItem);
582 }
583
584 /**
585 * @tc.name: HandleMoveForCompatibleMode
586 * @tc.desc: HandleMoveForCompatibleMode
587 * @tc.type: FUNC
588 */
589 HWTEST_F(WindowSceneSessionImplTest4, HandleMoveForCompatibleMode, TestSize.Level1)
590 {
591 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
592 option->SetWindowName("HandleMoveForCompatibleMode");
593 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
594
595 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
596 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
597 windowSceneSessionImpl->property_->SetPersistentId(1);
598 windowSceneSessionImpl->hostSession_ = session;
599 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
600 ASSERT_NE(nullptr, pointerEvent);
601 MMI::PointerEvent::PointerItem pointerItem;
602 pointerEvent->SetPointerAction(3);
603 windowSceneSessionImpl->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
604 }
605
606 /**
607 * @tc.name: HandleUpForCompatibleMode
608 * @tc.desc: HandleUpForCompatibleMode
609 * @tc.type: FUNC
610 */
611 HWTEST_F(WindowSceneSessionImplTest4, HandleUpForCompatibleMode, TestSize.Level1)
612 {
613 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
614 option->SetWindowName("HandleUpForCompatibleMode");
615 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
616
617 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
618 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
619 windowSceneSessionImpl->property_->SetPersistentId(1);
620 windowSceneSessionImpl->hostSession_ = session;
621 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
622 ASSERT_NE(nullptr, pointerEvent);
623 MMI::PointerEvent::PointerItem pointerItem;
624 pointerEvent->SetPointerAction(4);
625 windowSceneSessionImpl->HandleUpForCompatibleMode(pointerEvent, pointerItem);
626 }
627
628 /**
629 * @tc.name: ConvertPointForCompatibleMode
630 * @tc.desc: ConvertPointForCompatibleMode
631 * @tc.type: FUNC
632 */
633 HWTEST_F(WindowSceneSessionImplTest4, ConvertPointForCompatibleMode, TestSize.Level1)
634 {
635 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
636 option->SetWindowName("ConvertPointForCompatibleMode");
637 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
638
639 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
640 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
641 windowSceneSessionImpl->property_->SetPersistentId(1);
642 windowSceneSessionImpl->hostSession_ = session;
643 int32_t transferX = 800;
644 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
645 ASSERT_NE(nullptr, pointerEvent);
646 MMI::PointerEvent::PointerItem pointerItem;
647 pointerEvent->SetPointerAction(2);
648 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
649 pointerEvent->SetPointerAction(3);
650 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
651 pointerEvent->SetPointerAction(4);
652 windowSceneSessionImpl->ConvertPointForCompatibleMode(pointerEvent, pointerItem, transferX);
653 }
654
655 /**
656 * @tc.name: IsInMappingRegionForCompatibleMode
657 * @tc.desc: IsInMappingRegionForCompatibleMode
658 * @tc.type: FUNC
659 */
660 HWTEST_F(WindowSceneSessionImplTest4, IsInMappingRegionForCompatibleMode, TestSize.Level1)
661 {
662 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
663 option->SetWindowName("IsInMappingRegionForCompatibleMode");
664 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
665
666 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
667 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
668 windowSceneSessionImpl->property_->SetPersistentId(1);
669 windowSceneSessionImpl->hostSession_ = session;
670 windowSceneSessionImpl->property_->SetWindowRect({ 880, 0, 800, 1600 });
671 int32_t displayX = 400;
672 int32_t displayY = 400;
673 bool ret = windowSceneSessionImpl->IsInMappingRegionForCompatibleMode(displayX, displayY);
674 EXPECT_EQ(true, ret);
675 displayX = 1000;
676 displayY = 1000;
677 ret = windowSceneSessionImpl->IsInMappingRegionForCompatibleMode(displayX, displayY);
678 EXPECT_EQ(false, ret);
679 }
680
681 /**
682 * @tc.name: CheckTouchSlop
683 * @tc.desc: CheckTouchSlop
684 * @tc.type: FUNC
685 */
686 HWTEST_F(WindowSceneSessionImplTest4, CheckTouchSlop, TestSize.Level1)
687 {
688 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
689 option->SetWindowName("CheckTouchSlop");
690 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
691
692 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
693 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
694 windowSceneSessionImpl->property_->SetPersistentId(1);
695 windowSceneSessionImpl->hostSession_ = session;
696 int32_t pointerId = 0;
697 int32_t displayX = 400;
698 int32_t displayY = 400;
699 int32_t threshold = 50;
700 bool ret = windowSceneSessionImpl->CheckTouchSlop(pointerId, displayX, displayY, threshold);
701 EXPECT_EQ(false, ret);
702 }
703
704 /**
705 * @tc.name: IgnoreClickEvent
706 * @tc.desc: IgnoreClickEvent
707 * @tc.type: FUNC
708 */
709 HWTEST_F(WindowSceneSessionImplTest4, IgnoreClickEvent, TestSize.Level1)
710 {
711 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
712 option->SetWindowName("IgnoreClickEvent");
713 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
714
715 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
716 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
717 windowSceneSessionImpl->property_->SetPersistentId(1);
718 windowSceneSessionImpl->hostSession_ = session;
719 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
720 ASSERT_NE(nullptr, pointerEvent);
721 pointerEvent->SetPointerAction(3);
722 windowSceneSessionImpl->IgnoreClickEvent(pointerEvent);
723 pointerEvent->SetPointerAction(4);
724 windowSceneSessionImpl->IgnoreClickEvent(pointerEvent);
725 }
726
727 /**
728 * @tc.name: RegisterKeyboardPanelInfoChangeListener
729 * @tc.desc: RegisterKeyboardPanelInfoChangeListener
730 * @tc.type: FUNC
731 */
732 HWTEST_F(WindowSceneSessionImplTest4, RegisterKeyboardPanelInfoChangeListener, TestSize.Level1)
733 {
734 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
735 option->SetWindowName("RegisterKeyboardPanelInfoChangeListener");
736 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
737 windowSceneSessionImpl->keyboardPanelInfoChangeListeners_ = sptr<IKeyboardPanelInfoChangeListener>::MakeSptr();
738 sptr<IKeyboardPanelInfoChangeListener> listener = nullptr;
739 auto ret = windowSceneSessionImpl->RegisterKeyboardPanelInfoChangeListener(listener);
740 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
741 }
742
743 /**
744 * @tc.name: RegisterWindowAttachStateChangeListener
745 * @tc.desc: RegisterWindowAttachStateChangeListener
746 * @tc.type: FUNC
747 */
748 HWTEST_F(WindowSceneSessionImplTest4, RegisterWindowAttachStateChangeListener, TestSize.Level1)
749 {
750 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
751 option->SetWindowName("RegisterKeyboardPanelInfoChangeListener");
752 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
753 windowSceneSessionImpl->windowAttachStateChangeListener_ = sptr<IWindowAttachStateChangeListner>::MakeSptr();
754
755 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
756 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
757 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
758 windowSceneSessionImpl->hostSession_ = session;
759
760 // case1: listener is nullptr
761 sptr<IWindowAttachStateChangeListner> listener = nullptr;
762 auto ret = windowSceneSessionImpl->RegisterWindowAttachStateChangeListener(listener);
763 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
764
765 // case2: listener is not nullptr
766 listener = sptr<IWindowAttachStateChangeListner>::MakeSptr();
767 ret = windowSceneSessionImpl->RegisterWindowAttachStateChangeListener(listener);
768 EXPECT_EQ(WMError::WM_OK, ret);
769
770 // case3: host session is nullptr
771 windowSceneSessionImpl->hostSession_ = nullptr;
772 ret = windowSceneSessionImpl->RegisterWindowAttachStateChangeListener(listener);
773 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
774 }
775
776 /**
777 * @tc.name: UnregisterWindowAttachStateChangeListener
778 * @tc.desc: UnregisterWindowAttachStateChangeListener
779 * @tc.type: FUNC
780 */
781 HWTEST_F(WindowSceneSessionImplTest4, UnregisterWindowAttachStateChangeListener, TestSize.Level1)
782 {
783 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
784 option->SetWindowName("UnregisterWindowAttachStateChangeListener");
785 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
786 windowSceneSessionImpl->windowAttachStateChangeListener_ = sptr<IWindowAttachStateChangeListner>::MakeSptr();
787
788 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
789 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
790 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
791 windowSceneSessionImpl->hostSession_ = session;
792
793 // case1: register listener
794 sptr<IWindowAttachStateChangeListner> listener = sptr<IWindowAttachStateChangeListner>::MakeSptr();
795 auto ret = windowSceneSessionImpl->RegisterWindowAttachStateChangeListener(listener);
796 EXPECT_EQ(WMError::WM_OK, ret);
797
798 // case2: unregister success
799 ret = windowSceneSessionImpl->UnregisterWindowAttachStateChangeListener();
800 EXPECT_EQ(WMError::WM_OK, ret);
801 EXPECT_EQ(windowSceneSessionImpl->windowAttachStateChangeListener_, nullptr);
802
803 // case3: host session is nullptr
804 windowSceneSessionImpl->hostSession_ = nullptr;
805 ret = windowSceneSessionImpl->UnregisterWindowAttachStateChangeListener();
806 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
807 }
808
809 /**
810 * @tc.name: NotifyWindowAttachStateChange
811 * @tc.desc: NotifyWindowAttachStateChange
812 * @tc.type: FUNC
813 */
814 HWTEST_F(WindowSceneSessionImplTest4, NotifyWindowAttachStateChange, TestSize.Level1)
815 {
816 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
817 option->SetWindowName("NotifyWindowAttachStateChange");
818 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
819 windowSceneSessionImpl->windowAttachStateChangeListener_ = nullptr;
820
821 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
822 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
823 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
824 windowSceneSessionImpl->hostSession_ = session;
825
826 // case1: listener is nullptr
827 auto ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(true);
828 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, ret);
829 ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(false);
830 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, ret);
831
832 // case2: listener is not nullptr, then attach is true
833 sptr<IWindowAttachStateChangeListner> listener = sptr<IWindowAttachStateChangeListner>::MakeSptr();
834 auto ret2 = windowSceneSessionImpl->RegisterWindowAttachStateChangeListener(listener);
835 EXPECT_EQ(WMError::WM_OK, ret2);
836 ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(true);
837 EXPECT_EQ(WSError::WS_OK, ret);
838 ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(true);
839 EXPECT_EQ(WSError::WS_OK, ret);
840
841 // case3: listener is not nullptr, then attach is false
842 ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(false);
843 EXPECT_EQ(WSError::WS_OK, ret);
844 ret = windowSceneSessionImpl->NotifyWindowAttachStateChange(false);
845 EXPECT_EQ(WSError::WS_OK, ret);
846 }
847
848 /**
849 * @tc.name: GetSystemBarPropertyByType
850 * @tc.desc: GetSystemBarPropertyByType
851 * @tc.type: FUNC
852 */
853 HWTEST_F(WindowSceneSessionImplTest4, GetSystemBarPropertyByType, TestSize.Level1)
854 {
855 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
856 option->SetWindowName("GetSystemBarPropertyByType");
857 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
858 SystemBarProperty prop;
859 prop.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
860 windowSceneSessionImpl->property_->SetPersistentId(1);
861 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
862 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
863 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
864 windowSceneSessionImpl->hostSession_ = session;
865 ASSERT_EQ(WMError::WM_OK, windowSceneSessionImpl->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, prop));
866 auto prop2 = windowSceneSessionImpl->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
867 ASSERT_EQ(prop2, prop);
868 }
869
870 /**
871 * @tc.name: SetSpecificBarProperty
872 * @tc.desc: SetSpecificBarProperty
873 * @tc.type: FUNC
874 */
875 HWTEST_F(WindowSceneSessionImplTest4, SetSpecificBarProperty, TestSize.Level0)
876 {
877 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
878 option->SetWindowName("SetSpecificBarProperty");
879 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
880
881 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
882 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
883 windowSceneSessionImpl->hostSession_ = session;
884 SystemBarProperty property;
885 windowSceneSessionImpl->property_->SetPersistentId(1);
886 windowSceneSessionImpl->state_ = WindowState::STATE_INITIAL;
887 auto type = WindowType::WINDOW_TYPE_STATUS_BAR;
888 auto ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
889 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
890 windowSceneSessionImpl->state_ = WindowState::STATE_BOTTOM;
891 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
892 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
893 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
894 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
895 EXPECT_EQ(WMError::WM_OK, ret);
896 property = SystemBarProperty();
897 property.settingFlag_ = SystemBarSettingFlag::DEFAULT_SETTING;
898 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
899 EXPECT_EQ(WMError::WM_OK, ret);
900 property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
901 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
902 EXPECT_EQ(WMError::WM_OK, ret);
903 }
904
905 /**
906 * @tc.name: SetSystemBarPropertyForPage
907 * @tc.desc: SetSystemBarPropertyForPage
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowSceneSessionImplTest4, SetSystemBarPropertyForPage, Function | SmallTest | Level2)
911 {
912 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
913 option->SetWindowName("SetSystemBarPropertyForPage");
914 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
915 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
916 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
917 windowSceneSessionImpl->hostSession_ = session;
918 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
919 property->SetPersistentId(1);
920 windowSceneSessionImpl->property_ = property;
921 std::optional<SystemBarProperty> prop;
922 windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
923 auto ret = windowSceneSessionImpl->SetSystemBarPropertyForPage(WindowType::WINDOW_TYPE_STATUS_BAR, prop);
924 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
925 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
926 windowSceneSessionImpl->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
927 ret = windowSceneSessionImpl->SetSystemBarPropertyForPage(WindowType::WINDOW_TYPE_STATUS_BAR, prop);
928 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
929 windowSceneSessionImpl->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
930 ret = windowSceneSessionImpl->SetSystemBarPropertyForPage(WindowType::WINDOW_TYPE_STATUS_BAR, prop);
931 EXPECT_EQ(WMError::WM_OK, ret);
932 }
933
934 /**
935 * @tc.name: GetSystemBarPropertyForPage
936 * @tc.desc: GetSystemBarPropertyForPage
937 * @tc.type: FUNC
938 */
939 HWTEST_F(WindowSceneSessionImplTest4, GetSystemBarPropertyForPage, Function | SmallTest | Level2)
940 {
941 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
942 option->SetWindowName("GetSystemBarPropertyForPage");
943 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
944 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
945 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
946 windowSceneSessionImpl->hostSession_ = session;
947 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
948 property->SetPersistentId(1);
949 windowSceneSessionImpl->property_ = property;
950 std::map<WindowType, SystemBarProperty> properties;
951 std::map<WindowType, SystemBarProperty> pageProperties;
952 windowSceneSessionImpl->GetSystemBarPropertyForPage(properties, pageProperties);
953 EXPECT_EQ(pageProperties[WindowType::WINDOW_TYPE_STATUS_BAR],
954 windowSceneSessionImpl->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR));
955 EXPECT_EQ(pageProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR],
956 windowSceneSessionImpl->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR));
957 }
958
959 /**
960 * @tc.name: NotifyDialogStateChange
961 * @tc.desc: NotifyDialogStateChange
962 * @tc.type: FUNC
963 */
964 HWTEST_F(WindowSceneSessionImplTest4, NotifyDialogStateChange, TestSize.Level1)
965 {
966 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
967 option->SetWindowName("NotifyDialogStateChange");
968 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
969
970 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
971 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
972 windowSceneSessionImpl->property_->SetPersistentId(1);
973 windowSceneSessionImpl->hostSession_ = session;
974 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
975 auto ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
976 EXPECT_EQ(WSError::WS_OK, ret);
977 ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
978 EXPECT_EQ(WSError::WS_OK, ret);
979 ret = windowSceneSessionImpl->NotifyDialogStateChange(false);
980 EXPECT_EQ(WSError::WS_OK, ret);
981 ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
982 EXPECT_EQ(WSError::WS_OK, ret);
983 windowSceneSessionImpl->property_->SetPersistentId(0);
984 windowSceneSessionImpl->hostSession_ = nullptr;
985 windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
986 ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
987 EXPECT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ret);
988 }
989
990 /**
991 * @tc.name: GetWindowStatus01
992 * @tc.desc: GetWindowStatus
993 * @tc.type: FUNC
994 */
995 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus01, TestSize.Level1)
996 {
997 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
998 option->SetWindowName("GetWindowStatus01");
999 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1000 WindowStatus windowStatus;
1001 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetWindowStatus(windowStatus));
1002 ASSERT_EQ(WindowStatus::WINDOW_STATUS_UNDEFINED, windowStatus);
1003 window->property_->SetPersistentId(1);
1004 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1005 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1006 window->hostSession_ = session;
1007
1008 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1009 ASSERT_EQ(WindowStatus::WINDOW_STATUS_UNDEFINED, windowStatus);
1010 }
1011
1012 /**
1013 * @tc.name: GetWindowStatus02
1014 * @tc.desc: GetWindowStatus
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus02, TestSize.Level1)
1018 {
1019 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1020 option->SetWindowName("GetWindowStatus02");
1021 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1022 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1023 window->property_->SetPersistentId(1);
1024 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1025 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1026 window->hostSession_ = session;
1027
1028 WindowStatus windowStatus;
1029 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1030 ASSERT_EQ(WindowStatus::WINDOW_STATUS_SPLITSCREEN, windowStatus);
1031 }
1032
1033 /**
1034 * @tc.name: GetWindowStatus03
1035 * @tc.desc: GetWindowStatus
1036 * @tc.type: FUNC
1037 */
1038 HWTEST_F(WindowSceneSessionImplTest4, GetWindowStatus03, TestSize.Level1)
1039 {
1040 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1041 option->SetWindowName("GetWindowStatus03");
1042 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1043 option->SetDisplayId(0);
1044 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1045 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1046 window->property_->SetPersistentId(1);
1047 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1048 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1049 window->hostSession_ = session;
1050
1051 WindowStatus windowStatus;
1052 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1053 ASSERT_EQ(WindowStatus::WINDOW_STATUS_FLOATING, windowStatus);
1054 window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
1055 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1056 ASSERT_EQ(WindowStatus::WINDOW_STATUS_MAXIMIZE, windowStatus);
1057 window->state_ = WindowState::STATE_HIDDEN;
1058 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1059 ASSERT_EQ(WindowStatus::WINDOW_STATUS_MINIMIZE, windowStatus);
1060 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1061 window->state_ = WindowState::STATE_SHOWN;
1062 ASSERT_EQ(WMError::WM_OK, window->GetWindowStatus(windowStatus));
1063 ASSERT_EQ(WindowStatus::WINDOW_STATUS_FULLSCREEN, windowStatus);
1064 }
1065
1066 /**
1067 * @tc.name: SetWindowTitle
1068 * @tc.desc: SetWindowTitle Test
1069 * @tc.type: FUNC
1070 */
1071 HWTEST_F(WindowSceneSessionImplTest4, SetWindowTitle, TestSize.Level1)
1072 {
1073 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1074 option->SetWindowName("SetWindowTitle");
1075 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1076 option->SetDisplayId(0);
1077 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1078 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1079 std::string title = "SetWindowTitle";
1080 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_INVALID_WINDOW);
1081 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1082 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1083 window->hostSession_ = session;
1084 window->property_->SetPersistentId(1);
1085 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1086 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1087 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1088 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
1089 window->windowSystemConfig_.isSystemDecorEnable_ = false;
1090 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_INVALID_WINDOW);
1091 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1092 window->windowSystemConfig_.isSystemDecorEnable_ = true;
1093 window->property_->SetDecorEnable(true);
1094 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_NULLPTR);
1095 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1096 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_OK);
1097 window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1098 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_INVALID_WINDOW);
1099 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1100 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_ERROR_NULLPTR);
1101 EXPECT_EQ(window->Create(abilityContext_, session), WMError::WM_OK);
1102 EXPECT_EQ(window->SetWindowTitle(title), WMError::WM_OK);
1103
1104 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1105 window->property_->SetPcAppInpadCompatibleMode(true);
1106 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
1107 window->windowSystemConfig_.isSystemDecorEnable_ = false;
1108 EXPECT_EQ(WMError::WM_OK, window->SetWindowTitle(title));
1109 const std::string feature = "large_screen";
1110 std::string deviceType = OHOS::system::GetParameter("const.product.devicetype", "");
1111 auto context = std::make_shared<MockAbilityContextImpl>();
1112 window->context_ = context;
1113 context->hapModuleInfo_ = std::make_shared<AppExecFwk::HapModuleInfo>();
1114 context->hapModuleInfo_->requiredDeviceFeatures = {{deviceType, {feature}}};
1115 EXPECT_EQ(WMError::WM_OK, window->SetWindowTitle(title));
1116 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1117 }
1118
1119 /**
1120 * @tc.name: AddSubWindowMapForExtensionWindow
1121 * @tc.desc: AddSubWindowMapForExtensionWindow Test
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(WindowSceneSessionImplTest4, AddSubWindowMapForExtensionWindow, TestSize.Level1)
1125 {
1126 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1127 option->SetWindowName("AddSubWindowMapForExtensionWindow");
1128 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1129 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1130 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1131 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1132 window->hostSession_ = session;
1133 window->property_->SetPersistentId(1);
1134 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1135 WindowSceneSessionImpl::subWindowSessionMap_.clear();
1136 window->AddSubWindowMapForExtensionWindow();
1137 EXPECT_EQ(WindowSceneSessionImpl::subWindowSessionMap_.size(), 0);
1138 window->context_ = abilityContext_;
1139
1140 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1141 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_UI_EXTENSION);
1142 windowSession->context_ = abilityContext_;
1143 windowSession->property_->SetPersistentId(2);
1144 WindowSessionImpl::GetWindowExtensionSessionSet().insert(windowSession);
1145 window->AddSubWindowMapForExtensionWindow();
1146 EXPECT_EQ(WindowSceneSessionImpl::subWindowSessionMap_.size(), 1);
1147 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1148 }
1149
1150 /**
1151 * @tc.name: IsPcOrFreeMultiWindowCapabilityEnabled
1152 * @tc.desc: IsPcOrFreeMultiWindowCapabilityEnabled Test
1153 * @tc.type: FUNC
1154 */
1155 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrFreeMultiWindowCapabilityEnabled, TestSize.Level1)
1156 {
1157 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1158 option->SetWindowName("IsPcOrFreeMultiWindowCapabilityEnabled");
1159 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1160 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1161 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1162 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1163 window->hostSession_ = session;
1164 window->property_->SetPersistentId(1);
1165 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1166 EXPECT_EQ(true, window->IsPcOrFreeMultiWindowCapabilityEnabled());
1167 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1168 EXPECT_EQ(false, window->IsPcOrFreeMultiWindowCapabilityEnabled());
1169 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1170 EXPECT_EQ(false, window->IsPcOrFreeMultiWindowCapabilityEnabled());
1171 window->property_->SetIsUIExtFirstSubWindow(true);
1172 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
1173 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1174 EXPECT_EQ(true, window->IsPcOrFreeMultiWindowCapabilityEnabled());
1175 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1176 }
1177
1178 /**
1179 * @tc.name: GetParentSessionAndVerify
1180 * @tc.desc: GetParentSessionAndVerify Test
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(WindowSceneSessionImplTest4, GetParentSessionAndVerify, TestSize.Level1)
1184 {
1185 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1186 option->SetWindowName("GetParentSessionAndVerify");
1187 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1188 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1189 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1190 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1191 window->hostSession_ = session;
1192 window->property_->SetPersistentId(1);
1193 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1194 sptr<WindowSessionImpl> parentSession = nullptr;
1195 auto res = window->GetParentSessionAndVerify(false, parentSession);
1196 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
1197 res = window->GetParentSessionAndVerify(true, parentSession);
1198 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
1199
1200 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1201 subOption->SetWindowName("GetParentSessionAndVerify2");
1202 subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1203 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1204 SessionInfo subSessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1205 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1206 subWindow->hostSession_ = subSession;
1207 subWindow->property_->SetPersistentId(2);
1208 subWindow->property_->SetParentId(1);
1209 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1210 std::vector<sptr<WindowSessionImpl>> vec;
1211 WindowSceneSessionImpl::subWindowSessionMap_.insert(
1212 std::pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1, vec));
1213 WindowSceneSessionImpl::subWindowSessionMap_[1].push_back(subWindow);
1214 res = subWindow->GetParentSessionAndVerify(false, parentSession);
1215 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, res);
1216 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
1217 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1218 res = subWindow->GetParentSessionAndVerify(false, parentSession);
1219 EXPECT_EQ(WMError::WM_OK, res);
1220 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1221 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1222 }
1223
1224 /**
1225 * @tc.name: GetParentSessionAndVerify01
1226 * @tc.desc: GetParentSessionAndVerify Test
1227 * @tc.type: FUNC
1228 */
1229 HWTEST_F(WindowSceneSessionImplTest4, GetParentSessionAndVerify01, TestSize.Level1)
1230 {
1231 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1232 option->SetWindowName("GetParentSessionAndVerify01");
1233 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1234 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1235 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1236 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1237 window->hostSession_ = session;
1238 window->property_->SetPersistentId(1);
1239 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1240 WindowSceneSessionImpl::windowSessionMap_.clear();
1241 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
1242 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1243
1244 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1245 subOption->SetWindowName("GetParentSessionAndVerify01_subWindow");
1246 subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1247 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1248 SessionInfo subSessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1249 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1250 subWindow->hostSession_ = subSession;
1251 subWindow->property_->SetPersistentId(2);
1252 subWindow->property_->SetParentId(1);
1253 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1254 subWindow->property_->SetIsUIExtFirstSubWindow(true);
1255 sptr<WindowSessionImpl> parentSession = nullptr;
1256 auto res = subWindow->GetParentSessionAndVerify(false, parentSession);
1257 EXPECT_EQ(WMError::WM_OK, res);
1258 subWindow->property_->SetIsUIExtFirstSubWindow(false);
1259 res = subWindow->GetParentSessionAndVerify(false, parentSession);
1260 EXPECT_EQ(WMError::WM_OK, res);
1261 window->property_->SetSubWindowLevel(2);
1262 res = subWindow->GetParentSessionAndVerify(false, parentSession);
1263 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, res);
1264 EXPECT_NE(nullptr, parentSession);
1265 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1266 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1267 }
1268
1269 /**
1270 * @tc.name: MainWindowCloseInner
1271 * @tc.desc: MainWindowCloseInner Test
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(WindowSceneSessionImplTest4, MainWindowCloseInner, TestSize.Level1)
1275 {
1276 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1277 option->SetWindowName("MainWindowCloseInner");
1278 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1279 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1280 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1281 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1282 window->hostSession_ = session;
1283 window->property_->SetPersistentId(1);
1284 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1285 EXPECT_EQ(WMError::WM_OK, window->MainWindowCloseInner());
1286 }
1287
1288 /**
1289 * @tc.name: SetWindowMode01
1290 * @tc.desc: SetWindowMode
1291 * @tc.type: FUNC
1292 */
1293 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode01, TestSize.Level1)
1294 {
1295 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1296 subOption->SetWindowName("SetWindowMode01");
1297 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1298 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1299 subWindow->property_->SetPersistentId(1007);
1300 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1301 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1302 subWindow->hostSession_ = subSession;
1303 subWindow->property_->SetWindowModeSupportType(0);
1304 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1305 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, ret);
1306 }
1307
1308 /**
1309 * @tc.name: SetWindowMode02
1310 * @tc.desc: SetWindowMode
1311 * @tc.type: FUNC
1312 */
1313 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode02, TestSize.Level1)
1314 {
1315 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1316 subOption->SetWindowName("SetWindowMode02");
1317 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1318 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1319 subWindow->property_->SetPersistentId(1007);
1320 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1321 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1322 subWindow->hostSession_ = subSession;
1323 subWindow->property_->SetWindowModeSupportType(1);
1324 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1325 EXPECT_EQ(WMError::WM_OK, ret);
1326 }
1327
1328 /**
1329 * @tc.name: SetWindowMode03
1330 * @tc.desc: SetWindowMode
1331 * @tc.type: FUNC
1332 */
1333 HWTEST_F(WindowSceneSessionImplTest4, SetWindowMode03, TestSize.Level1)
1334 {
1335 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1336 subOption->SetWindowName("SetWindowMode03");
1337 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1338 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1339 subWindow->property_->SetPersistentId(0);
1340 SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility"};
1341 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1342 subWindow->hostSession_ = subSession;
1343 subWindow->property_->SetWindowModeSupportType(1);
1344 auto ret = subWindow->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1345 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1346 }
1347
1348 /**
1349 * @tc.name: UpdateNewSize01
1350 * @tc.desc: UpdateNewSize
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(WindowSceneSessionImplTest4, UpdateNewSize01, TestSize.Level1)
1354 {
1355 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1356 subOption->SetWindowName("UpdateNewSize01SubWindow");
1357 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1358 subWindow->property_->SetPersistentId(1003);
1359 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1360 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1361 subWindow->hostSession_ = subSession;
1362 subWindow->UpdateNewSize();
1363 Rect windowRect = { 0, 0, 0, 0 };
1364 WindowLimits windowLimits = { 0, 0, 0, 0, 0.0, 0, 0 };
1365 subWindow->property_->SetRequestRect(windowRect);
1366 subWindow->property_->SetWindowRect(windowRect);
1367 subWindow->property_->SetWindowLimits(windowLimits);
1368 subWindow->UpdateNewSize();
1369 windowRect.width_ = 10;
1370 windowRect.height_ = 10;
1371 subWindow->UpdateNewSize();
1372 windowRect.width_ = 0;
1373 windowRect.height_ = 0;
1374 ASSERT_NE(nullptr, subWindow->property_);
1375 subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1376 subWindow->UpdateNewSize();
1377 Rect windowRect1 = { 10, 10, 10, 10 };
1378 WindowLimits windowLimits1 = { 100, 100, 100, 100, 0.0, 0, 0 };
1379 subWindow->property_->SetRequestRect(windowRect1);
1380 subWindow->property_->SetWindowLimits(windowLimits1);
1381 subWindow->UpdateNewSize();
1382 Rect windowRect2 = { 200, 200, 200, 200 };
1383 subWindow->property_->SetRequestRect(windowRect2);
1384 subWindow->UpdateNewSize();
1385 }
1386
1387 /**
1388 * @tc.name: UpdateNewSize02
1389 * @tc.desc: UpdateNewSize
1390 * @tc.type: FUNC
1391 */
1392 HWTEST_F(WindowSceneSessionImplTest4, UpdateNewSize02, TestSize.Level1)
1393 {
1394 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1395 subOption->SetWindowName("UpdateNewSize01SubWindow");
1396 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1397 subWindow->property_->SetPersistentId(1003);
1398 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1399 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1400 subWindow->hostSession_ = subSession;
1401 subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1402 WindowLimits windowLimits = { 100, 100, 100, 100, 0.0, 0, 0 };
1403 subWindow->property_->SetWindowLimits(windowLimits);
1404 Rect windowRect = { 200, 200, 200, 200 };
1405 subWindow->property_->SetRequestRect(windowRect);
1406 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::INVALID_WINDOW;
1407 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
1408 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = false;
1409 subWindow->UpdateNewSize();
1410 subWindow->property_->SetRequestRect(windowRect);
1411 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
1412 subWindow->UpdateNewSize();
1413 subWindow->property_->SetRequestRect(windowRect);
1414 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = true;
1415 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = false;
1416 subWindow->UpdateNewSize();
1417 subWindow->property_->SetRequestRect(windowRect);
1418 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
1419 subWindow->UpdateNewSize();
1420 subWindow->property_->SetRequestRect(windowRect);
1421 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1422 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
1423 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = false;
1424 subWindow->UpdateNewSize();
1425 subWindow->property_->SetRequestRect(windowRect);
1426 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
1427 subWindow->UpdateNewSize();
1428 subWindow->property_->SetRequestRect(windowRect);
1429 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = true;
1430 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = false;
1431 subWindow->UpdateNewSize();
1432 subWindow->property_->SetRequestRect(windowRect);
1433 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = false;
1434 subWindow->UpdateNewSize();
1435 ASSERT_NE(nullptr, subWindow->property_);
1436 }
1437
1438 /**
1439 * @tc.name: UpdateSubWindowStateAndNotify01
1440 * @tc.desc: UpdateSubWindowStateAndNotify
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(WindowSceneSessionImplTest4, UpdateSubWindowStateAndNotify01, TestSize.Level1)
1444 {
1445 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1446 subOption->SetWindowName("UpdateSubWindowStateAndNotify01");
1447 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1448 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1449 subWindow->property_->SetPersistentId(1005);
1450 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
1451 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
1452 subWindow->hostSession_ = subSession;
1453
1454 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1455 option->SetWindowName("UpdateSubWindowStateAndNotify02");
1456 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1457 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1458 window->property_->SetPersistentId(1006);
1459 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1460 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1461 window->hostSession_ = session;
1462 std::vector<sptr<WindowSessionImpl>> vec;
1463 WindowSceneSessionImpl::subWindowSessionMap_.insert(
1464 std::pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1006, vec));
1465 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1466 WindowSceneSessionImpl::subWindowSessionMap_[1006].push_back(subWindow);
1467 subWindow->state_ = WindowState::STATE_SHOWN;
1468 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1469 subWindow->state_ = WindowState::STATE_HIDDEN;
1470 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_HIDDEN);
1471 subWindow->state_ = WindowState::STATE_SHOWN;
1472 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1473 subWindow->state_ = WindowState::STATE_SHOWN;
1474 subWindow->UpdateSubWindowStateAndNotify(1006, WindowState::STATE_SHOWN);
1475 ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1476 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1477 }
1478
1479 /**
1480 * @tc.name: PreLayoutOnShow01
1481 * @tc.desc: PreLayoutOnShow
1482 * @tc.type: FUNC
1483 */
1484 HWTEST_F(WindowSceneSessionImplTest4, PreLayoutOnShow01, TestSize.Level1)
1485 {
1486 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1487 option->SetWindowName("PreLayoutOnShow01");
1488 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1489 window->property_->SetPersistentId(2345);
1490 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1491 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1492 window->hostSession_ = nullptr;
1493 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1494 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1495 ASSERT_NE(nullptr, window->uiContent_);
1496 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
1497 window->hostSession_ = session;
1498 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
1499 Rect originRect = window->GetRect();
1500 Rect testRect = {10, 20, 100, 200};
1501 window->GetProperty()->SetRequestRect(testRect);
1502 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT, displayInfo);
1503 ASSERT_EQ(window->GetRect(), originRect);
1504 window->PreLayoutOnShow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, displayInfo);
1505 ASSERT_EQ(window->GetRect(), testRect);
1506 }
1507
1508 /**
1509 * @tc.name: KeepKeyboardOnFocus01
1510 * @tc.desc: KeepKeyboardOnFocus
1511 * @tc.type: FUNC
1512 */
1513 HWTEST_F(WindowSceneSessionImplTest4, KeepKeyboardOnFocus01, TestSize.Level1)
1514 {
1515 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1516 keyboardOption->SetWindowName("KeepKeyboardOnFocus01");
1517 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1518 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1519 keyboardWindow->KeepKeyboardOnFocus(false);
1520 ASSERT_EQ(keyboardWindow->property_->keepKeyboardFlag_, false);
1521
1522 keyboardWindow->KeepKeyboardOnFocus(true);
1523 ASSERT_EQ(keyboardWindow->property_->keepKeyboardFlag_, true);
1524 }
1525
1526 /**
1527 * @tc.name: MoveAndResizeKeyboard01
1528 * @tc.desc: MoveAndResizeKeyboard
1529 * @tc.type: FUNC
1530 */
1531 HWTEST_F(WindowSceneSessionImplTest4, MoveAndResizeKeyboard01, TestSize.Level1)
1532 {
1533 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1534 keyboardOption->SetWindowName("MoveAndResizeKeyboard01");
1535 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1536 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1537
1538 bool isLandscape = false;
1539 keyboardWindow->property_->displayId_ = 0;
1540 auto display = SingletonContainer::Get<DisplayManager>().GetDisplayById(0);
1541 if (display != nullptr) {
1542 isLandscape = display->GetWidth() > display->GetHeight();
1543 }
1544 KeyboardLayoutParams param;
1545 param.LandscapeKeyboardRect_ = { 100, 100, 100, 200 };
1546 param.PortraitKeyboardRect_ = { 200, 200, 200, 100 };
1547 auto result = keyboardWindow->MoveAndResizeKeyboard(param);
1548 auto expectRect = isLandscape ? param.LandscapeKeyboardRect_ : param.PortraitKeyboardRect_;
1549 ASSERT_EQ(keyboardWindow->property_->requestRect_, expectRect);
1550 ASSERT_EQ(result, WMError::WM_OK);
1551 }
1552
1553 /**
1554 * @tc.name: MoveAndResizeKeyboard02
1555 * @tc.desc: MoveAndResizeKeyboard
1556 * @tc.type: FUNC
1557 */
1558 HWTEST_F(WindowSceneSessionImplTest4, MoveAndResizeKeyboard02, TestSize.Level1)
1559 {
1560 sptr<WindowOption> keyboardOption = sptr<WindowOption>::MakeSptr();
1561 keyboardOption->SetWindowName("MoveAndResizeKeyboard02");
1562 keyboardOption->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1563 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(keyboardOption);
1564
1565 bool isLandscape = false;
1566 keyboardWindow->property_->displayId_ = DISPLAY_ID_INVALID;
1567 auto defaultDisplayInfo = DisplayManager::GetInstance().GetDefaultDisplay();
1568 if (defaultDisplayInfo != nullptr) {
1569 isLandscape = defaultDisplayInfo->GetWidth() > defaultDisplayInfo->GetHeight();
1570 }
1571 KeyboardLayoutParams param;
1572 param.LandscapeKeyboardRect_ = { 100, 100, 100, 200 };
1573 param.PortraitKeyboardRect_ = { 200, 200, 200, 100 };
1574 auto result = keyboardWindow->MoveAndResizeKeyboard(param);
1575 auto expectRect = isLandscape ? param.LandscapeKeyboardRect_ : param.PortraitKeyboardRect_;
1576 ASSERT_EQ(keyboardWindow->property_->requestRect_, expectRect);
1577 ASSERT_EQ(result, WMError::WM_OK);
1578 }
1579
CreateWindow(std::string windowName,WindowType type,int32_t id)1580 static sptr<WindowSceneSessionImpl> CreateWindow(std::string windowName, WindowType type, int32_t id)
1581 {
1582 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1583 option->SetWindowName(windowName);
1584 option->SetWindowType(type);
1585 auto window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1586 window->property_->SetPersistentId(id);
1587 return window;
1588 }
1589
1590 /**
1591 * @tc.name: GetParentMainWindowId
1592 * @tc.desc: GetParentMainWindowId
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F(WindowSceneSessionImplTest4, GetParentMainWindowId001, TestSize.Level1)
1596 {
1597 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1598 // toastSubWindow is function caller
1599 sptr<WindowSceneSessionImpl> toastWindow = CreateWindow("toastWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 99);
1600 toastWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
1601 toastWindow->windowSessionMap_["toastWindow"] = SessionPair(toastWindow->GetPersistentId(), toastWindow);
1602 int32_t res = 0;
1603 res = toastWindow->GetParentMainWindowId(0);
1604 ASSERT_EQ(res, 0);
1605
1606 sptr<WindowSceneSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1607 ASSERT_NE(mainWindow, nullptr);
1608 toastWindow->windowSessionMap_["mainWindow"] = SessionPair(mainWindow->GetPersistentId(), mainWindow);
1609 toastWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1610 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1611 ASSERT_EQ(res, mainWindow->GetPersistentId());
1612 res = 0;
1613
1614 sptr<WindowSceneSessionImpl> subWindow = CreateWindow("subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 101);
1615 ASSERT_NE(subWindow, nullptr);
1616 subWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1617 toastWindow->property_->SetParentPersistentId(subWindow->GetPersistentId());
1618 toastWindow->windowSessionMap_["subWindow"] = SessionPair(subWindow->GetPersistentId(), subWindow);
1619 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1620 ASSERT_EQ(res, mainWindow->GetPersistentId());
1621 res = 0;
1622
1623 sptr<WindowSceneSessionImpl> dialogWindow = CreateWindow("dialogWindow", WindowType::WINDOW_TYPE_DIALOG, 102);
1624 ASSERT_NE(dialogWindow, nullptr);
1625 dialogWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1626 toastWindow->property_->SetParentPersistentId(dialogWindow->GetPersistentId());
1627 toastWindow->windowSessionMap_["dialogWindow"] = SessionPair(dialogWindow->GetPersistentId(), dialogWindow);
1628 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1629 ASSERT_EQ(res, mainWindow->GetPersistentId());
1630 res = 0;
1631
1632 sptr<WindowSceneSessionImpl> pipWindow = CreateWindow("dialogWindow", WindowType::WINDOW_TYPE_PIP, 103);
1633 ASSERT_NE(pipWindow, nullptr);
1634 pipWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1635 toastWindow->property_->SetParentPersistentId(pipWindow->GetPersistentId());
1636 toastWindow->windowSessionMap_.insert(std::make_pair(
1637 "dialogWindow", std::pair<uint64_t, sptr<WindowSessionImpl>>(pipWindow->GetPersistentId(), pipWindow)));
1638 res = toastWindow->GetParentMainWindowId(toastWindow->GetPersistentId());
1639 ASSERT_EQ(res, 0);
1640 }
1641
1642 /**
1643 * @tc.name: FindParentMainSession001
1644 * @tc.desc: FindParentMainSession001
1645 * @tc.type: FUNC
1646 */
1647 HWTEST_F(WindowSceneSessionImplTest4, FindParentMainSession001, TestSize.Level1)
1648 {
1649 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1650 // toastSubWindow is function caller
1651 sptr<WindowSceneSessionImpl> toastWindow = CreateWindow("toastWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 99);
1652 toastWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
1653 ASSERT_NE(toastWindow, nullptr);
1654 toastWindow->windowSessionMap_["toastWindow"] = SessionPair(toastWindow->GetPersistentId(), toastWindow);
1655 sptr<WindowSessionImpl> result = nullptr;
1656
1657 result = toastWindow->FindParentMainSession(0, toastWindow->windowSessionMap_);
1658 ASSERT_EQ(result, nullptr);
1659
1660 // mainWindow need to be found
1661 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1662 ASSERT_NE(mainWindow, nullptr);
1663 toastWindow->windowSessionMap_["mainWindow"] = SessionPair(mainWindow->GetPersistentId(), mainWindow);
1664 toastWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1665 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1666 ASSERT_EQ(result, mainWindow);
1667 result = nullptr;
1668
1669 sptr<WindowSessionImpl> subWindow = CreateWindow("subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 101);
1670 ASSERT_NE(subWindow, nullptr);
1671 subWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1672 toastWindow->property_->SetParentPersistentId(subWindow->GetPersistentId());
1673 toastWindow->windowSessionMap_["subWindow"] = SessionPair(subWindow->GetPersistentId(), subWindow);
1674 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1675 ASSERT_EQ(result, mainWindow);
1676 result = nullptr;
1677
1678 sptr<WindowSessionImpl> floatWindow = CreateWindow("floatWindow", WindowType::WINDOW_TYPE_FLOAT, 105);
1679 ASSERT_NE(subWindow, nullptr);
1680 toastWindow->property_->SetParentPersistentId(floatWindow->GetPersistentId());
1681 floatWindow->property_->SetParentPersistentId(0);
1682 toastWindow->windowSessionMap_["floatWindow"] = SessionPair(floatWindow->GetPersistentId(), floatWindow);
1683 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1684 ASSERT_EQ(result, floatWindow);
1685 result = nullptr;
1686
1687 floatWindow->property_->SetParentPersistentId(mainWindow->GetPersistentId());
1688 result = toastWindow->FindParentMainSession(toastWindow->GetParentId(), toastWindow->windowSessionMap_);
1689 ASSERT_EQ(result, mainWindow);
1690 }
1691
1692 /**
1693 * @tc.name: IsPcOrPadFreeMultiWindowMode
1694 * @tc.desc: IsPcOrPadFreeMultiWindowMode
1695 * @tc.type: FUNC
1696 */
1697 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrPadFreeMultiWindowMode, TestSize.Level1)
1698 {
1699 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1700 ASSERT_NE(mainWindow, nullptr);
1701 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1702 ASSERT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
1703 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1704 ASSERT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
1705 }
1706
1707 /**
1708 * @tc.name: IsPcOrPadFreeMultiWindowMode
1709 * @tc.desc: uitype = padwindow
1710 * @tc.type: FUNC
1711 */
1712 HWTEST_F(WindowSceneSessionImplTest4, IsPcOrPadFreeMultiWindowMode002, TestSize.Level1)
1713 {
1714 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1715 ASSERT_NE(mainWindow, nullptr);
1716 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1717 mainWindow->SetFreeMultiWindowMode(true);
1718 ASSERT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
1719 mainWindow->SetFreeMultiWindowMode(false);
1720 ASSERT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
1721 }
1722
CreateWindowWithDisplayId(std::string windowName,WindowType type,int64_t displayId=DISPLAY_ID_INVALID,uint32_t parentId=INVALID_WINDOW_ID)1723 static sptr<WindowSceneSessionImpl> CreateWindowWithDisplayId(std::string windowName,
1724 WindowType type,
1725 int64_t displayId = DISPLAY_ID_INVALID,
1726 uint32_t parentId = INVALID_WINDOW_ID)
1727 {
1728 using SessionPair = std::pair<uint64_t, sptr<WindowSessionImpl>>;
1729 static uint32_t windowPersistentId = 106;
1730 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1731 option->SetWindowName(windowName);
1732 option->SetWindowType(type);
1733 option->SetParentId(parentId);
1734 option->SetDisplayId(displayId);
1735 auto window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1736 window->property_->SetPersistentId(windowPersistentId++);
1737 WindowSessionImpl::windowSessionMap_[std::move(windowName)] = SessionPair(window->GetPersistentId(), window);
1738 return window;
1739 }
1740
1741 /**
1742 * @tc.name: SetSpecificDisplayId01
1743 * @tc.desc: SetSpecificDisplayId01
1744 * @tc.type: FUNC
1745 */
1746 HWTEST_F(WindowSceneSessionImplTest4, SetSpecificDisplayId01, TestSize.Level1)
1747 {
1748 // create main window
1749 int64_t displayId = 12;
1750 auto mainWindowContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1751 sptr<WindowSceneSessionImpl> mainWindow =
1752 CreateWindowWithDisplayId("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, displayId);
1753 mainWindow->context_ = mainWindowContext;
1754 // create sub window
1755 sptr<WindowSceneSessionImpl> subWindow = CreateWindowWithDisplayId(
1756 "subWindow", WindowType::WINDOW_TYPE_APP_SUB_WINDOW, DISPLAY_ID_INVALID, mainWindow->GetPersistentId());
1757
1758 // create float window
1759 sptr<WindowSceneSessionImpl> floatWindow = CreateWindowWithDisplayId("floatWindow", WindowType::WINDOW_TYPE_FLOAT);
1760 floatWindow->context_ = mainWindow->context_;
1761 // create other window
1762 uint64_t globalSearchDisplayId = 5678;
1763 sptr<WindowSceneSessionImpl> globalSearchWindow =
1764 CreateWindowWithDisplayId("globalWindow", WindowType::WINDOW_TYPE_GLOBAL_SEARCH, globalSearchDisplayId);
1765 // test display id
1766 subWindow->CreateAndConnectSpecificSession();
1767 ASSERT_EQ(subWindow->property_->GetDisplayId(), displayId);
1768 floatWindow->CreateSystemWindow(WindowType::WINDOW_TYPE_FLOAT);
1769 ASSERT_EQ(floatWindow->property_->GetDisplayId(), displayId);
1770 globalSearchWindow->CreateSystemWindow(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1771 ASSERT_EQ(globalSearchWindow->property_->GetDisplayId(), globalSearchDisplayId);
1772 floatWindow->CreateSystemWindow(WindowType::WINDOW_TYPE_FB);
1773 ASSERT_EQ(floatWindow->property_->GetDisplayId(), displayId);
1774 }
1775
1776 /**
1777 * @tc.name: SetFullScreenWaterfallMode
1778 * @tc.desc: test SetFullScreenWaterfallMode
1779 * @tc.type: FUNC
1780 */
1781 HWTEST_F(WindowSceneSessionImplTest4, SetFullScreenWaterfallMode, TestSize.Level1)
1782 {
1783 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1784 option->SetWindowName("SetFullScreenWaterfallMode");
1785 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1786 window->property_->windowMode_ = WindowMode::WINDOW_MODE_FULLSCREEN;
1787 EXPECT_EQ(WSError::WS_OK, window->SetFullScreenWaterfallMode(true));
1788 EXPECT_EQ(WSError::WS_DO_NOTHING, window->SetFullScreenWaterfallMode(true));
1789 EXPECT_TRUE(window->isFullScreenWaterfallMode_.load());
1790 EXPECT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->lastWindowModeBeforeWaterfall_.load());
1791 EXPECT_EQ(WSError::WS_OK, window->SetFullScreenWaterfallMode(false));
1792 EXPECT_FALSE(window->isFullScreenWaterfallMode_.load());
1793 EXPECT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->lastWindowModeBeforeWaterfall_.load());
1794 }
1795
1796 /**
1797 * @tc.name: SetSupportEnterWaterfallMode
1798 * @tc.desc: test SetSupportEnterWaterfallMode
1799 * @tc.type: FUNC
1800 */
1801 HWTEST_F(WindowSceneSessionImplTest4, SetSupportEnterWaterfallMode, TestSize.Level1)
1802 {
1803 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1804 option->SetWindowName("SetSupportEnterWaterfallMode");
1805 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1806 ASSERT_EQ(WSError::WS_OK, window->SetSupportEnterWaterfallMode(true));
1807 }
1808
1809 /**
1810 * @tc.name: OnContainerModalEvent
1811 * @tc.desc: test OnContainerModalEvent
1812 * @tc.type: FUNC
1813 */
1814 HWTEST_F(WindowSceneSessionImplTest4, OnContainerModalEvent, TestSize.Level1)
1815 {
1816 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1817 option->SetWindowName("OnContainerModalEvent");
1818 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1819 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->OnContainerModalEvent("not_waterfall_window_event", ""));
1820 }
1821
1822 /**
1823 * @tc.name: UpdateConfigurationSyncForAll
1824 * @tc.desc: UpdateConfigurationSyncForAll
1825 * @tc.type: FUNC
1826 */
1827 HWTEST_F(WindowSceneSessionImplTest4, UpdateConfigurationSyncForAll, TestSize.Level1)
1828 {
1829 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1830 option->SetWindowName("UpdateConfigurationSyncForAll");
1831 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1832
1833 std::shared_ptr<AppExecFwk::Configuration> configuration = std::make_shared<AppExecFwk::Configuration>();
1834 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1835 SessionInfo sessionInfo = { "CreateTestBundle1", "CreateTestModule1", "CreateTestAbility1" };
1836 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1837 windowSession->hostSession_ = session;
1838 windowSession->property_->SetPersistentId(1);
1839 windowSession->state_ = WindowState::STATE_SHOWN;
1840 ASSERT_EQ(WMError::WM_OK, windowSession->Create(abilityContext_, session));
1841 windowSceneSessionImpl->UpdateConfigurationSyncForAll(configuration);
1842 ASSERT_EQ(WMError::WM_OK, windowSession->Destroy(true));
1843 }
1844
1845 /**
1846 * @tc.name: NotifyDrawingCompleted
1847 * @tc.desc: NotifyDrawingCompleted
1848 * @tc.type: FUNC
1849 */
1850 HWTEST_F(WindowSceneSessionImplTest4, NotifyDrawingCompleted, TestSize.Level1)
1851 {
1852 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1853 option->SetWindowName("NotifyDrawingCompleted");
1854 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1855 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1856 windowSessionImpl->hostSession_ = nullptr;
1857 auto ret = window->NotifyDrawingCompleted();
1858 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1859 }
1860
1861 /**
1862 * @tc.name: NotifyDrawingCompleted01
1863 * @tc.desc: NotifyDrawingCompleted
1864 * @tc.type: FUNC
1865 */
1866 HWTEST_F(WindowSceneSessionImplTest4, NotifyDrawingCompleted01, TestSize.Level1)
1867 {
1868 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1869 option->SetWindowName("NotifyDrawingCompleted01");
1870 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1871 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1872 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1873 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1874 windowSessionImpl->hostSession_ = session;
1875 WindowSessionProperty windowSessionProperty;
1876 windowSessionProperty.SetPersistentId(1);
1877
1878 auto ret = window->NotifyDrawingCompleted();
1879 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1880 }
1881
1882 /**
1883 * @tc.name: MoveTo
1884 * @tc.desc: MoveTo
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F(WindowSceneSessionImplTest4, MoveTo, TestSize.Level1)
1888 {
1889 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1890 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1891 option->SetWindowName("MoveTo");
1892 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1893 MoveConfiguration moveConfiguration;
1894
1895 windowSessionImpl->hostSession_ = nullptr;
1896 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1897 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1898
1899 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1900 ret = window->MoveTo(0, 0, true, moveConfiguration);
1901 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1902
1903 windowSessionImpl->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
1904 window->MoveTo(0, 0, true, moveConfiguration);
1905 }
1906
1907 /**
1908 * @tc.name: MoveTo
1909 * @tc.desc: MoveTo
1910 * @tc.type: FUNC
1911 */
1912 HWTEST_F(WindowSceneSessionImplTest4, MoveTo002, TestSize.Level1)
1913 {
1914 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1915 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1916 option->SetWindowName("MoveTo002");
1917 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1918 MoveConfiguration moveConfiguration;
1919 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1920
1921 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1922 window->state_ = WindowState::STATE_INITIAL;
1923 window->property_->SetPersistentId(1);
1924 ret = window->MoveTo(0, 0, true, moveConfiguration);
1925 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1926 }
1927
1928 /**
1929 * @tc.name: MoveTo
1930 * @tc.desc: MoveTo
1931 * @tc.type: FUNC
1932 */
1933 HWTEST_F(WindowSceneSessionImplTest4, MoveTo003, TestSize.Level1)
1934 {
1935 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1936 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
1937 option->SetWindowName("MoveTo002");
1938 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1939 MoveConfiguration moveConfiguration;
1940 auto ret = window->MoveTo(0, 0, true, moveConfiguration);
1941
1942 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1943 window->state_ = WindowState::STATE_INITIAL;
1944 ret = window->MoveTo(0, 0, true, moveConfiguration);
1945 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1946
1947 windowSessionImpl->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
1948 int64_t displayId = 12;
1949 auto mainWindowContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1950 sptr<WindowSceneSessionImpl> mainWindow =
1951 CreateWindowWithDisplayId("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, displayId);
1952 mainWindow->context_ = mainWindowContext;
1953 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1954 ret = window->MoveTo(0, 0, true, moveConfiguration);
1955 ASSERT_EQ(ret, WMError::WM_OK);
1956 }
1957
1958 /**
1959 * @tc.name: MoveWindowToGlobal
1960 * @tc.desc: MoveWindowToGlobal
1961 * @tc.type: FUNC
1962 */
1963 HWTEST_F(WindowSceneSessionImplTest4, MoveWindowToGlobal, TestSize.Level1)
1964 {
1965 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1966 option->SetWindowName("MoveWindowToGlobal");
1967 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1968
1969 MoveConfiguration moveConfiguration;
1970 window->hostSession_ = nullptr;
1971 auto ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
1972 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1973
1974 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1975 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1976
1977 window->hostSession_ = session;
1978 window->property_->SetPersistentId(1);
1979 window->state_ = WindowState::STATE_INITIAL;
1980
1981 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1982 ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
1983 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS);
1984
1985 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1986 window->MoveWindowToGlobal(0, 0, moveConfiguration);
1987 }
1988
1989 /**
1990 * @tc.name: MoveWindowToGlobal01
1991 * @tc.desc: MoveWindowToGlobal
1992 * @tc.type: FUNC
1993 */
1994 HWTEST_F(WindowSceneSessionImplTest4, MoveWindowToGlobal01, TestSize.Level1)
1995 {
1996 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1997 option->SetWindowName("MoveWindowToGlobal01");
1998 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1999
2000 MoveConfiguration moveConfiguration;
2001 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2002 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2003 window->hostSession_ = session;
2004 window->property_->SetPersistentId(1);
2005 window->state_ = WindowState::STATE_INITIAL;
2006 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2007 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
2008
2009 auto ret = window->MoveWindowToGlobal(0, 0, moveConfiguration);
2010 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
2011 }
2012
2013 /**
2014 * @tc.name: OnContainerModalEvent01
2015 * @tc.desc: OnContainerModalEvent
2016 * @tc.type: FUNC
2017 */
2018 HWTEST_F(WindowSceneSessionImplTest4, OnContainerModalEvent01, TestSize.Level1)
2019 {
2020 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2021 option->SetWindowName("VerifySubWindowLevel01");
2022 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2023
2024 std::string eventName = "window_scene_session_impl_test4";
2025 std::string value = "window_scene_session_impl_test4";
2026 auto ret = window->OnContainerModalEvent(eventName, value);
2027 ASSERT_EQ(WMError::WM_DO_NOTHING, ret);
2028
2029 eventName = "scb_waterfall_window_event";
2030 window->hostSession_ = nullptr;
2031 ret = window->OnContainerModalEvent(eventName, value);
2032 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
2033 }
2034
2035 /**
2036 * @tc.name: IsSystemDensityChanged01
2037 * @tc.desc: IsSystemDensityChanged
2038 * @tc.type: FUNC
2039 */
2040 HWTEST_F(WindowSceneSessionImplTest4, IsSystemDensityChanged01, TestSize.Level1)
2041 {
2042 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2043 option->SetWindowName("IsSystemDensityChanged01");
2044 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2045
2046 auto displayInfo = sptr<DisplayInfo>::MakeSptr();
2047 displayInfo->SetVirtualPixelRatio(1.5f);
2048 auto ret = window->IsSystemDensityChanged(displayInfo);
2049 ASSERT_EQ(true, ret);
2050
2051 window->lastSystemDensity_ = 1.5f;
2052 ret = window->IsSystemDensityChanged(displayInfo);
2053 ASSERT_EQ(false, ret);
2054 }
2055
2056 /**
2057 * @tc.name: GetWindowPropertyInfo
2058 * @tc.desc: GetWindowPropertyInfo01
2059 * @tc.type: FUNC
2060 */
2061 HWTEST_F(WindowSceneSessionImplTest4, GetWindowPropertyInfo01, TestSize.Level1)
2062 {
2063 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2064 option->SetFocusable(false);
2065 option->SetTouchable(true);
2066 option->SetDisplayId(999);
2067 option->SetWindowName("GetWindowPropertyInfo01");
2068 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2069 window->hostSession_ = nullptr;
2070 WindowPropertyInfo windowPropertyInfo;
2071 auto ret = window->GetWindowPropertyInfo(windowPropertyInfo);
2072 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
2073 }
2074
2075 /**
2076 * @tc.name: GetWindowPropertyInfo
2077 * @tc.desc: GetWindowPropertyInfo02
2078 * @tc.type: FUNC
2079 */
2080 HWTEST_F(WindowSceneSessionImplTest4, GetWindowPropertyInfo02, TestSize.Level1)
2081 {
2082 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2083 option->SetFocusable(false);
2084 option->SetTouchable(true);
2085 option->SetDisplayId(999);
2086 option->SetWindowName("GetWindowPropertyInfo02");
2087 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2088 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2089 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2090 window->property_->SetPersistentId(1);
2091 window->hostSession_ = session;
2092 window->state_ = WindowState::STATE_SHOWN;
2093 WindowPropertyInfo windowPropertyInfo;
2094 auto ret = window->GetWindowPropertyInfo(windowPropertyInfo);
2095 EXPECT_EQ(WMError::WM_OK, ret);
2096 EXPECT_EQ(false, windowPropertyInfo.isFocusable);
2097 EXPECT_EQ(true, windowPropertyInfo.isTouchable);
2098 EXPECT_EQ(999, windowPropertyInfo.displayId);
2099 }
2100
2101 /**
2102 * @tc.name: SetWindowContainerColor01
2103 * @tc.desc: SetWindowContainerColor
2104 * @tc.type: FUNC
2105 */
2106 HWTEST_F(WindowSceneSessionImplTest4, SetWindowContainerColor01, TestSize.Level1)
2107 {
2108 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2109 option->SetBundleName("SetWindowContainerColor");
2110 option->SetWindowName("SetWindowContainerColor");
2111 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2112 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2113 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
2114 std::string activeColor = "#00000000";
2115 std::string inactiveColor = "#FF000000";
2116 WMError res = window->SetWindowContainerColor(activeColor, inactiveColor);
2117 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
2118
2119 window->containerColorList_.insert("SetWindowContainerColor");
2120 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2121 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2122 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2123
2124 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2125 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2126 window->property_->SetPersistentId(1);
2127 window->hostSession_ = session;
2128 window->state_ = WindowState::STATE_SHOWN;
2129 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2130 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
2131
2132 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
2133 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2134 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2135
2136 window->property_->SetDecorEnable(true);
2137 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
2138 window->windowSystemConfig_.isSystemDecorEnable_ = true;
2139 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2140 EXPECT_EQ(res, WMError::WM_ERROR_NULLPTR);
2141
2142 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2143 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2144 EXPECT_EQ(res, WMError::WM_OK);
2145
2146 inactiveColor = "#F1000000";
2147 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2148 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARAM);
2149
2150 inactiveColor = "rgb#FF000000";
2151 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2152 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARAM);
2153
2154 activeColor = "rgb#00000000";
2155 res = window->SetWindowContainerColor(activeColor, inactiveColor);
2156 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARAM);
2157 }
2158
2159 /**
2160 * @tc.name: SetWindowContainerModalColor01
2161 * @tc.desc: SetWindowContainerModalColor
2162 * @tc.type: FUNC
2163 */
2164 HWTEST_F(WindowSceneSessionImplTest4, SetWindowContainerModalColor01, TestSize.Level1)
2165 {
2166 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2167 option->SetBundleName("SetWindowContainerModalColor");
2168 option->SetWindowName("SetWindowContainerModalColor");
2169 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2170 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2171 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
2172 std::string activeColor = "#FF000000";
2173 std::string inactiveColor = "#00000000";
2174 WMError res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2175 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
2176
2177 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2178 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2179 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2180
2181 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2182 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2183 window->property_->SetPersistentId(1);
2184 window->hostSession_ = session;
2185 window->state_ = WindowState::STATE_SHOWN;
2186 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2187 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
2188
2189 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
2190 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2191 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2192
2193 window->property_->SetDecorEnable(true);
2194 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
2195 window->windowSystemConfig_.isSystemDecorEnable_ = true;
2196 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2197 EXPECT_EQ(res, WMError::WM_ERROR_NULLPTR);
2198
2199 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2200 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2201 EXPECT_EQ(res, WMError::WM_OK);
2202
2203 inactiveColor = "rgb#FF000000";
2204 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2205 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARAM);
2206
2207 activeColor = "rgb#00000000";
2208 res = window->SetWindowContainerModalColor(activeColor, inactiveColor);
2209 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARAM);
2210 }
2211 } // namespace
2212 } // namespace Rosen
2213 } // namespace OHOS