1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <parameters.h>
18 #include "ability_context_impl.h"
19 #include "common_test_utils.h"
20 #include "display_info.h"
21 #include "mock_session.h"
22 #include "mock_uicontent.h"
23 #include "mock_window.h"
24 #include "mock_window_adapter.h"
25 #include "pointer_event.h"
26 #include "singleton_mocker.h"
27 #include "wm_common_inner.h"
28 #include "window_scene_session_impl.h"
29 #include "window_session_impl.h"
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 using WindowAdapterMocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
36 class WindowSceneSessionImplTest5 : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void WindowSceneSessionImplTest5::SetUpTestCase() {}
45
TearDownTestCase()46 void WindowSceneSessionImplTest5::TearDownTestCase() {}
47
SetUp()48 void WindowSceneSessionImplTest5::SetUp() {}
49
TearDown()50 void WindowSceneSessionImplTest5::TearDown() {}
51
52 namespace {
53 /**
54 * @tc.name: IgnoreClickEvent
55 * @tc.desc: IgnoreClickEvent
56 * @tc.type: FUNC
57 */
58 HWTEST_F(WindowSceneSessionImplTest5, IgnoreClickEvent, Function | SmallTest | Level2)
59 {
60 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
61 ASSERT_NE(nullptr, option);
62 option->SetWindowName("IgnoreClickEvent");
63 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
64 ASSERT_NE(nullptr, window);
65
66 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
67 ASSERT_NE(pointerEvent, nullptr);
68 pointerEvent->SetPointerAction(1);
69 window->IgnoreClickEvent(pointerEvent);
70
71 pointerEvent->SetPointerAction(4);
72 window->IgnoreClickEvent(pointerEvent);
73
74 window->isOverTouchSlop_ = true;
75 MMI::PointerEvent::PointerItem pointerItem;
76 pointerEvent->pointers_.clear();
77 pointerEvent->pointers_.push_back(pointerItem);
78 window->IgnoreClickEvent(pointerEvent);
79
80 window->isOverTouchSlop_ = false;
81 ASSERT_EQ(pointerEvent->GetPointerAction(), MMI::PointerEvent::POINTER_ACTION_CANCEL);
82 window->IgnoreClickEvent(pointerEvent);
83 }
84
85 /**
86 * @tc.name: HandleUpForCompatibleMode
87 * @tc.desc: HandleUpForCompatibleMode
88 * @tc.type: FUNC
89 */
90 HWTEST_F(WindowSceneSessionImplTest5, HandleUpForCompatibleMode, Function | SmallTest | Level2)
91 {
92 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
93 ASSERT_NE(nullptr, option);
94 option->SetWindowName("HandleUpForCompatibleMode");
95 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
96 ASSERT_NE(nullptr, window);
97
98 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
99 ASSERT_NE(pointerEvent, nullptr);
100 MMI::PointerEvent::PointerItem pointerItem;
101 window->HandleUpForCompatibleMode(pointerEvent, pointerItem);
102
103 window->isDown_ = true;
104 window->eventMapTriggerByDisplay_.clear();
105 window->eventMapTriggerByDisplay_.insert(std::pair<int32_t, std::vector<bool>>(-2, { true }));
106 window->HandleUpForCompatibleMode(pointerEvent, pointerItem);
107 }
108
109 /**
110 * @tc.name: HandleMoveForCompatibleMode
111 * @tc.desc: HandleMoveForCompatibleMode
112 * @tc.type: FUNC
113 */
114 HWTEST_F(WindowSceneSessionImplTest5, HandleMoveForCompatibleMode, Function | SmallTest | Level2)
115 {
116 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
117 ASSERT_NE(nullptr, option);
118 option->SetWindowName("HandleMoveForCompatibleMode");
119 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
120 ASSERT_NE(nullptr, window);
121
122 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
123 ASSERT_NE(pointerEvent, nullptr);
124 MMI::PointerEvent::PointerItem pointerItem;
125 window->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
126
127 window->isDown_ = true;
128 window->eventMapTriggerByDisplay_.clear();
129 window->eventMapTriggerByDisplay_.insert(std::pair<int32_t, std::vector<bool>>(-2, { true }));
130 window->HandleMoveForCompatibleMode(pointerEvent, pointerItem);
131 }
132
133 /**
134 * @tc.name: HandleDownForCompatibleMode
135 * @tc.desc: HandleDownForCompatibleMode
136 * @tc.type: FUNC
137 */
138 HWTEST_F(WindowSceneSessionImplTest5, HandleDownForCompatibleMode, Function | SmallTest | Level2)
139 {
140 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
141 ASSERT_NE(nullptr, option);
142 option->SetWindowName("HandleDownForCompatibleMode");
143 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
144 ASSERT_NE(nullptr, window);
145
146 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
147 ASSERT_NE(pointerEvent, nullptr);
148 MMI::PointerEvent::PointerItem pointerItem;
149 window->HandleDownForCompatibleMode(pointerEvent, pointerItem);
150
151 pointerEvent->pointers_.clear();
152 window->HandleDownForCompatibleMode(pointerEvent, pointerItem);
153
154 pointerEvent->pointers_.push_back(pointerItem);
155 sptr<DisplayInfo> displayInfo = nullptr;
156 auto ret = window->GetVirtualPixelRatio(displayInfo);
157 ASSERT_EQ(ret, 1.0f);
158 }
159
160 /**
161 * @tc.name: NotifyCompatibleModeEnableInPad
162 * @tc.desc: NotifyCompatibleModeEnableInPad
163 * @tc.type: FUNC
164 */
165 HWTEST_F(WindowSceneSessionImplTest5, NotifyCompatibleModeEnableInPad, Function | SmallTest | Level2)
166 {
167 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
168 ASSERT_NE(nullptr, option);
169 option->SetWindowName("HandleDownForCompatibleMode");
170 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
171 ASSERT_NE(nullptr, window);
172
173 window->hostSession_ = nullptr;
174 window->property_->persistentId_ = INVALID_SESSION_ID;
175 window->state_ = WindowState::STATE_DESTROYED;
176
177 auto ret = window->NotifyCompatibleModeEnableInPad(true);
178 ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_WINDOW);
179
180 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
181 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
182 window->hostSession_ = session;
183 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
184 window->state_ = WindowState::STATE_CREATED;
185 ret = window->NotifyCompatibleModeEnableInPad(true);
186 ASSERT_EQ(ret, WSError::WS_OK);
187 }
188
189 /**
190 * @tc.name: Maximize
191 * @tc.desc: Maximize
192 * @tc.type: FUNC
193 */
194 HWTEST_F(WindowSceneSessionImplTest5, Maximize, Function | SmallTest | Level2)
195 {
196 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
197 ASSERT_NE(nullptr, option);
198 option->SetWindowName("Maximize");
199 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
200 ASSERT_NE(nullptr, window);
201
202 window->hostSession_ = nullptr;
203 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
204 auto ret = window->Maximize(presentation);
205 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
206 }
207
208 /**
209 * @tc.name: Maximize01
210 * @tc.desc: Maximize
211 * @tc.type: FUNC
212 */
213 HWTEST_F(WindowSceneSessionImplTest5, Maximize01, Function | SmallTest | Level2)
214 {
215 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
216 ASSERT_NE(nullptr, option);
217 option->SetWindowName("Maximize");
218 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
219 ASSERT_NE(nullptr, window);
220
221 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
222 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
223 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
224 window->hostSession_ = session;
225 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
226 window->state_ = WindowState::STATE_CREATED;
227
228 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
229 auto ret = window->Maximize(presentation);
230 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
231
232 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
233 window->property_->SetWindowModeSupportType(0);
234 ret = window->Maximize(presentation);
235 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
236
237 window->property_->SetWindowModeSupportType(1);
238 SystemSessionConfig systemSessionConfig;
239 systemSessionConfig.windowUIType_ = WindowUIType::INVALID_WINDOW;
240 ret = window->Maximize(presentation);
241 ASSERT_EQ(ret, WMError::WM_OK);
242 }
243
244 /**
245 * @tc.name: Maximize02
246 * @tc.desc: Maximize
247 * @tc.type: FUNC
248 */
249 HWTEST_F(WindowSceneSessionImplTest5, Maximize02, Function | SmallTest | Level2)
250 {
251 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
252 ASSERT_NE(nullptr, option);
253 option->SetWindowName("Maximize");
254 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
255 ASSERT_NE(nullptr, window);
256
257 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
258 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
259 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
260 window->hostSession_ = session;
261 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
262 window->state_ = WindowState::STATE_CREATED;
263 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
264 window->property_->SetWindowModeSupportType(1);
265 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
266
267 presentation = MaximizePresentation::ENTER_IMMERSIVE;
268 auto ret = window->Maximize(presentation);
269 ASSERT_EQ(ret, WMError::WM_OK);
270
271 ASSERT_EQ(window->enableImmersiveMode_, true);
272
273 presentation = MaximizePresentation::EXIT_IMMERSIVE;
274 window->Maximize(presentation);
275 ASSERT_EQ(window->enableImmersiveMode_, false);
276
277 presentation = MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER;
278 window->Maximize(presentation);
279 ASSERT_EQ(window->enableImmersiveMode_, true);
280
281 presentation = MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING;
282 window->Maximize(presentation);
283 }
284
285 /**
286 * @tc.name: MoveWindowToGlobal
287 * @tc.desc: MoveWindowToGlobal
288 * @tc.type: FUNC
289 */
290 HWTEST_F(WindowSceneSessionImplTest5, MoveWindowToGlobal, Function | SmallTest | Level2)
291 {
292 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
293 ASSERT_NE(nullptr, option);
294 option->SetWindowName("MoveWindowToGlobal");
295 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
296 ASSERT_NE(nullptr, window);
297
298 window->hostSession_ = nullptr;
299 MoveConfiguration presentation;
300 auto ret = window->MoveWindowToGlobal(1, 1, presentation);
301 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
302 }
303
304 /**
305 * @tc.name: MoveWindowToGlobal01
306 * @tc.desc: MoveWindowToGlobal
307 * @tc.type: FUNC
308 */
309 HWTEST_F(WindowSceneSessionImplTest5, MoveWindowToGlobal01, Function | SmallTest | Level2)
310 {
311 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
312 ASSERT_NE(nullptr, option);
313 option->SetWindowName("Maximize");
314 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
315 ASSERT_NE(nullptr, window);
316
317 MoveConfiguration presentation;
318 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
319 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
320 window->hostSession_ = session;
321 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
322 window->state_ = WindowState::STATE_CREATED;
323
324 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
325 auto ret = window->MoveWindowToGlobal(1, 1, presentation);
326 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OP_IN_CUR_STATUS);
327
328 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
329 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
330 ret = window->MoveWindowToGlobal(1, 1, presentation);
331 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
332
333 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
334 window->MoveWindowToGlobal(1, 1, presentation);
335
336 window->state_ = WindowState::STATE_SHOWN;
337 ret = window->MoveWindowToGlobal(1, 1, presentation);
338 ASSERT_EQ(ret, WMError::WM_OK);
339 }
340
341 /**
342 * @tc.name: SetCustomDensity01
343 * @tc.desc: SetCustomDensity
344 * @tc.type: FUNC
345 */
346 HWTEST_F(WindowSceneSessionImplTest5, SetCustomDensity01, Function | SmallTest | Level2)
347 {
348 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
349 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
350 float density = 0.4f;
351 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetCustomDensity(density));
352
353 window->property_->SetPersistentId(1);
354 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
355 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
356 ASSERT_NE(nullptr, session);
357 window->hostSession_ = session;
358 window->property_->SetWindowName("SetCustomDensity01");
359 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
360 window->state_ = WindowState::STATE_CREATED;
361 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetCustomDensity(density));
362
363 density = 1.5f;
364 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
365 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetCustomDensity(density));
366
367 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
368 ASSERT_EQ(WMError::WM_OK, window->SetCustomDensity(density));
369 ASSERT_EQ(density, window->customDensity_);
370 ASSERT_EQ(WMError::WM_OK, window->SetCustomDensity(density));
371 }
372
373 /**
374 * @tc.name: IsDefaultDensityEnabled01
375 * @tc.desc: IsDefaultDensityEnabled
376 * @tc.type: FUNC
377 */
378 HWTEST_F(WindowSceneSessionImplTest5, IsDefaultDensityEnabled01, Function | SmallTest | Level2)
379 {
380 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
381 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
382 window->property_->SetPersistentId(1);
383 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
384 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
385 window->hostSession_ = session;
386 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
387 window->SetDefaultDensityEnabled(true);
388 EXPECT_EQ(true, window->GetDefaultDensityEnabled());
389 window->SetDefaultDensityEnabled(false);
390 EXPECT_EQ(false, window->GetDefaultDensityEnabled());
391 }
392
393 /**
394 * @tc.name: IsDefaultDensityEnabled02
395 * @tc.desc: IsDefaultDensityEnabled
396 * @tc.type: FUNC
397 */
398 HWTEST_F(WindowSceneSessionImplTest5, IsDefaultDensityEnabled02, Function | SmallTest | Level2)
399 {
400 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
401 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
402 window->property_->SetPersistentId(1);
403 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
404 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
405 window->hostSession_ = session;
406 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
407 EXPECT_EQ(false, window->GetDefaultDensityEnabled());
408 }
409
410
411 /**
412 * @tc.name: GetCustomDensity01
413 * @tc.desc: GetCustomDensity
414 * @tc.type: FUNC
415 */
416 HWTEST_F(WindowSceneSessionImplTest5, GetCustomDensity01, Function | SmallTest | Level2)
417 {
418 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
419 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
420 window->property_->SetPersistentId(1);
421 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
422 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
423 window->hostSession_ = session;
424 window->property_->SetWindowName("SetCustomDensity01");
425 window->state_ = WindowState::STATE_CREATED;
426 float density = 1.5f;
427 window->SetCustomDensity(density);
428 EXPECT_EQ(density, window->GetCustomDensity());
429 }
430
431 /**
432 * @tc.name: GetMainWindowCustomDensity02
433 * @tc.desc: GetMainWindowCustomDensity
434 * @tc.type: FUNC
435 */
436 HWTEST_F(WindowSceneSessionImplTest5, GetMainWindowCustomDensity01, Function | SmallTest | Level2)
437 {
438 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
439 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
440 window->property_->SetPersistentId(1);
441 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
442 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
443 window->hostSession_ = session;
444 window->property_->SetWindowName("SetCustomDensity01");
445 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
446 window->state_ = WindowState::STATE_CREATED;
447 float density = 1.5f;
448 window->SetCustomDensity(density);
449 EXPECT_EQ(density, window->GetMainWindowCustomDensity());
450 }
451
452 /**
453 * @tc.name: GetWindowDensityInfo01
454 * @tc.desc: GetWindowDensityInfo
455 * @tc.type: FUNC
456 */
457 HWTEST_F(WindowSceneSessionImplTest5, GetWindowDensityInfo01, Function | SmallTest | Level2)
458 {
459 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
460 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
461 WindowDensityInfo densityInfo;
462 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetWindowDensityInfo(densityInfo));
463
464 window->property_->SetPersistentId(1);
465 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
466 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
467 ASSERT_NE(nullptr, session);
468 window->hostSession_ = session;
469 window->property_->SetWindowName("GetWindowDensityInfo01");
470 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
471 window->state_ = WindowState::STATE_CREATED;
472 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->GetWindowDensityInfo(densityInfo));
473 }
474
475 /**
476 * @tc.name: SwitchFreeMultiWindow01
477 * @tc.desc: SwitchFreeMultiWindow
478 * @tc.type: FUNC
479 */
480 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow01, Function | SmallTest | Level2)
481 {
482 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
483 ASSERT_NE(nullptr, option);
484 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
485 ASSERT_NE(nullptr, window);
486 auto ref = window->SwitchFreeMultiWindow(false);
487 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ref);
488
489 window->property_->SetPersistentId(1);
490 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
491 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
492 window->hostSession_ = session;
493 window->property_->SetWindowName("SwitchFreeMultiWindow01");
494 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
495 ref = window->SwitchFreeMultiWindow(false);
496 ASSERT_EQ(WSError::WS_ERROR_REPEAT_OPERATION, ref);
497 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
498 ref = window->SwitchFreeMultiWindow(true);
499 ASSERT_EQ(WSError::WS_ERROR_REPEAT_OPERATION, ref);
500
501 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
502 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
503 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
504 ASSERT_EQ(WSError::WS_OK, window->SwitchFreeMultiWindow(true));
505 ASSERT_EQ(true, window->windowSystemConfig_.freeMultiWindowEnable_);
506 ASSERT_EQ(WSError::WS_OK, window->SwitchFreeMultiWindow(false));
507 ASSERT_EQ(false, window->windowSystemConfig_.freeMultiWindowEnable_);
508 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
509 }
510
511 /**
512 * @tc.name: SwitchFreeMultiWindow02
513 * @tc.desc: SwitchFreeMultiWindow
514 * @tc.type: FUNC
515 */
516 HWTEST_F(WindowSceneSessionImplTest5, SwitchFreeMultiWindow02, Function | SmallTest | Level2)
517 {
518 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
519 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
520 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
521
522 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
523 mainWindow->property_->SetPersistentId(1);
524 mainWindow->hostSession_ = session;
525 mainWindow->property_->SetWindowName("SwitchFreeMultiWindow02_mainWindow");
526 mainWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
527 mainWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
528 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
529 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
530 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
531 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
532
533 sptr<WindowSceneSessionImpl> floatWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
534 floatWindow->property_->SetPersistentId(2);
535 floatWindow->hostSession_ = session;
536 floatWindow->property_->SetWindowName("SwitchFreeMultiWindow02_floatWindow");
537 floatWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
538 floatWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
539 floatWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
540 floatWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
541 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(floatWindow->GetWindowName(),
542 std::pair<uint64_t, sptr<WindowSessionImpl>>(floatWindow->GetWindowId(), floatWindow)));
543
544 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
545 subWindow->property_->SetPersistentId(3);
546 subWindow->hostSession_ = session;
547 subWindow->property_->SetWindowName("SwitchFreeMultiWindow03_subWindow");
548 subWindow->windowSystemConfig_.freeMultiWindowEnable_ = false;
549 subWindow->windowSystemConfig_.freeMultiWindowSupport_ = true;
550 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
551 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
552 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
553
554 EXPECT_EQ(false, mainWindow->IsPcOrPadFreeMultiWindowMode());
555 EXPECT_EQ(false, floatWindow->IsPcOrPadFreeMultiWindowMode());
556 EXPECT_EQ(false, subWindow->IsPcOrPadFreeMultiWindowMode());
557 EXPECT_EQ(WSError::WS_OK, mainWindow->SwitchFreeMultiWindow(true));
558 EXPECT_EQ(true, mainWindow->IsPcOrPadFreeMultiWindowMode());
559 EXPECT_EQ(true, floatWindow->IsPcOrPadFreeMultiWindowMode());
560 EXPECT_EQ(true, subWindow->IsPcOrPadFreeMultiWindowMode());
561
562 EXPECT_EQ(WMError::WM_OK, mainWindow->Destroy(true));
563 EXPECT_EQ(WMError::WM_OK, floatWindow->Destroy(true));
564 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
565 }
566
567 /**
568 * @tc.name: ShowKeyboard01
569 * @tc.desc: SwitchFreeMultiWindow
570 * @tc.type: FUNC
571 */
572 HWTEST_F(WindowSceneSessionImplTest5, ShowKeyboard01, Function | SmallTest | Level2)
573 {
574 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
575 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
576 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
577
578 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
579 keyboardWindow->property_->SetPersistentId(1000);
580 keyboardWindow->hostSession_ = session;
581 keyboardWindow->property_->SetWindowName("SwitchFreeMultiWindow02_mainWindow");
582 keyboardWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
583 keyboardWindow->state_ = WindowState::STATE_DESTROYED;
584
585 // normal value
586 ASSERT_EQ(keyboardWindow->ShowKeyboard(KeyboardViewMode::DARK_IMMERSIVE_MODE), WMError::WM_ERROR_INVALID_WINDOW);
587
588 // exception value
589 ASSERT_EQ(keyboardWindow->ShowKeyboard(KeyboardViewMode::VIEW_MODE_END), WMError::WM_ERROR_INVALID_WINDOW);
590 ASSERT_EQ(keyboardWindow->property_->GetKeyboardViewMode(), KeyboardViewMode::NON_IMMERSIVE_MODE);
591 }
592
593 /**
594 * @tc.name: ChangeKeyboardViewMode01
595 * @tc.desc: SwitchFreeMultiWindow
596 * @tc.type: FUNC
597 */
598 HWTEST_F(WindowSceneSessionImplTest5, ChangeKeyboardViewMode01, Function | SmallTest | Level2)
599 {
600 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
601 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
602 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
603
604 sptr<WindowSceneSessionImpl> keyboardWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
605 keyboardWindow->property_->SetPersistentId(1000);
606 keyboardWindow->hostSession_ = session;
607 keyboardWindow->property_->SetWindowName("SwitchFreeMultiWindow02_mainWindow");
608 keyboardWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
609 keyboardWindow->property_->SetKeyboardViewMode(KeyboardViewMode::NON_IMMERSIVE_MODE);
610
611 auto result = WMError::WM_OK;
612 // exception mode value
613 result = keyboardWindow->ChangeKeyboardViewMode(KeyboardViewMode::VIEW_MODE_END);
614 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
615
616 // same mode
617 result = keyboardWindow->ChangeKeyboardViewMode(KeyboardViewMode::NON_IMMERSIVE_MODE);
618 ASSERT_EQ(result, WMError::WM_DO_NOTHING);
619
620 // invalid window state
621 keyboardWindow->state_ = WindowState::STATE_DESTROYED;
622 result = keyboardWindow->ChangeKeyboardViewMode(KeyboardViewMode::LIGHT_IMMERSIVE_MODE);
623 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_WINDOW);
624
625 // window state not shown
626 keyboardWindow->state_ = WindowState::STATE_HIDDEN;
627 result = keyboardWindow->ChangeKeyboardViewMode(KeyboardViewMode::LIGHT_IMMERSIVE_MODE);
628 ASSERT_EQ(result, WMError::WM_ERROR_INVALID_WINDOW);
629
630 keyboardWindow->state_ = WindowState::STATE_SHOWN;
631 result = keyboardWindow->ChangeKeyboardViewMode(KeyboardViewMode::DARK_IMMERSIVE_MODE);
632 ASSERT_EQ(result, WMError::WM_OK);
633 auto currentMode = keyboardWindow->property_->GetKeyboardViewMode();
634 ASSERT_EQ(currentMode, KeyboardViewMode::DARK_IMMERSIVE_MODE);
635 }
636
637 /**
638 * @tc.name: StartMoveWindowWithCoordinate_01
639 * @tc.desc: StartMoveWindowWithCoordinate
640 * @tc.type: FUNC
641 */
642 HWTEST_F(WindowSceneSessionImplTest5, StartMoveWindowWithCoordinate_01, Function | SmallTest | Level2)
643 {
644 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
645 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
646 window->property_->SetPersistentId(1);
647 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
648 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
649 window->hostSession_ = session;
650
651 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
652 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
653
654 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
655 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
656
657 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
658 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
659 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
660 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
661
662 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
663 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
664 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
665 window->property_->SetIsPcAppInPad(true);
666 ASSERT_NE(window->StartMoveWindowWithCoordinate(100, 50), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
667 }
668
669 /**
670 * @tc.name: StartMoveWindowWithCoordinate_02
671 * @tc.desc: StartMoveWindowWithCoordinate
672 * @tc.type: FUNC
673 */
674 HWTEST_F(WindowSceneSessionImplTest5, StartMoveWindowWithCoordinate_02, Function | SmallTest | Level2)
675 {
676 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
677 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
678 window->property_->SetPersistentId(1);
679 Rect windowRect = { 200, 200, 1000, 1000 };
680 window->property_->SetWindowRect(windowRect);
681 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
682 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
683 window->hostSession_ = session;
684 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
685
686 ASSERT_EQ(window->StartMoveWindowWithCoordinate(-1, 50), WmErrorCode::WM_ERROR_INVALID_PARAM);
687 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, -1), WmErrorCode::WM_ERROR_INVALID_PARAM);
688 ASSERT_EQ(window->StartMoveWindowWithCoordinate(1500, 50), WmErrorCode::WM_ERROR_INVALID_PARAM);
689 ASSERT_EQ(window->StartMoveWindowWithCoordinate(100, 1500), WmErrorCode::WM_ERROR_INVALID_PARAM);
690 }
691
692 /**
693 * @tc.name: UpdateSystemBarProperties
694 * @tc.desc: UpdateSystemBarProperties test
695 * @tc.type: FUNC
696 */
697 HWTEST_F(WindowSceneSessionImplTest5, UpdateSystemBarProperties, Function | SmallTest | Level3)
698 {
699 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
700 option->SetWindowName("UpdateSystemBarProperties");
701 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
702 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
703 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
704 std::unordered_map<WindowType, SystemBarProperty> systemBarProperties;
705 std::unordered_map<WindowType, SystemBarPropertyFlag> systemBarPropertyFlags;
706 ASSERT_EQ(WMError::WM_OK, window->UpdateSystemBarProperties(systemBarProperties, systemBarPropertyFlags));
707 }
708
709 /**
710 * @tc.name: NotifyAfterDidForeground
711 * @tc.desc: NotifyAfterDidForeground
712 * @tc.type: FUNC
713 */
714 HWTEST_F(WindowSceneSessionImplTest5, NotifyAfterDidForeground, Function | SmallTest | Level2)
715 {
716 sptr<MockWindowLifeCycleListener> mockListener = sptr<MockWindowLifeCycleListener>::MakeSptr();
717 sptr<IWindowLifeCycle> listener = static_cast<sptr<IWindowLifeCycle>>(mockListener);
718
719 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
720 option->SetWindowName("Test");
721 option->SetDisplayId(0);
722
723 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
724 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
725
726 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
727 window->property_->SetPersistentId(1);
728 window->hostSession_ = session;
729 window->RegisterLifeCycleListener(listener);
730
731 EXPECT_CALL(*mockListener, AfterDidForeground()).Times(1);
732 ASSERT_EQ(WMError::WM_OK, window->Show(static_cast<uint32_t>(WindowStateChangeReason::ABILITY_CALL), false));
733 }
734
735 /**
736 * @tc.name: NotifyAfterDidBackground
737 * @tc.desc: NotifyAfterDidBackground
738 * @tc.type: FUNC
739 */
740 HWTEST_F(WindowSceneSessionImplTest5, NotifyAfterDidBackground, Function | SmallTest | Level2)
741 {
742 sptr<MockWindowLifeCycleListener> mockListener = sptr<MockWindowLifeCycleListener>::MakeSptr();
743 sptr<IWindowLifeCycle> listener = static_cast<sptr<IWindowLifeCycle>>(mockListener);
744
745 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
746 option->SetWindowName("Test");
747 option->SetDisplayId(0);
748
749 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
750 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
751
752 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
753 window->property_->SetPersistentId(1);
754 window->hostSession_ = session;
755 window->RegisterLifeCycleListener(listener);
756
757 EXPECT_CALL(*mockListener, AfterDidBackground()).Times(1);
758 ASSERT_EQ(WMError::WM_OK, window->Hide(static_cast<uint32_t>(WindowStateChangeReason::ABILITY_CALL), false, false));
759 }
760
761 /**
762 * @tc.name: Resume
763 * @tc.desc: Resume
764 * @tc.type: FUNC
765 */
766 HWTEST_F(WindowSceneSessionImplTest5, Resume, Function | SmallTest | Level2)
767 {
768 sptr<MockWindowLifeCycleListener> mockListener = sptr<MockWindowLifeCycleListener>::MakeSptr();
769 sptr<IWindowLifeCycle> listener = static_cast<sptr<IWindowLifeCycle>>(mockListener);
770
771 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
772 option->SetWindowName("Test");
773 option->SetDisplayId(0);
774
775 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
776 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
777
778 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
779 window->property_->SetPersistentId(1);
780 window->hostSession_ = session;
781 window->RegisterLifeCycleListener(listener);
782 window->SetTargetAPIVersion(16);
783
784 EXPECT_CALL(*mockListener, AfterResumed()).Times(1);
785 window->Resume();
786 }
787
788 /**
789 * @tc.name: GetParentWindow01
790 * @tc.desc: GetParentWindow
791 * @tc.type: FUNC
792 */
793 HWTEST_F(WindowSceneSessionImplTest5, GetParentWindow01, Function | SmallTest | Level2)
794 {
795 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
796 option->SetWindowName("GetParentWindow01");
797 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
798 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
799 sptr<Window> parentWindow = nullptr;
800 auto res = window->GetParentWindow(parentWindow);
801 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
802
803 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
804 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
805 window->hostSession_ = session;
806 window->property_->SetPersistentId(1);
807 window->property_->SetParentPersistentId(2);
808 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
809 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
810 res = window->GetParentWindow(parentWindow);
811 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
812
813 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
814 res = window->GetParentWindow(parentWindow);
815 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
816
817 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
818 window->property_->SetIsUIExtFirstSubWindow(true);
819 res = window->GetParentWindow(parentWindow);
820 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
821
822 window->property_->SetIsUIExtFirstSubWindow(false);
823 res = window->GetParentWindow(parentWindow);
824 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
825 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
826 }
827
828 /**
829 * @tc.name: GetParentWindow02
830 * @tc.desc: GetParentWindow
831 * @tc.type: FUNC
832 */
833 HWTEST_F(WindowSceneSessionImplTest5, GetParentWindow02, Function | SmallTest | Level2)
834 {
835 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
836 option->SetWindowName("GetParentWindow01_parentWindow");
837 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
838 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
839 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
840 mainWindow->hostSession_ = session;
841 mainWindow->property_->SetPersistentId(1);
842 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
843 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
844 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
845 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
846
847 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
848 subWindowOption->SetWindowName("GetParentWindow01_subWindow");
849 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
850 subWindow->property_->SetPersistentId(2);
851 subWindow->property_->SetParentPersistentId(1);
852 subWindow->hostSession_ = session;
853 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
854 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
855 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
856 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
857
858 sptr<Window> parentWindow = nullptr;
859 auto res = subWindow->GetParentWindow(parentWindow);
860 EXPECT_EQ(res, WMError::WM_OK);
861 ASSERT_NE(parentWindow, nullptr);
862 EXPECT_EQ(parentWindow->GetWindowName(), mainWindow->GetWindowName());
863 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
864 EXPECT_EQ(WMError::WM_OK, mainWindow->Destroy(true));
865 }
866
867 /**
868 * @tc.name: SetParentWindow01
869 * @tc.desc: SetParentWindow
870 * @tc.type: FUNC
871 */
872 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow01, Function | SmallTest | Level2)
873 {
874 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
875 option->SetWindowName("SetParentWindow01");
876 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
877 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
878 int32_t newParentWindowId = 2;
879 auto res = window->SetParentWindow(newParentWindowId);
880 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
881
882 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
883 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
884 window->hostSession_ = session;
885 window->property_->SetPersistentId(1);
886 window->property_->SetParentPersistentId(2);
887 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
888 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
889 res = window->SetParentWindow(newParentWindowId);
890 EXPECT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
891
892 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
893 res = window->SetParentWindow(newParentWindowId);
894 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_CALLING);
895
896 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
897 newParentWindowId = 1;
898 res = window->SetParentWindow(newParentWindowId);
899 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
900 newParentWindowId = 2;
901 res = window->SetParentWindow(newParentWindowId);
902 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
903 newParentWindowId = 3;
904 res = window->SetParentWindow(newParentWindowId);
905 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
906 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
907 }
908
909 /**
910 * @tc.name: SetParentWindow02
911 * @tc.desc: SetParentWindow
912 * @tc.type: FUNC
913 */
914 HWTEST_F(WindowSceneSessionImplTest5, SetParentWindow02, Function | SmallTest | Level2)
915 {
916 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
917 option->SetWindowName("SetParentWindow01_parentWindow");
918 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
919 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
920 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
921 mainWindow->hostSession_ = session;
922 mainWindow->property_->SetPersistentId(1);
923 mainWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
924 mainWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
925 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(mainWindow->GetWindowName(),
926 std::pair<uint64_t, sptr<WindowSessionImpl>>(mainWindow->GetWindowId(), mainWindow)));
927
928 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
929 subWindowOption->SetWindowName("SetParentWindow01_subWindow");
930 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subWindowOption);
931 subWindow->property_->SetPersistentId(2);
932 subWindow->property_->SetParentPersistentId(1);
933 subWindow->hostSession_ = session;
934 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
935 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
936 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(subWindow->GetWindowName(),
937 std::pair<uint64_t, sptr<WindowSessionImpl>>(subWindow->GetWindowId(), subWindow)));
938
939 sptr<WindowOption> newParentWindowOption = sptr<WindowOption>::MakeSptr();
940 newParentWindowOption->SetWindowName("SetParentWindow01_newParentWindow");
941 sptr<WindowSceneSessionImpl> newParentWindow = sptr<WindowSceneSessionImpl>::MakeSptr(newParentWindowOption);
942 newParentWindow->property_->SetPersistentId(3);
943 newParentWindow->property_->SetParentPersistentId(1);
944 newParentWindow->hostSession_ = session;
945 newParentWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
946 newParentWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
947 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(newParentWindow->GetWindowName(),
948 std::pair<uint64_t, sptr<WindowSessionImpl>>(newParentWindow->GetWindowId(), newParentWindow)));
949
950 int32_t newParentWindowId = 3;
951 auto res = subWindow->SetParentWindow(newParentWindowId);
952 EXPECT_EQ(res, WMError::WM_ERROR_INVALID_PARENT);
953 newParentWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
954 WindowAdapterMocker mocker;
955 EXPECT_CALL(mocker.Mock(), SetParentWindow(_, _)).WillOnce(Return(WMError::WM_OK));
956 res = subWindow->SetParentWindow(newParentWindowId);
957 EXPECT_EQ(res, WMError::WM_OK);
958 sptr<Window> parentWindow = nullptr;
959 EXPECT_EQ(subWindow->GetParentWindow(parentWindow), WMError::WM_OK);
960 ASSERT_NE(parentWindow, nullptr);
961 EXPECT_EQ(parentWindow->GetWindowName(), newParentWindow->GetWindowName());
962 }
963
964 /**
965 * @tc.name: SetFollowParentWindowLayoutEnabled
966 * @tc.desc: SetFollowParentWindowLayoutEnabled
967 * @tc.type: FUNC
968 */
969 HWTEST_F(WindowSceneSessionImplTest5, SetFollowParentWindowLayoutEnabled01, Function | SmallTest | Level2)
970 {
971 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
972 option->SetWindowName("SetFollowParentWindowLayoutEnabled01");
973 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
974 auto property = window->GetProperty();
975
976 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
977 WMError ret = window->SetFollowParentWindowLayoutEnabled(true);
978 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
979
980 SessionInfo sessionInfo;
981 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
982 window->hostSession_ = session;
983 property->persistentId_ = 100;
984 window->state_ = WindowState::STATE_CREATED;
985 ret = window->SetFollowParentWindowLayoutEnabled(true);
986 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
987
988 property->subWindowLevel_ = 100;
989 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
990 ret = window->SetFollowParentWindowLayoutEnabled(true);
991 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
992
993 property->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
994 ret = window->SetFollowParentWindowLayoutEnabled(true);
995 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
996
997 property->subWindowLevel_ = 1;
998 ret = window->SetFollowParentWindowLayoutEnabled(true);
999 ASSERT_EQ(ret, WMError::WM_OK);
1000 }
1001
1002 /**
1003 * @tc.name: TransferLifeCycleEventToString
1004 * @tc.desc: TransferLifeCycleEventToString
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(WindowSceneSessionImplTest5, TransferLifeCycleEventToString, Function | SmallTest | Level2)
1008 {
1009 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1010 option->SetWindowName("TransferLifeCycleEventToString");
1011 option->SetDisplayId(0);
1012 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1013 ASSERT_NE(window, nullptr);
1014 window->RecordLifeCycleExceptionEvent(LifeCycleEvent::CREATE_EVENT, WMError::WM_ERROR_REPEAT_OPERATION);
1015 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::CREATE_EVENT), "CREATE");
1016 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::SHOW_EVENT), "SHOW");
1017 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::HIDE_EVENT), "HIDE");
1018 ASSERT_EQ(window->TransferLifeCycleEventToString(LifeCycleEvent::DESTROY_EVENT), "DESTROY");
1019 }
1020 }
1021 } // namespace Rosen
1022 } // namespace OHOS