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