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 "application_context.h"
19 #include "ability_context_impl.h"
20 #include "common_test_utils.h"
21 #include "display_info.h"
22 #include "mock_session.h"
23 #include "mock_uicontent.h"
24 #include "mock_window.h"
25 #include "mock_window_adapter.h"
26 #include "pointer_event.h"
27 #include "scene_board_judgement.h"
28 #include "singleton_mocker.h"
29 #include "wm_common_inner.h"
30 #include "window_scene_session_impl.h"
31 #include "window_session_impl.h"
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Rosen {
37 namespace {
38 using WindowAdapterMocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
39 }
40 class WindowSceneSessionImplTest5 : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 };
47
SetUpTestCase()48 void WindowSceneSessionImplTest5::SetUpTestCase() {}
49
TearDownTestCase()50 void WindowSceneSessionImplTest5::TearDownTestCase() {}
51
SetUp()52 void WindowSceneSessionImplTest5::SetUp() {}
53
TearDown()54 void WindowSceneSessionImplTest5::TearDown() {}
55
56 namespace {
57 /**
58 * @tc.name: IgnoreClickEvent
59 * @tc.desc: IgnoreClickEvent
60 * @tc.type: FUNC
61 */
62 HWTEST_F(WindowSceneSessionImplTest5, IgnoreClickEvent, TestSize.Level1)
63 {
64 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
65 ASSERT_NE(nullptr, option);
66 option->SetWindowName("IgnoreClickEvent");
67 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
68 ASSERT_NE(nullptr, window);
69
70 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
71 ASSERT_NE(pointerEvent, nullptr);
72 pointerEvent->SetPointerAction(1);
73 window->IgnoreClickEvent(pointerEvent);
74
75 pointerEvent->SetPointerAction(4);
76 window->IgnoreClickEvent(pointerEvent);
77
78 window->isOverTouchSlop_ = true;
79 MMI::PointerEvent::PointerItem pointerItem;
80 pointerEvent->pointers_.clear();
81 pointerEvent->pointers_.push_back(pointerItem);
82 window->IgnoreClickEvent(pointerEvent);
83
84 window->isOverTouchSlop_ = false;
85 ASSERT_EQ(pointerEvent->GetPointerAction(), MMI::PointerEvent::POINTER_ACTION_CANCEL);
86 window->IgnoreClickEvent(pointerEvent);
87 }
88
89 /**
90 * @tc.name: HandleUpForCompatibleMode
91 * @tc.desc: HandleUpForCompatibleMode
92 * @tc.type: FUNC
93 */
94 HWTEST_F(WindowSceneSessionImplTest5, HandleUpForCompatibleMode, TestSize.Level1)
95 {
96 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
97 ASSERT_NE(nullptr, option);
98 option->SetWindowName("HandleUpForCompatibleMode");
99 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
100 ASSERT_NE(nullptr, window);
101
102 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
103 ASSERT_NE(pointerEvent, nullptr);
104 MMI::PointerEvent::PointerItem pointerItem;
105 window->HandleUpForCompatibleMode(pointerEvent, pointerItem);
106
107 window->isDown_ = true;
108 window->eventMapTriggerByDisplay_.clear();
109 window->eventMapTriggerByDisplay_.insert(std::pair<int32_t, std::vector<bool>>(-2, { true }));
110 window->HandleUpForCompatibleMode(pointerEvent, pointerItem);
111 }
112
113 /**
114 * @tc.name: HandleMoveForCompatibleMode
115 * @tc.desc: HandleMoveForCompatibleMode
116 * @tc.type: FUNC
117 */
118 HWTEST_F(WindowSceneSessionImplTest5, HandleMoveForCompatibleMode, TestSize.Level1)
119 {
120 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
121 ASSERT_NE(nullptr, option);
122 option->SetWindowName("HandleMoveForCompatibleMode");
123 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
124 ASSERT_NE(nullptr, window);
125
126 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
127 ASSERT_NE(pointerEvent, nullptr);
128 MMI::PointerEvent::PointerItem pointerItem;
129 window->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
130
131 window->isDown_ = true;
132 window->eventMapTriggerByDisplay_.clear();
133 window->eventMapTriggerByDisplay_.insert(std::pair<int32_t, std::vector<bool>>(-2, { true }));
134 window->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
135 }
136
137 /**
138 * @tc.name: HandleDownForCompatibleMode
139 * @tc.desc: HandleDownForCompatibleMode
140 * @tc.type: FUNC
141 */
142 HWTEST_F(WindowSceneSessionImplTest5, HandleDownForCompatibleMode, TestSize.Level1)
143 {
144 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
145 ASSERT_NE(nullptr, option);
146 option->SetWindowName("HandleDownForCompatibleMode");
147 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
148 ASSERT_NE(nullptr, window);
149
150 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
151 ASSERT_NE(pointerEvent, nullptr);
152 MMI::PointerEvent::PointerItem pointerItem;
153 window->HandleDownForCompatibleMode(pointerEvent, pointerItem);
154
155 pointerEvent->pointers_.clear();
156 window->HandleDownForCompatibleMode(pointerEvent, pointerItem);
157
158 pointerEvent->pointers_.push_back(pointerItem);
159 sptr<DisplayInfo> displayInfo = nullptr;
160 auto ret = window->GetVirtualPixelRatio(displayInfo);
161 ASSERT_EQ(ret, 1.0f);
162 }
163
164 /**
165 * @tc.name: Maximize
166 * @tc.desc: Maximize
167 * @tc.type: FUNC
168 */
169 HWTEST_F(WindowSceneSessionImplTest5, Maximize, TestSize.Level1)
170 {
171 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
172 ASSERT_NE(nullptr, option);
173 option->SetWindowName("Maximize");
174 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
175 ASSERT_NE(nullptr, window);
176
177 window->hostSession_ = nullptr;
178 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
179 auto ret = window->Maximize(presentation);
180 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
181 }
182
183 /**
184 * @tc.name: Maximize01
185 * @tc.desc: Maximize
186 * @tc.type: FUNC
187 */
188 HWTEST_F(WindowSceneSessionImplTest5, Maximize01, TestSize.Level1)
189 {
190 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
191 ASSERT_NE(nullptr, option);
192 option->SetWindowName("Maximize");
193 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
194 ASSERT_NE(nullptr, window);
195
196 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
197 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
198 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
199 window->hostSession_ = session;
200 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
201 window->state_ = WindowState::STATE_CREATED;
202
203 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
204 auto ret = window->Maximize(presentation);
205 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
206
207 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
208 window->property_->SetWindowModeSupportType(0);
209 ret = window->Maximize(presentation);
210 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
211
212 window->property_->SetWindowModeSupportType(1);
213 SystemSessionConfig systemSessionConfig;
214 systemSessionConfig.windowUIType_ = WindowUIType::INVALID_WINDOW;
215 ret = window->Maximize(presentation);
216 ASSERT_EQ(ret, WMError::WM_OK);
217 }
218
219 /**
220 * @tc.name: Maximize02
221 * @tc.desc: Maximize
222 * @tc.type: FUNC
223 */
224 HWTEST_F(WindowSceneSessionImplTest5, Maximize02, TestSize.Level1)
225 {
226 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
227 ASSERT_NE(nullptr, option);
228 option->SetWindowName("Maximize");
229 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
230 ASSERT_NE(nullptr, window);
231
232 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
233 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
234 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
235 window->hostSession_ = session;
236 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
237 window->state_ = WindowState::STATE_CREATED;
238 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
239 window->property_->SetWindowModeSupportType(1);
240 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
241
242 presentation = MaximizePresentation::ENTER_IMMERSIVE;
243 auto ret = window->Maximize(presentation);
244 ASSERT_EQ(ret, WMError::WM_OK);
245
246 ASSERT_EQ(window->enableImmersiveMode_, true);
247
248 presentation = MaximizePresentation::EXIT_IMMERSIVE;
249 window->Maximize(presentation);
250 ASSERT_EQ(window->enableImmersiveMode_, false);
251
252 presentation = MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER;
253 window->Maximize(presentation);
254 ASSERT_EQ(window->enableImmersiveMode_, true);
255
256 presentation = MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING;
257 window->Maximize(presentation);
258 }
259
260 /**
261 * @tc.name: MoveWindowToGlobal
262 * @tc.desc: MoveWindowToGlobal
263 * @tc.type: FUNC
264 */
265 HWTEST_F(WindowSceneSessionImplTest5, MoveWindowToGlobal, TestSize.Level1)
266 {
267 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
268 ASSERT_NE(nullptr, option);
269 option->SetWindowName("MoveWindowToGlobal");
270 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
271 ASSERT_NE(nullptr, window);
272
273 window->hostSession_ = nullptr;
274 MoveConfiguration presentation;
275 auto ret = window->MoveWindowToGlobal(1, 1, presentation);
276 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
277 }
278
279 /**
280 * @tc.name: MoveWindowToGlobal01
281 * @tc.desc: MoveWindowToGlobal
282 * @tc.type: FUNC
283 */
284 HWTEST_F(WindowSceneSessionImplTest5, MoveWindowToGlobal01, TestSize.Level1)
285 {
286 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
287 ASSERT_NE(nullptr, option);
288 option->SetWindowName("Maximize");
289 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
290 ASSERT_NE(nullptr, window);
291
292 MoveConfiguration presentation;
293 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
294 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
295 window->hostSession_ = session;
296 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
297 window->state_ = WindowState::STATE_CREATED;
298
299 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
300 auto ret = window->MoveWindowToGlobal(1, 1, presentation);
301 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS);
302
303 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
304 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
305 ret = window->MoveWindowToGlobal(1, 1, presentation);
306 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
307
308 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
309 window->MoveWindowToGlobal(1, 1, presentation);
310
311 window->state_ = WindowState::STATE_SHOWN;
312 ret = window->MoveWindowToGlobal(1, 1, presentation);
313 ASSERT_EQ(ret, WMError::WM_OK);
314 }
315
316 /**
317 * @tc.name: TestDefaultDisplayId
318 * @tc.desc: test function: SetDefaultDisplayIdIfNee
319 * @tc.desc: test function: SetIsFollowParentWindowDisplayId
320 * @tc.desc: test function: IsFollowParentWindowDisplayId
321 * @tc.type: FUNC
322 */
323 HWTEST_F(WindowSceneSessionImplTest5, TestDefaultDisplayId, TestSize.Level1)
324 {
325 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
326 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
327 window->property_->SetDisplayId(DISPLAY_ID_INVALID);
328 window->SetDefaultDisplayIdIfNeed();
329 auto ret = window->property_->IsFollowParentWindowDisplayId();
330 EXPECT_EQ(true, ret);
331
332 window->property_->SetIsFollowParentWindowDisplayId(false);
333 ret = window->property_->IsFollowParentWindowDisplayId();
334 EXPECT_EQ(false, ret);
335 }
336
337 /**
338 * @tc.name: SetCustomDensity01
339 * @tc.desc: SetCustomDensity
340 * @tc.type: FUNC
341 */
342 HWTEST_F(WindowSceneSessionImplTest5, SetCustomDensity01, TestSize.Level1)
343 {
344 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
345 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
346 float density = 0.4f;
347 bool applyToSubWindow = false;
348 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetCustomDensity(density, applyToSubWindow));
349
350 window->property_->SetPersistentId(1);
351 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
352 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
353 ASSERT_NE(nullptr, session);
354 window->hostSession_ = session;
355 window->property_->SetWindowName("SetCustomDensity01");
356 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
357 window->state_ = WindowState::STATE_CREATED;
358 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetCustomDensity(density, applyToSubWindow));
359
360 density = 1.5f;
361 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
362 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetCustomDensity(density, applyToSubWindow));
363
364 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
365 EXPECT_EQ(WMError::WM_OK, window->SetCustomDensity(density, applyToSubWindow));
366 EXPECT_EQ(density, window->customDensity_);
367 applyToSubWindow = true;
368 EXPECT_EQ(WMError::WM_OK, window->SetCustomDensity(density, applyToSubWindow));
369
370 sptr<WindowSceneSessionImpl> window1;
371 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
372 std::pair<uint64_t, sptr<WindowSessionImpl>>(1, window)));
373 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair("winTest",
374 std::pair<uint64_t, sptr<WindowSessionImpl>>(2, window1)));
375 EXPECT_EQ(WMError::WM_OK, window->SetCustomDensity(density, applyToSubWindow));
376 EXPECT_EQ(WMError::WM_OK, window->SetCustomDensity(1.6f, false));
377 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
378 WindowSceneSessionImpl::windowSessionMap_.erase("winTest");
379 }
380
381 /**
382 * @tc.name: IsDefaultDensityEnabled01
383 * @tc.desc: IsDefaultDensityEnabled
384 * @tc.type: FUNC
385 */
386 HWTEST_F(WindowSceneSessionImplTest5, IsDefaultDensityEnabled01, TestSize.Level1)
387 {
388 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
389 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
390 window->property_->SetPersistentId(1);
391 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
392 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
393 window->hostSession_ = session;
394 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
395 window->SetDefaultDensityEnabled(true);
396 EXPECT_EQ(true, window->GetDefaultDensityEnabled());
397 window->SetDefaultDensityEnabled(false);
398 EXPECT_EQ(false, window->GetDefaultDensityEnabled());
399 }
400
401 /**
402 * @tc.name: IsDefaultDensityEnabled02
403 * @tc.desc: IsDefaultDensityEnabled
404 * @tc.type: FUNC
405 */
406 HWTEST_F(WindowSceneSessionImplTest5, IsDefaultDensityEnabled02, TestSize.Level1)
407 {
408 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
409 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
410 window->property_->SetPersistentId(1);
411 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
412 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
413 window->hostSession_ = session;
414 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
415 EXPECT_EQ(false, window->GetDefaultDensityEnabled());
416 window->isEnableDefaultDensityWhenCreate_ = true;
417 EXPECT_EQ(window->IsDefaultDensityEnabled(), true);
418 }
419
420
421 /**
422 * @tc.name: GetCustomDensity01
423 * @tc.desc: GetCustomDensity
424 * @tc.type: FUNC
425 */
426 HWTEST_F(WindowSceneSessionImplTest5, GetCustomDensity01, TestSize.Level1)
427 {
428 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
429 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
430 window->property_->SetPersistentId(1);
431 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
432 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
433 window->hostSession_ = session;
434 window->property_->SetWindowName("SetCustomDensity01");
435 window->state_ = WindowState::STATE_CREATED;
436 float density = 1.5f;
437 window->SetCustomDensity(density, false);
438 EXPECT_EQ(density, window->GetCustomDensity());
439 }
440
441 /**
442 * @tc.name: GetMainWindowCustomDensity02
443 * @tc.desc: GetMainWindowCustomDensity
444 * @tc.type: FUNC
445 */
446 HWTEST_F(WindowSceneSessionImplTest5, GetMainWindowCustomDensity01, TestSize.Level1)
447 {
448 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
449 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
450 window->property_->SetPersistentId(1);
451 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
452 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
453 window->hostSession_ = session;
454 window->property_->SetWindowName("SetCustomDensity01");
455 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
456 window->state_ = WindowState::STATE_CREATED;
457 float density = 1.5f;
458 window->SetCustomDensity(density, false);
459 EXPECT_EQ(density, window->GetMainWindowCustomDensity());
460 }
461
462 /**
463 * @tc.name: GetWindowDensityInfo01
464 * @tc.desc: GetWindowDensityInfo
465 * @tc.type: FUNC
466 */
467 HWTEST_F(WindowSceneSessionImplTest5, GetWindowDensityInfo01, TestSize.Level1)
468 {
469 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
470 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
471 WindowDensityInfo densityInfo;
472 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetWindowDensityInfo(densityInfo));
473
474 window->property_->SetPersistentId(1);
475 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
476 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
477 ASSERT_NE(nullptr, session);
478 window->hostSession_ = session;
479 window->property_->SetWindowName("GetWindowDensityInfo01");
480 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
481 window->state_ = WindowState::STATE_CREATED;
482 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->GetWindowDensityInfo(densityInfo));
483 }
484
485 /**
486 * @tc.name: IsMainWindowFullScreenAcrossDisplays01
487 * @tc.desc: IsMainWindowFullScreenAcrossDisplays
488 * @tc.type: FUNC
489 */
490 HWTEST_F(WindowSceneSessionImplTest5, IsMainWindowFullScreenAcrossDisplays01, TestSize.Level1)
491 {
492 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
493 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
494 bool isAcrossDisplays = false;
495 window->hostSession_ = nullptr;
496 auto ret = window->IsMainWindowFullScreenAcrossDisplays(isAcrossDisplays);
497 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
498
499 window->property_->SetPersistentId(1);
500 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
501 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
502 ASSERT_NE(nullptr, session);
503 window->hostSession_ = session;
504 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
505 window->state_ = WindowState::STATE_CREATED;
506 ret = window->IsMainWindowFullScreenAcrossDisplays(isAcrossDisplays);
507 EXPECT_EQ(WMError::WM_OK, ret);
508 }
509
510 /**
511 * @tc.name: SwitchFreeMultiWindow01
512 * @tc.desc: SwitchFreeMultiWindow
513 * @tc.type: FUNC
514 */
515 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow01, TestSize.Level1)
516 {
517 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
518 ASSERT_NE(nullptr, option);
519 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
520 ASSERT_NE(nullptr, window);
521 auto ref = window->SwitchFreeMultiWindow(false);
522 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ref);
523
524 window->property_->SetPersistentId(1);
525 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
526 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
527 window->hostSession_ = session;
528 window->property_->SetWindowName("SwitchFreeMultiWindow01");
529 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
530 ref = window->SwitchFreeMultiWindow(false);
531 ASSERT_EQ(WSError::WS_ERROR_REPEAT_OPERATION, ref);
532 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
533 ref = window->SwitchFreeMultiWindow(true);
534 ASSERT_EQ(WSError::WS_ERROR_REPEAT_OPERATION, ref);
535
536 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
537 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
538 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
539 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, window->SwitchFreeMultiWindow(true));
540 EXPECT_EQ(true, window->windowSystemConfig_.freeMultiWindowEnable_);
541 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, window->SwitchFreeMultiWindow(false));
542 EXPECT_EQ(false, window->windowSystemConfig_.freeMultiWindowEnable_);
543 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
544 }
545
546 /**
547 * @tc.name: SwitchFreeMultiWindow02
548 * @tc.desc: SwitchFreeMultiWindow
549 * @tc.type: FUNC
550 */
551 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow02, TestSize.Level1)
552 {
553 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
554 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
555 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
556
557 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
558 mainWindow->property_->SetPersistentId(1);
559 mainWindow->hostSession_ = session;
560 mainWindow->property_->SetWindowName("SwitchFreeMultiWindow02_mainWindow");
561 mainWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
562 mainWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
563 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
564 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
565 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
566 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
567
568 sptr<WindowSceneSessionImpl> floatWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
569 floatWindow->property_->SetPersistentId(2);
570 floatWindow->hostSession_ = session;
571 floatWindow->property_->SetWindowName("SwitchFreeMultiWindow02_floatWindow");
572 floatWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
573 floatWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
574 floatWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
575 floatWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
576 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(floatWindow->GetWindowName(),
577 std::pair<uint64_t, sptr<WindowSessionImpl>>(floatWindow->GetWindowId(), floatWindow)));
578
579 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
580 subWindow->property_->SetPersistentId(3);
581 subWindow->hostSession_ = session;
582 subWindow->property_->SetWindowName("SwitchFreeMultiWindow03_subWindow");
583 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
584 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
585 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
586 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
587 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
588
589 EXPECT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
590 EXPECT_EQ(false, floatWindow->IsPcOrPadFreeMultiWindowMode());
591 EXPECT_EQ(false, subWindow->IsPcOrPadFreeMultiWindowMode());
592 EXPECT_EQ(WSError::WS_ERROR_NULLPTR, mainWindow->SwitchFreeMultiWindow(true));
593 EXPECT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
594 EXPECT_EQ(WSError::WS_OK, floatWindow->SwitchFreeMultiWindow(true));
595 EXPECT_EQ(true, floatWindow->IsPcOrPadFreeMultiWindowMode());
596 EXPECT_EQ(WSError::WS_OK, subWindow->SwitchFreeMultiWindow(true));
597 EXPECT_EQ(true, subWindow->IsPcOrPadFreeMultiWindowMode());
598
599 EXPECT_EQ(WMError::WM_OK, mainWindow->Destroy(true));
600 EXPECT_EQ(WMError::WM_OK, floatWindow->Destroy(true));
601 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
602 }
603
604 /**
605 * @tc.name: SwitchFreeMultiWindow03
606 * @tc.desc: SwitchFreeMultiWindow
607 * @tc.type: FUNC
608 */
609 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow03, Function | SmallTest | Level2)
610 {
611 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
612 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
613 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
614
615 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
616 mainWindow->property_->SetPersistentId(1);
617 mainWindow->hostSession_ = session;
618 mainWindow->property_->SetWindowName("SwitchFreeMultiWindow03_mainWindow");
619 mainWindow->windowSystemConfig_.freeMultiWindowEnable_ = true;
620 mainWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
621 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
622 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
623 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
624 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
625 mainWindow->haveSetSupportedWindowModes_ = true;
626 mainWindow->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
627 EXPECT_EQ(mainWindow->property_->GetWindowModeSupportType(), WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
628 EXPECT_EQ(mainWindow->SwitchFreeMultiWindow(false), WSError::WS_OK);
629 EXPECT_EQ(WindowHelper::IsWindowModeSupported(mainWindow->property_->GetWindowModeSupportType(),
630 WindowMode::WINDOW_MODE_FULLSCREEN), false);
631 EXPECT_EQ(mainWindow->windowSystemConfig_.freeMultiWindowEnable_, false);
632 WindowSceneSessionImpl::windowSessionMap_.erase(mainWindow->property_->GetWindowName());
633 }
634
635 /**
636 * @tc.name: SwitchFreeMultiWindow04
637 * @tc.desc: SwitchFreeMultiWindow
638 * @tc.type: FUNC
639 */
640 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow04, Function | SmallTest | Level2)
641 {
642 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
643 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
644 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
645
646 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
647 mainWindow->property_->SetPersistentId(1);
648 mainWindow->hostSession_ = session;
649 mainWindow->property_->SetWindowName("SwitchFreeMultiWindow04_mainWindow");
650 mainWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
651 mainWindow->windowSystemConfig_.freeMultiWindowEnable_ = true;
652 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
653 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
654 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
655 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
656 mainWindow->haveSetSupportedWindowModes_ = true;
657 mainWindow->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
658 EXPECT_EQ(mainWindow->property_->GetWindowModeSupportType(), WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
659 EXPECT_EQ(mainWindow->SwitchFreeMultiWindow(false), WSError::WS_OK);
660 EXPECT_EQ(mainWindow->windowSystemConfig_.freeMultiWindowEnable_, false);
661
662 mainWindow->pendingWindowModeSupportType_ = WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN;
663 EXPECT_EQ(mainWindow->SwitchFreeMultiWindow(true), WSError::WS_OK);
664 EXPECT_EQ(mainWindow->property_->GetWindowModeSupportType(), WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
665 WindowSceneSessionImpl::windowSessionMap_.erase(mainWindow->property_->GetWindowName());
666 }
667
668 /**
669 * @tc.name: ShowKeyboard01
670 * @tc.desc: SwitchFreeMultiWindow
671 * @tc.type: FUNC
672 */
673 HWTEST_F(WindowSceneSessionImplTest5, ShowKeyboard01, TestSize.Level1)
674 {
675 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
676 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
677 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
678
679 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
680 keyboardWindow->property_->SetPersistentId(1000);
681 keyboardWindow->hostSession_ = session;
682 keyboardWindow->property_->SetWindowName("ShowKeyboard01");
683 keyboardWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
684 keyboardWindow->state_ = WindowState::STATE_DESTROYED;
685
686 KeyboardEffectOption effectOption;
687 effectOption.viewMode_ = KeyboardViewMode::DARK_IMMERSIVE_MODE;
688 effectOption.flowLightMode_ = KeyboardFlowLightMode::BACKGROUND_FLOW_LIGHT;
689 effectOption.gradientMode_ = KeyboardGradientMode::LINEAR_GRADIENT;
690 // normal value
691 ASSERT_EQ(keyboardWindow->ShowKeyboard(effectOption), WMError::WM_ERROR_INVALID_WINDOW);
692
693 effectOption.viewMode_ = KeyboardViewMode::VIEW_MODE_END;
694 effectOption.flowLightMode_ = KeyboardFlowLightMode::END;
695 effectOption.gradientMode_ = KeyboardGradientMode::END;
696 // exception value
697 ASSERT_EQ(keyboardWindow->ShowKeyboard(effectOption), WMError::WM_ERROR_INVALID_WINDOW);
698 auto lastOption = keyboardWindow->property_->GetKeyboardEffectOption();
699 ASSERT_EQ(lastOption.viewMode_, KeyboardViewMode::NON_IMMERSIVE_MODE);
700 }
701
702 /**
703 * @tc.name: ChangeKeyboardEffectOption01
704 * @tc.desc: SwitchFreeMultiWindow
705 * @tc.type: FUNC
706 */
707 HWTEST_F(WindowSceneSessionImplTest5, ChangeKeyboardEffectOption01, TestSize.Level1)
708 {
709 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
710 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
711 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
712
713 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
714 keyboardWindow->property_->SetPersistentId(1000);
715 keyboardWindow->hostSession_ = session;
716 keyboardWindow->property_->SetWindowName("ChangeKeyboardEffectOption01");
717 keyboardWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
718
719 KeyboardEffectOption effectOption;
720 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
721 keyboardWindow->property_->SetKeyboardEffectOption(effectOption);
722 auto result = WMError::WM_OK;
723 // exception mode value
724 effectOption.viewMode_ = KeyboardViewMode::VIEW_MODE_END;
725 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
726 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
727
728 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
729 effectOption.flowLightMode_ = KeyboardFlowLightMode::END;
730 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
731 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
732
733 // same mode
734 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
735 effectOption.flowLightMode_ = KeyboardFlowLightMode::NONE;
736 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
737 ASSERT_EQ(result, WMError::WM_DO_NOTHING);
738
739 // invalid window state
740 keyboardWindow->state_ = WindowState::STATE_DESTROYED;
741 effectOption.viewMode_ = KeyboardViewMode::LIGHT_IMMERSIVE_MODE;
742 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
743 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_WINDOW);
744
745 // window state not shown
746 keyboardWindow->state_ = WindowState::STATE_HIDDEN;
747 effectOption.viewMode_ = KeyboardViewMode::LIGHT_IMMERSIVE_MODE;
748 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
749 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_WINDOW);
750
751 keyboardWindow->state_ = WindowState::STATE_SHOWN;
752 effectOption.viewMode_ = KeyboardViewMode::DARK_IMMERSIVE_MODE;
753 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
754 ASSERT_EQ(result, WMError::WM_OK);
755 auto lastOption = keyboardWindow->property_->GetKeyboardEffectOption();
756 ASSERT_EQ(lastOption.viewMode_, KeyboardViewMode::DARK_IMMERSIVE_MODE);
757 }
758
759 /**
760 * @tc.name: ChangeKeyboardEffectOption02
761 * @tc.desc: SwitchFreeMultiWindow
762 * @tc.type: FUNC
763 */
764 HWTEST_F(WindowSceneSessionImplTest5, ChangeKeyboardEffectOption02, TestSize.Level1)
765 {
766 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
767 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
768 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
769
770 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
771 keyboardWindow->property_->SetPersistentId(1000);
772 keyboardWindow->hostSession_ = session;
773 keyboardWindow->property_->SetWindowName("ChangeKeyboardEffectOption02");
774 keyboardWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
775
776 KeyboardEffectOption effectOption;
777 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
778 keyboardWindow->property_->SetKeyboardEffectOption(effectOption);
779 auto result = WMError::WM_OK;
780 // exception mode value
781 effectOption.viewMode_ = KeyboardViewMode::VIEW_MODE_END;
782 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
783 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
784
785 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
786 effectOption.flowLightMode_ = KeyboardFlowLightMode::END;
787 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
788 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
789
790 effectOption.viewMode_ = KeyboardViewMode::NON_IMMERSIVE_MODE;
791 effectOption.flowLightMode_ = KeyboardFlowLightMode::NONE;
792 effectOption.gradientMode_ = KeyboardGradientMode::END;
793 result = keyboardWindow->ChangeKeyboardEffectOption(effectOption);
794 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
795 }
796
797 /**
798 * @tc.name: StartMoveWindowWithCoordinate_01
799 * @tc.desc: StartMoveWindowWithCoordinate
800 * @tc.type: FUNC
801 */
802 HWTEST_F(WindowSceneSessionImplTest5, StartMoveWindowWithCoordinate_01, TestSize.Level1)
803 {
804 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
805 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
806 window->property_->SetPersistentId(1);
807 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
808 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
809 window->hostSession_ = session;
810
811 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
812 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
813
814 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
815 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
816
817 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
818 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
819 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
820 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
821
822 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
823 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
824 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
825 window->property_->SetIsPcAppInPad(true);
826 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
827
828 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
829 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
830 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
831 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
832 window->property_->SetIsPcAppInPad(true);
833 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_OK);
834 }
835
836 /**
837 * @tc.name: StartMoveWindowWithCoordinate_02
838 * @tc.desc: StartMoveWindowWithCoordinate
839 * @tc.type: FUNC
840 */
841 HWTEST_F(WindowSceneSessionImplTest5, StartMoveWindowWithCoordinate_02, TestSize.Level1)
842 {
843 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
844 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
845 Rect windowRect = { 200, 200, 1000, 1000 };
846 window->property_->SetWindowRect(windowRect);
847 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
848 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
849 window->hostSession_ = session;
850 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
851 window->property_->SetPersistentId(0);
852 ASSERT_EQ(window->StartMoveWindowWithCoordinate(-1, 50), WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
853
854 window->property_->SetPersistentId(1);
855 ASSERT_EQ(window->StartMoveWindowWithCoordinate(-1, 50), WmErrorCode::WM_ERROR_INVALID_PARAM);
856 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, -1), WmErrorCode::WM_ERROR_INVALID_PARAM);
857 ASSERT_EQ(window->StartMoveWindowWithCoordinate(1500, 50), WmErrorCode::WM_ERROR_INVALID_PARAM);
858 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 1500), WmErrorCode::WM_ERROR_INVALID_PARAM);
859 }
860
861 /**
862 * @tc.name: StartMoveWindowWithCoordinate_03
863 * @tc.desc: StartMoveWindowWithCoordinate
864 * @tc.type: FUNC
865 */
866 HWTEST_F(WindowSceneSessionImplTest5, StartMoveWindowWithCoordinate_03, TestSize.Level1)
867 {
868 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
869 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
870 window->property_->SetPersistentId(1);
871 Rect windowRect = { 200, 200, 1000, 1000 };
872 window->property_->SetWindowRect(windowRect);
873 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
874 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
875 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
876 window->hostSession_ = session;
877
878 EXPECT_CALL(*session, SyncSessionEvent(_)).Times(1).WillOnce(Return(WSError::WS_ERROR_REPEAT_OPERATION));
879 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_REPEAT_OPERATION);
880
881 EXPECT_CALL(*session, SyncSessionEvent(_)).Times(1).WillOnce(Return(WSError::WS_ERROR_NULLPTR));
882 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
883
884 EXPECT_CALL(*session, SyncSessionEvent(_)).Times(1).WillOnce(Return(WSError::WS_OK));
885 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_OK);
886 }
887
888 /**
889 * @tc.name: UpdateSystemBarProperties
890 * @tc.desc: UpdateSystemBarProperties test
891 * @tc.type: FUNC
892 */
893 HWTEST_F(WindowSceneSessionImplTest5, UpdateSystemBarProperties, TestSize.Level0)
894 {
895 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
896 option->SetWindowName("UpdateSystemBarProperties");
897 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
898 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
899 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
900 std::unordered_map<WindowType, SystemBarProperty> systemBarProperties;
901 std::unordered_map<WindowType, SystemBarPropertyFlag> systemBarPropertyFlags;
902 ASSERT_EQ(WMError::WM_OK, window->UpdateSystemBarProperties(systemBarProperties, systemBarPropertyFlags));
903 }
904
905 /**
906 * @tc.name: UpdateSystemBarProperties02
907 * @tc.desc: UpdateSystemBarProperties02 test
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowSceneSessionImplTest5, UpdateSystemBarProperties02, TestSize.Level0)
911 {
912 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
913 option->SetWindowName("UpdateSystemBarProperties02");
914 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
915 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
916 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
917 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
918
919 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
920 window->hostSession_ = session;
921 window->property_->SetPersistentId(1);
922 window->state_ = WindowState::STATE_CREATED;
923
924 WindowType windowType1 = WindowType::WINDOW_TYPE_STATUS_BAR;
925 WindowType windowType2 = WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR;
926 SystemBarProperty systemBarProperty1 = SystemBarProperty();
927 SystemBarProperty systemBarProperty2 = SystemBarProperty(true, 100, 200);
928 SystemBarPropertyFlag systemBarPropertyFlag1 = {true, true, true, true};
929 SystemBarPropertyFlag systemBarPropertyFlag2 = {false, false, false, false};
930
931 std::unordered_map<WindowType, SystemBarProperty> systemBarProperties;
932 std::unordered_map<WindowType, SystemBarPropertyFlag> systemBarPropertyFlags;
933 systemBarProperties.insert({windowType1, systemBarProperty1});
934 systemBarPropertyFlags.insert({windowType2, systemBarPropertyFlag2});
935 ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSystemBarProperties(systemBarProperties, systemBarPropertyFlags));
936
937 systemBarProperties.insert({windowType2, systemBarProperty2});
938 systemBarPropertyFlags.insert({windowType1, systemBarPropertyFlag1});
939 ASSERT_EQ(WMError::WM_OK, window->UpdateSystemBarProperties(systemBarProperties, systemBarPropertyFlags));
940
941 window->state_ = WindowState::STATE_BOTTOM;
942 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
943 window->UpdateSystemBarProperties(systemBarProperties, systemBarPropertyFlags));
944 }
945
946 /**
947 * @tc.name: NotifyAfterDidForeground
948 * @tc.desc: NotifyAfterDidForeground
949 * @tc.type: FUNC
950 */
951 HWTEST_F(WindowSceneSessionImplTest5, NotifyAfterDidForeground, TestSize.Level1)
952 {
953 sptr<MockWindowLifeCycleListener> mockListener = sptr<MockWindowLifeCycleListener>::MakeSptr();
954 sptr<IWindowLifeCycle> listener = static_cast<sptr<IWindowLifeCycle>>(mockListener);
955
956 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
957 option->SetWindowName("Test");
958 option->SetDisplayId(0);
959
960 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
961 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
962
963 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
964 window->property_->SetPersistentId(1);
965 window->hostSession_ = session;
966 ASSERT_EQ(WMError::WM_OK, window->RegisterLifeCycleListener(listener));
967
968 ON_CALL(*mockListener, AfterDidForeground());
969 ASSERT_EQ(WMError::WM_OK, window->Show(static_cast<uint32_t>(WindowStateChangeReason::ABILITY_CALL), false));
970 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
971 }
972
973 /**
974 * @tc.name: NotifyAfterDidBackground
975 * @tc.desc: NotifyAfterDidBackground
976 * @tc.type: FUNC
977 */
978 HWTEST_F(WindowSceneSessionImplTest5, NotifyAfterDidBackground, TestSize.Level1)
979 {
980 sptr<MockWindowLifeCycleListener> mockListener = sptr<MockWindowLifeCycleListener>::MakeSptr();
981 sptr<IWindowLifeCycle> listener = static_cast<sptr<IWindowLifeCycle>>(mockListener);
982
983 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
984 option->SetWindowName("Test");
985 option->SetDisplayId(0);
986
987 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
988 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
989
990 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
991 window->property_->SetPersistentId(1);
992 window->hostSession_ = session;
993 ASSERT_EQ(WMError::WM_OK, window->RegisterLifeCycleListener(listener));
994
995 ON_CALL(*mockListener, AfterDidBackground());
996 ASSERT_EQ(WMError::WM_OK, window->Hide(static_cast<uint32_t>(WindowStateChangeReason::ABILITY_CALL), false, false));
997 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
998 }
999
1000 /**
1001 * @tc.name: Resume
1002 * @tc.desc: Resume
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(WindowSceneSessionImplTest5, Resume, TestSize.Level1)
1006 {
1007 sptr<MockWindowStageLifeCycleListener> mockListener = sptr<MockWindowStageLifeCycleListener>::MakeSptr();
1008 sptr<IWindowStageLifeCycle> listener = static_cast<sptr<IWindowStageLifeCycle>>(mockListener);
1009
1010 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1011 option->SetWindowName("Test");
1012 option->SetDisplayId(0);
1013
1014 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1015 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1016
1017 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1018 window->property_->SetPersistentId(1);
1019 window->hostSession_ = session;
1020 EXPECT_EQ(WMError::WM_OK, window->RegisterWindowStageLifeCycleListener(listener));
1021 window->isDidForeground_ = false;
1022 window->isColdStart_ = true;
1023 window->state_ = WindowState::STATE_SHOWN;
1024 EXPECT_CALL(*mockListener, AfterLifecycleResumed()).Times(1);
1025 window->Resume();
1026 EXPECT_EQ(window->isDidForeground_, true);
1027 EXPECT_EQ(window->isColdStart_, false);
1028
1029 EXPECT_CALL(*mockListener, AfterLifecyclePaused()).Times(1);
1030 window->Pause();
1031 EXPECT_EQ(window->isDidForeground_, true);
1032 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1033 }
1034
1035 /**
1036 * @tc.name: NotifyDialogStateChange
1037 * @tc.desc: NotifyDialogStateChange
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(WindowSceneSessionImplTest5, NotifyDialogStateChange, TestSize.Level1)
1041 {
1042 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1043 option->SetWindowName("NotifyDialogStateChange");
1044 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1045 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1046 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1047 windowSceneSessionImpl->property_->SetPersistentId(1);
1048 windowSceneSessionImpl->hostSession_ = session;
1049 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1050 auto ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
1051 EXPECT_EQ(WSError::WS_OK, ret);
1052 windowSceneSessionImpl->state_ = WindowState::STATE_HIDDEN;
1053 windowSceneSessionImpl->requestState_ = WindowState::STATE_SHOWN;
1054 ret = windowSceneSessionImpl->NotifyDialogStateChange(true);
1055 EXPECT_EQ(WSError::WS_OK, ret);
1056 }
1057
1058 /**
1059 * @tc.name: NotifyFreeMultiWindowModeResume
1060 * @tc.desc: NotifyFreeMultiWindowModeResume
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(WindowSceneSessionImplTest5, NotifyFreeMultiWindowModeResume, TestSize.Level1)
1064 {
1065 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1066 option->SetWindowName("NotifyFreeMultiWindowModeResume");
1067 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1068 sptr<WindowSceneSessionImpl> multiWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1069 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1070 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1071 multiWindow->hostSession_ = session;
1072 multiWindow->property_->SetPersistentId(1);
1073 multiWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1074 EXPECT_EQ(true, multiWindow->IsPcOrFreeMultiWindowCapabilityEnabled());
1075 multiWindow->Resume();
1076 EXPECT_EQ(false, multiWindow->isColdStart_);
1077 multiWindow->NotifyFreeMultiWindowModeResume();
1078 EXPECT_EQ(true, multiWindow->isDidForeground_);
1079 EXPECT_EQ(WMError::WM_OK, multiWindow->Destroy(true));
1080 }
1081
1082 /**
1083 * @tc.name: GetParentWindow01
1084 * @tc.desc: GetParentWindow
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(WindowSceneSessionImplTest5, GetParentWindow01, TestSize.Level1)
1088 {
1089 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1090 option->SetWindowName("GetParentWindow01");
1091 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1092 sptr<Window> parentWindow = nullptr;
1093 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1094 window->property_->SetPcAppInpadCompatibleMode(true);
1095 auto res = window->GetParentWindow(parentWindow);
1096 EXPECT_EQ(res, WMError::WM_OK);
1097 window->property_->SetPcAppInpadCompatibleMode(false);
1098 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1099 res = window->GetParentWindow(parentWindow);
1100 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
1101
1102 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1103 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1104 window->hostSession_ = session;
1105 window->property_->SetPersistentId(1);
1106 window->property_->SetParentPersistentId(2);
1107 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1108 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1109 res = window->GetParentWindow(parentWindow);
1110 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1111
1112 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1113 res = window->GetParentWindow(parentWindow);
1114 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
1115
1116 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1117 window->property_->SetIsUIExtFirstSubWindow(true);
1118 res = window->GetParentWindow(parentWindow);
1119 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
1120
1121 window->property_->SetIsUIExtFirstSubWindow(false);
1122 res = window->GetParentWindow(parentWindow);
1123 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
1124 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1125 }
1126
1127 /**
1128 * @tc.name: GetParentWindow02
1129 * @tc.desc: GetParentWindow
1130 * @tc.type: FUNC
1131 */
1132 HWTEST_F(WindowSceneSessionImplTest5, GetParentWindow02, TestSize.Level1)
1133 {
1134 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1135 option->SetWindowName("GetParentWindow01_parentWindow");
1136 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1137 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1138 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1139 mainWindow->hostSession_ = session;
1140 mainWindow->property_->SetPersistentId(1);
1141 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1142 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1143 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
1144 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
1145
1146 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1147 subWindowOption->SetWindowName("GetParentWindow01_subWindow");
1148 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1149 subWindow->property_->SetPersistentId(2);
1150 subWindow->property_->SetParentPersistentId(1);
1151 subWindow->hostSession_ = session;
1152 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1153 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1154 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
1155 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
1156
1157 sptr<Window> parentWindow = nullptr;
1158 auto res = subWindow->GetParentWindow(parentWindow);
1159 EXPECT_EQ(res, WMError::WM_OK);
1160 ASSERT_NE(parentWindow, nullptr);
1161 EXPECT_EQ(parentWindow->GetWindowName(), mainWindow->GetWindowName());
1162 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1163 EXPECT_EQ(WMError::WM_OK, mainWindow->Destroy(true));
1164 }
1165
1166 /**
1167 * @tc.name: SetParentWindow01
1168 * @tc.desc: SetParentWindow
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow01, TestSize.Level1)
1172 {
1173 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1174 option->SetWindowName("SetParentWindow01");
1175 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1176 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1177 int32_t newParentWindowId = 2;
1178 auto res = window->SetParentWindow(newParentWindowId);
1179 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
1180
1181 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1182 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1183 window->hostSession_ = session;
1184 window->property_->SetPersistentId(1);
1185 window->property_->SetParentPersistentId(2);
1186 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1187 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1188 res = window->SetParentWindow(newParentWindowId);
1189 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1190
1191 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1192 res = window->SetParentWindow(newParentWindowId);
1193 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
1194
1195 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1196 newParentWindowId = 1;
1197 res = window->SetParentWindow(newParentWindowId);
1198 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
1199 newParentWindowId = 2;
1200 res = window->SetParentWindow(newParentWindowId);
1201 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
1202 newParentWindowId = 3;
1203 res = window->SetParentWindow(newParentWindowId);
1204 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
1205 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1206 }
1207
1208 /**
1209 * @tc.name: SetParentWindow02
1210 * @tc.desc: SetParentWindow
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow02, TestSize.Level1)
1214 {
1215 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1216 option->SetWindowName("SetParentWindow02_parentWindow");
1217 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1218 mainWindow->property_->SetPersistentId(1);
1219 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1220 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1221 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
1222 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
1223
1224 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1225 subWindowOption->SetWindowName("SetParentWindow02_subWindow");
1226 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1227 subWindow->property_->SetPersistentId(2);
1228 subWindow->property_->SetParentPersistentId(1);
1229 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1230 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1231 subWindow->hostSession_ = session;
1232 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1233 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1234 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
1235 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
1236
1237 sptr<WindowOption> newParentWindowOption = sptr<WindowOption>::MakeSptr();
1238 newParentWindowOption->SetWindowName("SetParentWindow02_newParentWindow");
1239 sptr<WindowSceneSessionImpl> newParentWindow = sptr<WindowSceneSessionImpl>::MakeSptr(newParentWindowOption);
1240 newParentWindow->property_->SetPersistentId(3);
1241 newParentWindow->property_->SetParentPersistentId(1);
1242 newParentWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1243 newParentWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1244 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(newParentWindow->GetWindowName(),
1245 std::pair<uint64_t, sptr<WindowSessionImpl>>(newParentWindow->GetWindowId(), newParentWindow)));
1246
1247 int32_t newParentWindowId = 3;
1248 auto res = subWindow->SetParentWindow(newParentWindowId);
1249 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
1250 newParentWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1251 WindowAdapterMocker mocker;
1252 EXPECT_CALL(mocker.Mock(), SetParentWindow(_, _)).WillOnce(Return(WMError::WM_OK));
1253 res = subWindow->SetParentWindow(newParentWindowId);
1254 EXPECT_EQ(res, WMError::WM_OK);
1255 sptr<Window> parentWindow = nullptr;
1256 EXPECT_EQ(subWindow->GetParentWindow(parentWindow), WMError::WM_OK);
1257 ASSERT_NE(parentWindow, nullptr);
1258 EXPECT_EQ(parentWindow->GetWindowName(), newParentWindow->GetWindowName());
1259 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1260 }
1261
1262 /**
1263 * @tc.name: SetParentWindow03
1264 * @tc.desc: SetParentWindow
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow03, TestSize.Level1)
1268 {
1269 WindowSceneSessionImpl::windowSessionMap_.clear();
1270 sptr<WindowOption> parentOption1 = sptr<WindowOption>::MakeSptr();
1271 parentOption1->SetWindowName("SetParentWindow03_parentWindow1");
1272 parentOption1->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1273 sptr<WindowSceneSessionImpl> parentWindow1 = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption1);
1274 parentWindow1->property_->SetPersistentId(1);
1275
1276 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1277 subWindowOption->SetWindowName("SetParentWindow03_subWindow");
1278 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1279 subWindow->property_->SetPersistentId(2);
1280 subWindow->property_->SetParentPersistentId(1);
1281 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1282 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1283 subWindow->hostSession_ = session;
1284 int32_t newParentWindowId = 3;
1285 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1286 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1287
1288 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), WMError::WM_ERROR_INVALID_PARENT);
1289 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(parentWindow1->GetWindowName(),
1290 std::pair<uint64_t, sptr<WindowSessionImpl>>(parentWindow1->GetWindowId(), parentWindow1)));
1291 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), WMError::WM_ERROR_INVALID_PARENT);
1292 parentWindow1->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1293 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), WMError::WM_ERROR_INVALID_PARENT);
1294
1295 sptr<WindowOption> parentOption2 = sptr<WindowOption>::MakeSptr();
1296 parentOption2->SetWindowName("SetParentWindow03_parentWindow2");
1297 parentOption2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1298 sptr<WindowSceneSessionImpl> parentWindow2 = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption2);
1299 parentWindow2->property_->SetPersistentId(3);
1300 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(parentWindow2->GetWindowName(),
1301 std::pair<uint64_t, sptr<WindowSessionImpl>>(parentWindow2->GetWindowId(), parentWindow2)));
1302 WindowAdapterMocker mocker;
1303 WMError mockerResult = WMError::WM_ERROR_INVALID_WINDOW;
1304 EXPECT_CALL(mocker.Mock(), SetParentWindow(_, _)).WillOnce(Return(mockerResult));
1305 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), mockerResult);
1306 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1307 subWindow->property_->SetPcAppInpadCompatibleMode(true);
1308 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), WMError::WM_OK);
1309 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1310 }
1311
1312 /**
1313 * @tc.name: SetParentWindow04
1314 * @tc.desc: SetParentWindow
1315 * @tc.type: FUNC
1316 */
1317 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow04, TestSize.Level1)
1318 {
1319 WindowSceneSessionImpl::subWindowSessionMap_.clear();
1320 WindowSceneSessionImpl::windowSessionMap_.clear();
1321 sptr<WindowOption> parentOption1 = sptr<WindowOption>::MakeSptr();
1322 parentOption1->SetWindowName("SetParentWindow04_parentWindow1");
1323 parentOption1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1324 sptr<WindowSceneSessionImpl> parentWindow1 = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption1);
1325 parentWindow1->property_->SetPersistentId(1);
1326 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(parentWindow1->GetWindowName(),
1327 std::pair<uint64_t, sptr<WindowSessionImpl>>(parentWindow1->GetWindowId(), parentWindow1)));
1328
1329 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1330 subWindowOption->SetWindowName("SetParentWindow04_subWindow");
1331 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1332 subWindow->property_->SetPersistentId(2);
1333 subWindow->property_->SetParentPersistentId(1);
1334 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1335 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1336 subWindow->hostSession_ = session;
1337 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1338 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1339 WindowSceneSessionImpl::subWindowSessionMap_.insert(std::pair<int32_t,
1340 std::vector<sptr<WindowSessionImpl>>>(1, { subWindow }));
1341
1342 sptr<WindowOption> parentOption2 = sptr<WindowOption>::MakeSptr();
1343 parentOption2->SetWindowName("SetParentWindow04_parentWindow2");
1344 parentOption2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1345 sptr<WindowSceneSessionImpl> parentWindow2 = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption2);
1346 parentWindow2->property_->SetPersistentId(3);
1347 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(parentWindow2->GetWindowName(),
1348 std::pair<uint64_t, sptr<WindowSessionImpl>>(parentWindow2->GetWindowId(), parentWindow2)));
1349
1350 std::vector<sptr<WindowSessionImpl>> subWindows;
1351 parentWindow1->GetSubWindows(1, subWindows);
1352 EXPECT_EQ(subWindows.size(), 1);
1353 WindowAdapterMocker mocker;
1354 EXPECT_CALL(mocker.Mock(), SetParentWindow(_, _)).WillOnce(Return(WMError::WM_OK));
1355 int32_t newParentWindowId = 3;
1356 EXPECT_EQ(subWindow->SetParentWindow(newParentWindowId), WMError::WM_OK);
1357 parentWindow1->GetSubWindows(1, subWindows);
1358 EXPECT_EQ(subWindows.size(), 0);
1359 subWindows.clear();
1360 parentWindow1->GetSubWindows(3, subWindows);
1361 EXPECT_EQ(subWindows.size(), 1);
1362 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1363 }
1364
1365 /**
1366 * @tc.name: SetParentWindowInner
1367 * @tc.desc: SetParentWindowInner
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindowInner, TestSize.Level1)
1371 {
1372 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1373 subWindowOption->SetWindowName("SetParentWindowInner_subWindow");
1374 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1375 subWindow->property_->SetPersistentId(2);
1376 subWindow->property_->SetParentPersistentId(1);
1377 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1378 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(sessionInfo);
1379 subWindow->hostSession_ = subSession;
1380 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1381 subWindow->state_ = WindowState::STATE_SHOWN;
1382
1383 sptr<WindowOption> parentOption = sptr<WindowOption>::MakeSptr();
1384 parentOption->SetWindowName("SetParentWindowInner_parentWindow");
1385 parentOption->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1386 sptr<WindowSceneSessionImpl> parentWindow = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption);
1387 parentWindow->property_->SetPersistentId(3);
1388 sptr<SessionMocker> parentSession = sptr<SessionMocker>::MakeSptr(sessionInfo);
1389 parentWindow->hostSession_ = parentSession;
1390 parentWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1391 parentWindow->state_ = WindowState::STATE_HIDDEN;
1392
1393 WindowAdapterMocker mocker;
1394 EXPECT_CALL(mocker.Mock(), SetParentWindow(_, _)).WillRepeatedly(Return(WMError::WM_OK));
1395 WindowSceneSessionImpl::subWindowSessionMap_.clear();
1396 EXPECT_EQ(WMError::WM_OK, subWindow->SetParentWindowInner(1, parentWindow));
1397 EXPECT_EQ(subWindow->state_, WindowState::STATE_HIDDEN);
1398 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1399 EXPECT_EQ(WMError::WM_OK, parentWindow->Destroy(true));
1400 }
1401
1402 /**
1403 * @tc.name: SetSubWindowModal01
1404 * @tc.desc: SetSubWindowModal
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(WindowSceneSessionImplTest5, SetSubWindowModal01, TestSize.Level1)
1408 {
1409 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1410 subOption->SetWindowName("SetSubWindowModal01");
1411 subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1412 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1413 subWindow->property_->SetPersistentId(2);
1414 subWindow->property_->SetParentPersistentId(1);
1415 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1416 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1417 subWindow->hostSession_ = session;
1418 EXPECT_CALL(*(session), UpdateSessionPropertyByAction(_, _))
1419 .WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1420 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1421 ModalityType modalityType = ModalityType::APPLICATION_MODALITY;
1422 auto ret = subWindow->SetSubWindowModal(true, modalityType);
1423 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1424 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1425 }
1426
1427 /**
1428 * @tc.name: SetWindowModal01
1429 * @tc.desc: SetWindowModal
1430 * @tc.type: FUNC
1431 */
1432 HWTEST_F(WindowSceneSessionImplTest5, SetWindowModal01, TestSize.Level1)
1433 {
1434 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1435 option->SetWindowName("SetWindowModal01");
1436 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1437 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1438 window->property_->SetPersistentId(1);
1439 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1440 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1441 window->hostSession_ = session;
1442 EXPECT_CALL(*(session), UpdateSessionPropertyByAction(_, _))
1443 .WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1444 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1445 auto ret = window->SetWindowModal(true);
1446 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1447 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1448 }
1449
1450 /**
1451 * @tc.name: IsFullScreenEnable
1452 * @tc.desc: IsFullScreenEnable
1453 * @tc.type: FUNC
1454 */
1455 HWTEST_F(WindowSceneSessionImplTest5, IsFullScreenEnable, TestSize.Level1)
1456 {
1457 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1458 option->SetDisplayId(0);
1459 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1460 window->property_->SetWindowModeSupportType(0);
1461 ASSERT_EQ(window->IsFullScreenEnable(), false);
1462 window->property_->SetWindowModeSupportType(1);
1463 ASSERT_EQ(window->IsFullScreenEnable(), true);
1464 window->property_->SetDragEnabled(true);
1465 WindowLimits windowLimits = {5000, 5000, 500, 500, 0.0f, 0.0f};
1466 window->property_->SetWindowLimits(windowLimits);
1467 ASSERT_EQ(window->IsFullScreenEnable(), true);
1468 WindowLimits windowLimits1 = {800, 800, 500, 500, 0.0f, 0.0f};
1469 window->property_->SetWindowLimits(windowLimits1);
1470 ASSERT_EQ(window->IsFullScreenEnable(), false);
1471 window->property_->SetDragEnabled(false);
1472 ASSERT_EQ(window->IsFullScreenEnable(), true);
1473 }
1474
1475 /**
1476 * @tc.name: IsFullScreenSizeWindow
1477 * @tc.desc: IsFullScreenSizeWindow
1478 * @tc.type: FUNC
1479 */
1480 HWTEST_F(WindowSceneSessionImplTest5, IsFullScreenSizeWindow, TestSize.Level1)
1481 {
1482 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1483 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1484 window->property_->SetDisplayId(0);
1485 uint32_t width = 0;
1486 uint32_t height = 0;
1487 ASSERT_EQ(window->IsFullScreenSizeWindow(width, height), false);
1488 auto display = SingletonContainer::Get<DisplayManager>().GetDisplayById(0);
1489 ASSERT_NE(display, nullptr);
1490 auto displayInfo = display->GetDisplayInfo();
1491 ASSERT_NE(displayInfo, nullptr);
1492 width = static_cast<uint32_t>(displayInfo->GetWidth());
1493 height = static_cast<uint32_t>(displayInfo->GetHeight());
1494 ASSERT_EQ(window->IsFullScreenSizeWindow(width, height), true);
1495 }
1496
1497 /**
1498 * @tc.name: SetWindowAnchorInfo
1499 * @tc.desc: SetWindowAnchorInfo
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(WindowSceneSessionImplTest5, SetWindowAnchorInfo01, Function | SmallTest | Level2)
1503 {
1504 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1505 option->SetWindowName("SetWindowAnchorInfo01");
1506 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1507 auto property = window->GetProperty();
1508
1509 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1510 WindowAnchorInfo windowAnchorInfo = { true, WindowAnchor::BOTTOM_END, 0, 0 };
1511 WMError ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1512 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1513
1514 SessionInfo sessionInfo;
1515 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1516 window->hostSession_ = session;
1517 property->persistentId_ = 100;
1518 window->state_ = WindowState::STATE_CREATED;
1519 ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1520 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
1521
1522 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1523 property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1524 ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1525 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
1526
1527 property->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1528 property->subWindowLevel_ = 100;
1529 ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1530 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
1531
1532 property->subWindowLevel_ = 1;
1533 window->windowSystemConfig_.supportFollowRelativePositionToParent_ = false;
1534 ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1535 EXPECT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1536
1537 window->windowSystemConfig_.supportFollowRelativePositionToParent_ = true;
1538 session->systemConfig_.supportFollowRelativePositionToParent_ = true;
1539 ret = window->SetWindowAnchorInfo(windowAnchorInfo);
1540 EXPECT_EQ(ret, WMError::WM_OK);
1541 }
1542
1543 /**
1544 * @tc.name: SetFollowParentWindowLayoutEnabled
1545 * @tc.desc: SetFollowParentWindowLayoutEnabled
1546 * @tc.type: FUNC
1547 */
1548 HWTEST_F(WindowSceneSessionImplTest5, SetFollowParentWindowLayoutEnabled01, Function | SmallTest | Level2)
1549 {
1550 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1551 option->SetWindowName("SetFollowParentWindowLayoutEnabled01");
1552 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1553 auto property = window->GetProperty();
1554 window->windowSystemConfig_.supportFollowParentWindowLayout_ = true;
1555
1556 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1557 WMError ret = window->SetFollowParentWindowLayoutEnabled(true);
1558 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1559
1560 SessionInfo sessionInfo;
1561 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1562 window->hostSession_ = session;
1563 property->persistentId_ = 100;
1564 window->state_ = WindowState::STATE_CREATED;
1565 ret = window->SetFollowParentWindowLayoutEnabled(true);
1566 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
1567
1568 property->subWindowLevel_ = 100;
1569 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1570 ret = window->SetFollowParentWindowLayoutEnabled(true);
1571 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
1572
1573 property->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1574 ret = window->SetFollowParentWindowLayoutEnabled(true);
1575 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
1576
1577 property->subWindowLevel_ = 1;
1578 window->windowSystemConfig_.supportFollowParentWindowLayout_ = false;
1579 ret = window->SetFollowParentWindowLayoutEnabled(true);
1580 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1581
1582 window->windowSystemConfig_.supportFollowParentWindowLayout_ = true;
1583 ret = window->SetFollowParentWindowLayoutEnabled(true);
1584 ASSERT_EQ(ret, WMError::WM_OK);
1585 }
1586
1587 /**
1588 * @tc.name: GetTargetOrientationConfigInfo
1589 * @tc.desc: GetTargetOrientationConfigInfo
1590 * @tc.type: FUNC
1591 */
1592 HWTEST_F(WindowSceneSessionImplTest5, GetTargetOrientationConfigInfo, Function | SmallTest | Level2)
1593 {
1594 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1595 option->SetDisplayId(0);
1596 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1597 Orientation targetOrientation = Orientation::USER_ROTATION_PORTRAIT;
1598 std::map<Rosen::WindowType, Rosen::SystemBarProperty> properties;
1599 Rosen::SystemBarProperty statusBarProperty;
1600 properties[Rosen::WindowType::WINDOW_TYPE_STATUS_BAR] = statusBarProperty;
1601 Ace::ViewportConfig config;
1602 std::map<AvoidAreaType, AvoidArea> avoidAreas;
1603 window->getTargetInfoCallback_ = sptr<FutureCallback>::MakeSptr();
1604
1605 window->property_->SetPersistentId(1);
1606 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1607 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1608 window->hostSession_ = session;
1609 window->property_->SetWindowName("GetTargetOrientationConfigInfo");
1610 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1611 window->state_ = WindowState::STATE_CREATED;
1612 EXPECT_EQ(WMError::WM_OK,
1613 window->GetTargetOrientationConfigInfo(targetOrientation, properties, config, avoidAreas));
1614 targetOrientation = Orientation::INVALID;
1615 EXPECT_EQ(WMError::WM_OK,
1616 window->GetTargetOrientationConfigInfo(targetOrientation, properties, config, avoidAreas));
1617 }
1618
1619 /**
1620 * @tc.name: SetWindowTransitionAnimation
1621 * @tc.desc: SetWindowTransitionAnimation
1622 * @tc.type: FUNC
1623 */
1624 HWTEST_F(WindowSceneSessionImplTest5, SetWindowTransitionAnimation01, Function | SmallTest | Level2)
1625 {
1626 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1627 option->SetWindowName("SetWindowTransitionAnimation01");
1628 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1629 auto property = window->GetProperty();
1630
1631 WindowTransitionType type = WindowTransitionType::DESTROY;
1632 TransitionAnimation animation;
1633
1634 property->SetWindowState(WindowState::STATE_DESTROYED);
1635 WMError ret = window->SetWindowTransitionAnimation(type, animation);
1636 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1637
1638 SessionInfo sessionInfo;
1639 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1640 window->hostSession_ = session;
1641 property->persistentId_ = 100;
1642
1643 property->SetWindowState(WindowState::STATE_SHOWN);
1644 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1645 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1646 ret = window->SetWindowTransitionAnimation(type, animation);
1647 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1648
1649 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1650 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1651 ret = window->SetWindowTransitionAnimation(type, animation);
1652 ASSERT_EQ(ret, WMError::WM_OK);
1653
1654 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1655 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1656 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
1657 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
1658 ret = window->SetWindowTransitionAnimation(type, animation);
1659 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1660
1661 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
1662 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1663 ret = window->SetWindowTransitionAnimation(type, animation);
1664 ASSERT_EQ(ret, WMError::WM_OK);
1665
1666
1667 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1668 ret = window->SetWindowTransitionAnimation(type, animation);
1669 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
1670 }
1671
1672 /**
1673 * @tc.name: GetWindowTransitionAnimation
1674 * @tc.desc: GetWindowTransitionAnimation
1675 * @tc.type: FUNC
1676 */
1677 HWTEST_F(WindowSceneSessionImplTest5, GetWindowTransitionAnimation01, Function | SmallTest | Level2)
1678 {
1679 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1680 option->SetWindowName("GetWindowTransitionAnimation01");
1681 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1682 auto property = window->GetProperty();
1683
1684 WindowTransitionType type = WindowTransitionType::DESTROY;
1685
1686 property->SetWindowState(WindowState::STATE_DESTROYED);
1687 std::shared_ptr<TransitionAnimation> ret = window->GetWindowTransitionAnimation(type);
1688 ASSERT_EQ(ret, nullptr);
1689
1690 SessionInfo sessionInfo;
1691 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1692 window->hostSession_ = session;
1693 property->persistentId_ = 100;
1694
1695 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1696 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1697 ret = window->GetWindowTransitionAnimation(type);
1698 ASSERT_EQ(ret, nullptr);
1699
1700 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1701 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1702 ret = window->GetWindowTransitionAnimation(type);
1703 ASSERT_EQ(ret, nullptr);
1704
1705 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1706 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1707 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
1708 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1709 ret = window->GetWindowTransitionAnimation(type);
1710 ASSERT_EQ(ret, nullptr);
1711
1712 TransitionAnimation animation;
1713 property->SetWindowState(WindowState::STATE_SHOWN);
1714 property->SetTransitionAnimationConfig(type, animation);
1715 ret = window->GetWindowTransitionAnimation(type);
1716 ASSERT_NE(ret, nullptr);
1717
1718 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1719 ret = window->GetWindowTransitionAnimation(type);
1720 ASSERT_EQ(ret, nullptr);
1721 }
1722
1723 /**
1724 * @tc.name: TransferLifeCycleEventToString
1725 * @tc.desc: TransferLifeCycleEventToString
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(WindowSceneSessionImplTest5, TransferLifeCycleEventToString, Function | SmallTest | Level2)
1729 {
1730 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1731 option->SetWindowName("TransferLifeCycleEventToString");
1732 option->SetDisplayId(0);
1733 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1734 ASSERT_NE(window, nullptr);
1735 window->RecordLifeCycleExceptionEvent(LifeCycleEvent::CREATE_EVENT, WMError::WM_ERROR_REPEAT_OPERATION);
1736 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::CREATE_EVENT), "CREATE");
1737 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::SHOW_EVENT), "SHOW");
1738 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::HIDE_EVENT), "HIDE");
1739 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::DESTROY_EVENT), "DESTROY");
1740 }
1741
1742 /**
1743 * @tc.name: FillTargetOrientationConfig
1744 * @tc.desc: FillTargetOrientationConfig
1745 * @tc.type: FUNC
1746 */
1747 HWTEST_F(WindowSceneSessionImplTest5, FillTargetOrientationConfig, Function | SmallTest | Level2)
1748 {
1749 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1750 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1751 OrientationInfo info;
1752 info.rotation = 90;
1753 info.rect = {0, 0, 50, 50};
1754 std::map<AvoidAreaType, AvoidArea> avoidAreas;
1755 info.avoidAreas = avoidAreas;
1756
1757 window->property_->SetPersistentId(1);
1758 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1759 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1760 window->hostSession_ = session;
1761 window->property_->SetWindowName("FillTargetOrientationConfig");
1762 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1763 window->property_->SetDisplayId(3);
1764 window->state_ = WindowState::STATE_CREATED;
1765 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1766 Ace::ViewportConfig config = window->FillTargetOrientationConfig(info, displayInfo, 3);
1767 EXPECT_EQ(3, config.DisplayId());
1768 }
1769
1770 /**
1771 * @tc.name: NotifyTargetRotationInfo
1772 * @tc.desc: NotifyTargetRotationInfo
1773 * @tc.type: FUNC
1774 */
1775 HWTEST_F(WindowSceneSessionImplTest5, NotifyTargetRotationInfo, Function | SmallTest | Level2)
1776 {
1777 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1778 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1779 OrientationInfo info;
1780 info.rotation = 90;
1781 info.rect = {0, 0, 50, 50};
1782 std::map<AvoidAreaType, AvoidArea> avoidAreas;
1783 info.avoidAreas = avoidAreas;
1784
1785 window->property_->SetPersistentId(1);
1786 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1787 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1788 window->hostSession_ = session;
1789 window->property_->SetWindowName("NotifyTargetRotationInfo");
1790 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1791 window->state_ = WindowState::STATE_CREATED;
1792 EXPECT_EQ(WSError::WS_DO_NOTHING, window->NotifyTargetRotationInfo(info));
1793 }
1794
1795 /**
1796 * @tc.name: StopMoveWindow
1797 * @tc.desc: StopMoveWindow
1798 * @tc.type: FUNC
1799 */
1800 HWTEST_F(WindowSceneSessionImplTest5, StopMoveWindow, Function | SmallTest | TestSize.Level1)
1801 {
1802 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1803 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1804 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1805 ASSERT_EQ(WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT, window->StopMoveWindow());
1806
1807 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1808 window->state_ = WindowState::STATE_DESTROYED;
1809 ASSERT_EQ(WmErrorCode::WM_ERROR_STATE_ABNORMALLY, window->StopMoveWindow());
1810
1811 window->state_ = WindowState::STATE_CREATED;
1812 window->property_->SetPersistentId(1);
1813 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1814 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1815 window->hostSession_ = session;
1816 EXPECT_CALL(*session, SyncSessionEvent(_)).Times(1).WillOnce(Return(WSError::WS_ERROR_NULLPTR));
1817 ASSERT_EQ(WmErrorCode::WM_ERROR_STATE_ABNORMALLY, window->StopMoveWindow());
1818
1819 EXPECT_CALL(*session, SyncSessionEvent(_)).Times(1).WillOnce(Return(WSError::WS_OK));
1820 ASSERT_EQ(WmErrorCode::WM_OK, window->StopMoveWindow());
1821 }
1822
1823 /**
1824 * @tc.name: HandleWindowLimitsInCompatibleMode01
1825 * @tc.desc: HandleWindowLimitsInCompatibleMode
1826 * @tc.type: FUNC
1827 */
1828 HWTEST_F(WindowSceneSessionImplTest5, HandleWindowLimitsInCompatibleMode01, Function | SmallTest | Level2)
1829 {
1830 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1831 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1832 window->property_->SetPersistentId(1);
1833 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1834 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1835 window->hostSession_ = session;
1836 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1837 compatibleModeProperty->SetDisableWindowLimit(true);
1838 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1839 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1840 WindowSizeLimits windowSizeLimits = {0, 0, 0, 0};
1841 window->HandleWindowLimitsInCompatibleMode(windowSizeLimits);
1842 EXPECT_EQ(windowSizeLimits.maxWindowWidth, window->windowSystemConfig_.maxFloatingWindowSize_);
1843 EXPECT_EQ(windowSizeLimits.maxWindowHeight, window->windowSystemConfig_.maxFloatingWindowSize_);
1844 EXPECT_EQ(windowSizeLimits.minWindowWidth, window->windowSystemConfig_.miniWidthOfMainWindow_);
1845 EXPECT_EQ(windowSizeLimits.minWindowHeight, window->windowSystemConfig_.miniHeightOfMainWindow_);
1846 }
1847
1848 /**
1849 * @tc.name: HandleWindowLimitsInCompatibleMode02
1850 * @tc.desc: HandleWindowLimitsInCompatibleMode
1851 * @tc.type: FUNC
1852 */
1853 HWTEST_F(WindowSceneSessionImplTest5, HandleWindowLimitsInCompatibleMode02, Function | SmallTest | Level2)
1854 {
1855 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1856 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1857 window->property_->SetPersistentId(1);
1858 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1859 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1860 window->hostSession_ = session;
1861 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1862 compatibleModeProperty->SetDisableWindowLimit(true);
1863 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1864 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1865 WindowSizeLimits windowSizeLimits = {0, 0, 0, 0};
1866 window->HandleWindowLimitsInCompatibleMode(windowSizeLimits);
1867 EXPECT_EQ(windowSizeLimits.maxWindowWidth, window->windowSystemConfig_.maxFloatingWindowSize_);
1868 EXPECT_EQ(windowSizeLimits.maxWindowHeight, window->windowSystemConfig_.maxFloatingWindowSize_);
1869 EXPECT_EQ(windowSizeLimits.minWindowWidth, window->windowSystemConfig_.miniWidthOfSubWindow_);
1870 EXPECT_EQ(windowSizeLimits.minWindowHeight, window->windowSystemConfig_.miniHeightOfSubWindow_);
1871 }
1872
1873 /**
1874 * @tc.name: HandleWindowLimitsInCompatibleMode03
1875 * @tc.desc: HandleWindowLimitsInCompatibleMode
1876 * @tc.type: FUNC
1877 */
1878 HWTEST_F(WindowSceneSessionImplTest5, HandleWindowLimitsInCompatibleMode03, Function | SmallTest | Level2)
1879 {
1880 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1881 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1882 window->property_->SetPersistentId(1);
1883 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1884 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1885 window->hostSession_ = session;
1886 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1887 compatibleModeProperty->SetDisableWindowLimit(true);
1888 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1889 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1890 WindowSizeLimits windowSizeLimits = {0, 0, 0, 0};
1891 window->HandleWindowLimitsInCompatibleMode(windowSizeLimits);
1892 EXPECT_EQ(windowSizeLimits.maxWindowWidth, window->windowSystemConfig_.maxFloatingWindowSize_);
1893 EXPECT_EQ(windowSizeLimits.maxWindowHeight, window->windowSystemConfig_.maxFloatingWindowSize_);
1894 EXPECT_EQ(windowSizeLimits.minWindowWidth, window->windowSystemConfig_.miniWidthOfDialogWindow_);
1895 EXPECT_EQ(windowSizeLimits.minWindowHeight, window->windowSystemConfig_.miniHeightOfDialogWindow_);
1896 }
1897
1898 /**
1899 * @tc.name: HandleWindowLimitsInCompatibleMode04
1900 * @tc.desc: HandleWindowLimitsInCompatibleMode
1901 * @tc.type: FUNC
1902 */
1903 HWTEST_F(WindowSceneSessionImplTest5, HandleWindowLimitsInCompatibleMode04, Function | SmallTest | Level2)
1904 {
1905 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1906 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1907 window->property_->SetPersistentId(1);
1908 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1909 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1910 window->hostSession_ = session;
1911 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1912 compatibleModeProperty->SetDisableWindowLimit(true);
1913 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1914 window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1915 WindowSizeLimits windowSizeLimits = {0, 0, 0, 0};
1916 window->HandleWindowLimitsInCompatibleMode(windowSizeLimits);
1917 EXPECT_EQ(windowSizeLimits.maxWindowWidth, window->windowSystemConfig_.maxFloatingWindowSize_);
1918 EXPECT_EQ(windowSizeLimits.maxWindowHeight, window->windowSystemConfig_.maxFloatingWindowSize_);
1919 EXPECT_EQ(windowSizeLimits.minWindowWidth, MIN_FLOATING_WIDTH);
1920 EXPECT_EQ(windowSizeLimits.minWindowHeight, MIN_FLOATING_HEIGHT);
1921 }
1922
1923 /**
1924 * @tc.name: HandleWindowLimitsInCompatibleMode05
1925 * @tc.desc: HandleWindowLimitsInCompatibleMode
1926 * @tc.type: FUNC
1927 */
1928 HWTEST_F(WindowSceneSessionImplTest5, HandleWindowLimitsInCompatibleMode05, Function | SmallTest | Level2)
1929 {
1930 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1931 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1932 window->property_->SetPersistentId(1);
1933 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1934 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1935 window->hostSession_ = session;
1936 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1937 compatibleModeProperty->SetDisableWindowLimit(true);
1938 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1939 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1940 WindowSizeLimits windowSizeLimits = {0, 0, 0, 0};
1941 window->HandleWindowLimitsInCompatibleMode(windowSizeLimits);
1942 EXPECT_EQ(windowSizeLimits.maxWindowWidth, 0);
1943 EXPECT_EQ(windowSizeLimits.maxWindowHeight, 0);
1944 EXPECT_EQ(windowSizeLimits.minWindowWidth, 0);
1945 EXPECT_EQ(windowSizeLimits.minWindowHeight, 0);
1946 }
1947
1948 /**
1949 * @tc.name: IsDecorEnable1
1950 * @tc.desc: IsDecorEnable1
1951 * @tc.type: FUNC
1952 */
1953 HWTEST_F(WindowSceneSessionImplTest5, IsDecorEnable1, Function | SmallTest | Level2)
1954 {
1955 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1956 subWindowOption->SetWindowName("IsDecorEnable1");
1957 subWindowOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1958
1959 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
1960 window->property_->SetDecorEnable(true);
1961 window->windowSystemConfig_.isSystemDecorEnable_ = true;
1962 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1963 auto ret = window->IsDecorEnable();
1964 EXPECT_EQ(false, ret);
1965 subWindowOption->SetSubWindowMaximizeSupported(true);
1966 ret = window->IsDecorEnable();
1967 EXPECT_EQ(true, ret);
1968 }
1969
1970 /**
1971 * @tc.name: GetAppForceLandscapeConfig01
1972 * @tc.desc: GetAppForceLandscapeConfig
1973 * @tc.type: FUNC
1974 */
1975 HWTEST_F(WindowSceneSessionImplTest5, GetAppForceLandscapeConfig01, TestSize.Level1)
1976 {
1977 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1978 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1979 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1980 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1981 window->hostSession_ = session;
1982
1983 window->property_->SetPersistentId(1);
1984 window->state_ = WindowState::STATE_CREATED;
1985 AppForceLandscapeConfig config = {};
1986 auto res = window->GetAppForceLandscapeConfig(config);
1987 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1988 ASSERT_EQ(res, WMError::WM_OK);
1989 EXPECT_EQ(config.mode_, 0);
1990 EXPECT_EQ(config.homePage_, "");
1991 EXPECT_EQ(config.supportSplit_, -1);
1992 EXPECT_EQ(config.arkUIOptions_, "");
1993 }
1994 }
1995
1996 /**
1997 * @tc.name: GetAppForceLandscapeConfig02
1998 * @tc.desc: GetAppForceLandscapeConfig
1999 * @tc.type: FUNC
2000 */
2001 HWTEST_F(WindowSceneSessionImplTest5, GetAppForceLandscapeConfig02, TestSize.Level1)
2002 {
2003 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2004 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2005 window->property_->SetPersistentId(1);
2006 window->hostSession_ = nullptr;
2007
2008 AppForceLandscapeConfig config = {};
2009 auto res = window->GetAppForceLandscapeConfig(config);
2010 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2011 ASSERT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2012 EXPECT_EQ(config.mode_, 0);
2013 EXPECT_EQ(config.homePage_, "");
2014 EXPECT_EQ(config.supportSplit_, -1);
2015 EXPECT_EQ(config.arkUIOptions_, "");
2016 }
2017 }
2018
2019 /**
2020 * @tc.name: NotifyAppForceLandscapeConfigUpdated01
2021 * @tc.desc: NotifyAppForceLandscapeConfigUpdated
2022 * @tc.type: FUNC
2023 */
2024 HWTEST_F(WindowSceneSessionImplTest5, NotifyAppForceLandscapeConfigUpdated01, TestSize.Level1)
2025 {
2026 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2027 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2028 window->property_->SetPersistentId(1);
2029 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
2030 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
2031 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2032 window->hostSession_ = session;
2033
2034 WSError res = window->NotifyAppForceLandscapeConfigUpdated();
2035 EXPECT_EQ(res, WSError::WS_DO_NOTHING);
2036 }
2037
2038 /**
2039 * @tc.name: NotifyAppForceLandscapeConfigUpdated02
2040 * @tc.desc: NotifyAppForceLandscapeConfigUpdated
2041 * @tc.type: FUNC
2042 */
2043 HWTEST_F(WindowSceneSessionImplTest5, NotifyAppForceLandscapeConfigUpdated02, TestSize.Level1)
2044 {
2045 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2046 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2047 window->property_->SetPersistentId(1);
2048 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
2049 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
2050 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2051 window->hostSession_ = session;
2052
2053 WSError res = window->NotifyAppForceLandscapeConfigUpdated();
2054 EXPECT_EQ(res, WSError::WS_DO_NOTHING);
2055 }
2056
2057 /**
2058 * @tc.name: SetFrameRectForPartialZoomIn01
2059 * @tc.desc: Test SetFrameRectForPartialZoomIn when window type is invalid
2060 * @tc.type: FUNC
2061 */
2062 HWTEST_F(WindowSceneSessionImplTest5, SetFrameRectForPartialZoomIn01, Function | SmallTest | Level2)
2063 {
2064 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2065 option->SetWindowName("SetFrameRectForPartialZoomIn01");
2066 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2067
2068 Rect frameRect = { 10, 10, 10, 10 }; // 10 is valid frame rect param
2069 // window type is WINDOW_TYPE_APP_MAIN_WINDOW
2070 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFrameRectForPartialZoomIn(frameRect));
2071 }
2072
2073 /**
2074 * @tc.name: SetFrameRectForPartialZoomIn02
2075 * @tc.desc: Test SetFrameRectForPartialZoomIn when window session is invalid
2076 * @tc.type: FUNC
2077 */
2078 HWTEST_F(WindowSceneSessionImplTest5, SetFrameRectForPartialZoomIn02, Function | SmallTest | Level2)
2079 {
2080 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2081 option->SetWindowName("SetFrameRectForPartialZoomIn02");
2082 option->SetWindowType(WindowType::WINDOW_TYPE_MAGNIFICATION);
2083 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2084
2085 Rect frameRect = { 10, 10, 10, 10 }; // 10 is valid frame rect param
2086 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFrameRectForPartialZoomIn(frameRect));
2087
2088 SessionInfo sessionInfo;
2089 sessionInfo.bundleName_ = "SetFrameRectForPartialZoomIn02";
2090 sessionInfo.abilityName_ = "SetFrameRectForPartialZoomIn02";
2091 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2092 window->hostSession_ = session;
2093 window->property_->persistentId_ = 100; // 100 is persistent id
2094 window->state_ = WindowState::STATE_CREATED;
2095 EXPECT_EQ(WMError::WM_OK, window->SetFrameRectForPartialZoomIn(frameRect));
2096 }
2097
2098 /**
2099 * @tc.name: GetConfigurationFromAbilityInfo
2100 * @tc.desc: GetConfigurationFromAbilityInfo
2101 * @tc.type: FUNC
2102 */
2103 HWTEST_F(WindowSceneSessionImplTest5, GetConfigurationFromAbilityInfo, TestSize.Level1)
2104 {
2105 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2106 option->SetWindowName("GetConfigurationFromAbilityInfo");
2107 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2108 std::shared_ptr<AbilityRuntime::AbilityContextImpl> context =
2109 std::make_shared<AbilityRuntime::AbilityContextImpl>();
2110 std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
2111 context->SetAbilityInfo(info);
2112 window->context_ = context;
2113 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
2114 compatibleModeProperty->SetIsSupportRotateFullScreen(true);
2115 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
2116 window->GetConfigurationFromAbilityInfo();
2117 auto supportType = window->property_->GetWindowModeSupportType();
2118 auto expceted = WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN |
2119 WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING;
2120 EXPECT_EQ(supportType & expceted, expceted);
2121 }
2122
2123 /**
2124 * @tc.name: TestMoveWindowToGlobalDisplay
2125 * @tc.desc: Test MoveWindowToGlobalDisplay under multiple conditions
2126 * @tc.type: FUNC
2127 */
2128 HWTEST_F(WindowSceneSessionImplTest5, TestMoveWindowToGlobalDisplay, TestSize.Level1)
2129 {
2130 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2131 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2132 SessionInfo sessionInfo;
2133 sptr<SessionMocker> mockHostSession = sptr<SessionMocker>::MakeSptr(sessionInfo);
2134 auto property = window->GetProperty();
2135
2136 property->SetPersistentId(123);
2137 property->SetGlobalDisplayRect({ 100, 100, 300, 300 });
2138 property->SetRequestRect({ 0, 0, 300, 300 });
2139
2140 // Case 1: session is null
2141 window->hostSession_ = nullptr;
2142 auto ret = window->MoveWindowToGlobalDisplay(100, 100);
2143 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
2144
2145 // Case 2: windowMode is not floating
2146 window->hostSession_ = mockHostSession;
2147 property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
2148 ret = window->MoveWindowToGlobalDisplay(100, 100);
2149 EXPECT_EQ(ret, WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS);
2150
2151 // Case 3: Same position
2152 property->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2153 ret = window->MoveWindowToGlobalDisplay(100, 100);
2154 EXPECT_EQ(ret, WMError::WM_OK);
2155
2156 // Case 4: Illegal position
2157 property->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2158 ret = window->MoveWindowToGlobalDisplay(INT32_MAX, INT32_MAX);
2159 EXPECT_EQ(ret, WMError::WM_ERROR_ILLEGAL_PARAM);
2160
2161 EXPECT_CALL(*mockHostSession, UpdateGlobalDisplayRectFromClient(_, _)).Times(2).WillOnce(Return(WSError::WS_OK));
2162
2163 // Case 5: Move to new position
2164 window->state_ = WindowState::STATE_SHOWN;
2165 ret = window->MoveWindowToGlobalDisplay(200, 300);
2166 EXPECT_EQ(ret, WMError::WM_OK);
2167
2168 // Case 6: Window is not shown
2169 window->state_ = WindowState::STATE_HIDDEN;
2170 ret = window->MoveWindowToGlobalDisplay(200, 300);
2171 EXPECT_EQ(ret, WMError::WM_OK);
2172 }
2173
2174 /**
2175 * @tc.name: GetDragAreaByDownEvent01
2176 * @tc.desc: GetDragAreaByDownEvent01
2177 * @tc.type: FUNC
2178 */
2179 HWTEST_F(WindowSceneSessionImplTest5, GetDragAreaByDownEvent01, TestSize.Level2)
2180 {
2181 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2182 option->SetWindowName("GetDragAreaByDownEvent01");
2183 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2184 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
2185 ASSERT_NE(nullptr, pointerEvent);
2186 MMI::PointerEvent::PointerItem pointerItem;
2187
2188 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, 0.0f);
2189 AreaType dragType = windowSceneSessionImpl->GetDragAreaByDownEvent(pointerEvent, pointerItem);
2190 EXPECT_EQ(dragType, AreaType::UNDEFINED);
2191 }
2192
2193 /**
2194 * @tc.name: GetDragAreaByDownEvent02
2195 * @tc.desc: GetDragAreaByDownEvent02
2196 * @tc.type: FUNC
2197 */
2198 HWTEST_F(WindowSceneSessionImplTest5, GetDragAreaByDownEvent02, TestSize.Level2)
2199 {
2200 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2201 option->SetWindowName("GetDragAreaByDownEvent02");
2202 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2203 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
2204 ASSERT_NE(nullptr, pointerEvent);
2205 pointerEvent->SetSourceType(1);
2206 MMI::PointerEvent::PointerItem pointerItem;
2207
2208 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, 1.0f);
2209 Rect rect = {1, 1, 1, 1};
2210 windowSceneSessionImpl->property_->SetWindowRect(rect);
2211 pointerItem.SetWindowX(1);
2212 pointerItem.SetWindowY(1);
2213 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
2214 AreaType dragType = windowSceneSessionImpl->GetDragAreaByDownEvent(pointerEvent, pointerItem);
2215 EXPECT_EQ(dragType, AreaType::LEFT_TOP);
2216 }
2217
2218 /**
2219 * @tc.name: GetDragAreaByDownEvent03
2220 * @tc.desc: GetDragAreaByDownEvent03
2221 * @tc.type: FUNC
2222 */
2223 HWTEST_F(WindowSceneSessionImplTest5, GetDragAreaByDownEvent03, TestSize.Level2)
2224 {
2225 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2226 option->SetWindowName("GetDragAreaByDownEvent03");
2227 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2228 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
2229 ASSERT_NE(nullptr, pointerEvent);
2230 pointerEvent->SetSourceType(1);
2231 MMI::PointerEvent::PointerItem pointerItem;
2232
2233 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, 1.0f);
2234 Rect rect = {1, 1, 1, 1};
2235 windowSceneSessionImpl->property_->SetWindowRect(rect);
2236 pointerItem.SetWindowX(1);
2237 pointerItem.SetWindowY(1);
2238 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FULLSCREEN);
2239 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
2240 windowSceneSessionImpl->property_->SetDragEnabled(true);
2241 AreaType dragType = windowSceneSessionImpl->GetDragAreaByDownEvent(pointerEvent, pointerItem);
2242 EXPECT_EQ(dragType, AreaType::LEFT_TOP);
2243 }
2244
2245 /**
2246 * @tc.name: GetDragAreaByDownEvent04
2247 * @tc.desc: GetDragAreaByDownEvent04
2248 * @tc.type: FUNC
2249 */
2250 HWTEST_F(WindowSceneSessionImplTest5, GetDragAreaByDownEvent04, TestSize.Level2)
2251 {
2252 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2253 option->SetWindowName("GetDragAreaByDownEvent04");
2254 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2255 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
2256 ASSERT_NE(nullptr, pointerEvent);
2257 pointerEvent->SetSourceType(1);
2258 MMI::PointerEvent::PointerItem pointerItem;
2259 windowSceneSessionImpl->SetUniqueVirtualPixelRatio(true, 1.0f);
2260 windowSceneSessionImpl->property_->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FULLSCREEN);
2261 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
2262 windowSceneSessionImpl->property_->SetDragEnabled(false);
2263 AreaType dragType = windowSceneSessionImpl->GetDragAreaByDownEvent(pointerEvent, pointerItem);
2264 EXPECT_EQ(dragType, AreaType::UNDEFINED);
2265 }
2266
2267 /**
2268 * @tc.name: UpdateImmersiveBySwitchMode
2269 * @tc.desc: Test UpdateImmersiveBySwitchMode
2270 * @tc.type: FUNC
2271 */
2272 HWTEST_F(WindowSceneSessionImplTest5, UpdateImmersiveBySwitchMode, TestSize.Level1)
2273 {
2274 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2275 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2276 SessionInfo sessionInfo;
2277 sptr<SessionMocker> mockHostSession = sptr<SessionMocker>::MakeSptr(sessionInfo);
2278 auto property = window->GetProperty();
2279
2280 property->SetPersistentId(123);
2281
2282 window->hostSession_ = nullptr;
2283 window->enableImmersiveMode_ = true;
2284 window->UpdateImmersiveBySwitchMode(true);
2285 EXPECT_EQ(window->enableImmersiveMode_, false);
2286
2287 window->enableImmersiveMode_ = false;
2288 window->hostSession_ = nullptr;
2289 window->UpdateImmersiveBySwitchMode(true);
2290 EXPECT_EQ(window->enableImmersiveMode_, false);
2291
2292 window->enableImmersiveMode_ = false;
2293 window->hostSession_ = mockHostSession;
2294 window->UpdateImmersiveBySwitchMode(true);
2295 EXPECT_EQ(window->enableImmersiveMode_, false);
2296
2297 window->cacheEnableImmersiveMode_ = false;
2298 window->UpdateImmersiveBySwitchMode(false);
2299 EXPECT_EQ(window->enableImmersiveMode_, false);
2300
2301 window->cacheEnableImmersiveMode_ = true;
2302 window->hostSession_ = nullptr;
2303 window->UpdateImmersiveBySwitchMode(false);
2304 EXPECT_EQ(window->enableImmersiveMode_, true);
2305
2306 window->cacheEnableImmersiveMode_ = true;
2307 window->hostSession_ = mockHostSession;
2308 window->UpdateImmersiveBySwitchMode(false);
2309 EXPECT_EQ(window->enableImmersiveMode_, true);
2310 }
2311 }
2312 } // namespace Rosen
2313 } // namespace OHOS