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 WindowSceneSessionImplTest3 : 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 WindowSceneSessionImplTest3::SetUpTestCase() {}
49
TearDownTestCase()50 void WindowSceneSessionImplTest3::TearDownTestCase() {}
51
SetUp()52 void WindowSceneSessionImplTest3::SetUp()
53 {
54 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
55 }
56
TearDown()57 void WindowSceneSessionImplTest3::TearDown()
58 {
59 usleep(WAIT_SYNC_IN_NS);
60 abilityContext_ = nullptr;
61 }
62
CreateRSSurfaceNode()63 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest3::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: UpdateOrientation
74 * @tc.desc: UpdateOrientation
75 * @tc.type: FUNC
76 */
77 HWTEST_F(WindowSceneSessionImplTest3, UpdateOrientation, TestSize.Level1)
78 {
79 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
80 option->SetWindowName("UpdateOrientation");
81 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
82
83 auto ret = windowSceneSessionImpl->UpdateOrientation();
84 EXPECT_EQ(WSError::WS_OK, ret);
85
86 windowSceneSessionImpl->hostSession_ = nullptr;
87 windowSceneSessionImpl->UpdateDensity();
88
89 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
90 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
91 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
92 windowSceneSessionImpl->property_->SetPersistentId(1);
93 windowSceneSessionImpl->hostSession_ = session;
94 windowSceneSessionImpl->UpdateDensity();
95
96 windowSceneSessionImpl->userLimitsSet_ = true;
97 windowSceneSessionImpl->UpdateDensity();
98 }
99
100 /**
101 * @tc.name: SetWindowMask
102 * @tc.desc: SetWindowMask
103 * @tc.type: FUNC
104 */
105 HWTEST_F(WindowSceneSessionImplTest3, SetWindowMask, TestSize.Level1)
106 {
107 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
108 option->SetWindowName("SetWindowMask");
109 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
110 std::vector<std::vector<uint32_t>> windowMask;
111
112 windowSceneSessionImpl->hostSession_ = nullptr;
113 auto ret = windowSceneSessionImpl->SetWindowMask(windowMask);
114 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
115
116 windowSceneSessionImpl->property_->SetPersistentId(1);
117 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
118 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
119 windowSceneSessionImpl->hostSession_ = session;
120 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
121 ret = windowSceneSessionImpl->SetWindowMask(windowMask);
122 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
123 windowMask = { { 1, 1, 1 }, { 2, 2, 2 }, { 3, 3, 3 } };
124 ret = windowSceneSessionImpl->SetWindowMask(windowMask);
125 EXPECT_EQ(WMError::WM_OK, ret);
126 EXPECT_FALSE(nullptr == windowSceneSessionImpl->HandleWindowMask(windowMask));
127 Rect rect = { 9, 9, 9, 9 };
128 windowSceneSessionImpl->property_->SetRequestRect(rect);
129 EXPECT_TRUE(nullptr == windowSceneSessionImpl->HandleWindowMask(windowMask));
130 rect = { 3, 3, 3, 3 };
131 windowSceneSessionImpl->property_->SetRequestRect(rect);
132 EXPECT_FALSE(nullptr == windowSceneSessionImpl->HandleWindowMask(windowMask));
133 rect = { 2, 2, 2, 2 };
134 windowSceneSessionImpl->property_->SetRequestRect(rect);
135 EXPECT_TRUE(nullptr == windowSceneSessionImpl->HandleWindowMask(windowMask));
136 rect = { 0, 0, 0, 0 };
137 windowSceneSessionImpl->property_->SetRequestRect(rect);
138 EXPECT_FALSE(nullptr == windowSceneSessionImpl->HandleWindowMask(windowMask));
139 }
140
141 /**
142 * @tc.name: UpdateTitleInTargetPos
143 * @tc.desc: UpdateTitleInTargetPos
144 * @tc.type: FUNC
145 */
146 HWTEST_F(WindowSceneSessionImplTest3, UpdateTitleInTargetPos, TestSize.Level1)
147 {
148 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
149 option->SetWindowName("UpdateTitleInTargetPos");
150 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
151
152 auto ret = windowSceneSessionImpl->UpdateTitleInTargetPos(true, 0);
153 EXPECT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ret);
154 ret = windowSceneSessionImpl->UpdateTitleInTargetPos(false, 0);
155 EXPECT_EQ(WSError::WS_ERROR_INVALID_WINDOW, ret);
156 windowSceneSessionImpl->property_->SetPersistentId(1);
157 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
158 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
159 windowSceneSessionImpl->hostSession_ = session;
160 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
161 windowSceneSessionImpl->windowSessionMap_.insert(
162 std::make_pair(windowSceneSessionImpl->GetWindowName(),
163 std::make_pair(windowSceneSessionImpl->GetWindowId(), windowSceneSessionImpl)));
164 ret = windowSceneSessionImpl->SwitchFreeMultiWindow(true);
165 EXPECT_EQ(WSError::WS_OK, ret);
166 ret = windowSceneSessionImpl->SwitchFreeMultiWindow(false);
167 EXPECT_EQ(WSError::WS_OK, ret);
168
169 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
170 ASSERT_NE(nullptr, windowSceneSessionImpl->uiContent_);
171 ret = windowSceneSessionImpl->UpdateTitleInTargetPos(true, 0);
172 EXPECT_EQ(WSError::WS_OK, ret);
173 ret = windowSceneSessionImpl->UpdateTitleInTargetPos(false, 0);
174 EXPECT_EQ(WSError::WS_OK, ret);
175
176 windowSceneSessionImpl->uiContent_ = nullptr;
177 ret = windowSceneSessionImpl->UpdateTitleInTargetPos(true, 0);
178 EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
179 ret = windowSceneSessionImpl->UpdateTitleInTargetPos(false, 0);
180 EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
181 windowSceneSessionImpl->windowSessionMap_.erase(windowSceneSessionImpl->GetWindowName());
182 }
183
184 /**
185 * @tc.name: CheckParmAndPermission01
186 * @tc.desc: CheckParmAndPermission
187 * @tc.type: FUNC
188 */
189 HWTEST_F(WindowSceneSessionImplTest3, CheckParmAndPermission01, TestSize.Level1)
190 {
191 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
192 option->SetWindowName("CheckParmAndPermission01");
193 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
194 windowSceneSessionImpl->surfaceNode_ = nullptr;
195
196 auto ret = windowSceneSessionImpl->CheckParmAndPermission();
197 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
198 ret = windowSceneSessionImpl->SetCornerRadius(1.0f);
199 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
200 auto surfaceNode_mocker = CreateRSSurfaceNode();
201 ASSERT_NE(nullptr, surfaceNode_mocker);
202 windowSceneSessionImpl->surfaceNode_ = surfaceNode_mocker;
203 ret = windowSceneSessionImpl->CheckParmAndPermission();
204 EXPECT_EQ(WMError::WM_OK, ret);
205 }
206
207 /**
208 * @tc.name: PerformBack
209 * @tc.desc: PerformBack
210 * @tc.type: FUNC
211 */
212 HWTEST_F(WindowSceneSessionImplTest3, PerformBack, TestSize.Level1)
213 {
214 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
215 option->SetWindowName("PerformBack");
216 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
217
218 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
219 windowSceneSessionImpl->PerformBack();
220
221 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
222 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
223 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
224 windowSceneSessionImpl->property_->SetPersistentId(1);
225 windowSceneSessionImpl->hostSession_ = session;
226 ASSERT_NE(nullptr, abilityContext_);
227 windowSceneSessionImpl->context_ = abilityContext_;
228 windowSceneSessionImpl->PerformBack();
229 windowSceneSessionImpl->context_ = nullptr;
230 windowSceneSessionImpl->PerformBack();
231
232 windowSceneSessionImpl->hostSession_ = nullptr;
233 windowSceneSessionImpl->PerformBack();
234 }
235
236 /**
237 * @tc.name: AdjustKeyboardLayout
238 * @tc.desc: AdjustKeyboardLayout
239 * @tc.type: FUNC
240 */
241 HWTEST_F(WindowSceneSessionImplTest3, AdjustKeyboardLayout, TestSize.Level1)
242 {
243 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
244 option->SetWindowName("AdjustKeyboardLayout");
245 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
246 KeyboardLayoutParams params;
247
248 auto ret = windowSceneSessionImpl->AdjustKeyboardLayout(params);
249 EXPECT_EQ(WMError::WM_OK, ret);
250
251 windowSceneSessionImpl->hostSession_ = nullptr;
252 ret = windowSceneSessionImpl->AdjustKeyboardLayout(params);
253 EXPECT_EQ(WMError::WM_OK, ret);
254 }
255
256 /**
257 * @tc.name: UpdateSubWindowState
258 * @tc.desc: UpdateSubWindowState
259 * @tc.type: FUNC
260 */
261 HWTEST_F(WindowSceneSessionImplTest3, UpdateSubWindowState, TestSize.Level1)
262 {
263 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
264 option->SetWindowName("UpdateSubWindowState");
265 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
266 WindowType type = WindowType::APP_SUB_WINDOW_BASE;
267 ASSERT_NE(nullptr, windowSceneSessionImpl);
268
269 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
270 windowSceneSessionImpl->UpdateSubWindowState(type);
271 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
272 windowSceneSessionImpl->UpdateSubWindowState(type);
273 type = WindowType::SYSTEM_WINDOW_BASE;
274 windowSceneSessionImpl->UpdateSubWindowState(type);
275 type = WindowType::APP_MAIN_WINDOW_BASE;
276 windowSceneSessionImpl->UpdateSubWindowState(type);
277 ASSERT_EQ(false, windowSceneSessionImpl->GetDefaultDensityEnabled());
278 }
279
280 /**
281 * @tc.name: GetWindowFlags
282 * @tc.desc: GetWindowFlags
283 * @tc.type: FUNC
284 */
285 HWTEST_F(WindowSceneSessionImplTest3, GetWindowFlags, TestSize.Level1)
286 {
287 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
288 option->SetWindowName("GetWindowFlags");
289 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
290 windowSceneSessionImpl->property_->SetWindowFlags(0);
291 auto ret = windowSceneSessionImpl->GetWindowFlags();
292 EXPECT_EQ(0, ret);
293 }
294
295 /**
296 * @tc.name: IsApplicationModalSubWindowShowing
297 * @tc.desc: Test whether application modal sub window could be detected correctly
298 * @tc.type: FUNC
299 */
300 HWTEST_F(WindowSceneSessionImplTest3, IsApplicationModalSubWindowShowing, TestSize.Level1)
301 {
302 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
303 option->SetWindowName("IsApplicationModalSubWindowShowing_ParentWindow");
304 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
305 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
306 window->property_->SetPersistentId(101);
307
308 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
309 subOption->SetWindowName("IsApplicationModalSubWindowShowing_SubWindow1");
310 subOption->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
311 sptr<WindowSceneSessionImpl> subWindow1 = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
312 subWindow1->property_->SetPersistentId(102);
313 subWindow1->property_->SetParentPersistentId(101);
314 window->subWindowSessionMap_[window->GetPersistentId()].push_back(subWindow1);
315 EXPECT_EQ(false, window->IsApplicationModalSubWindowShowing(101));
316
317 subOption->SetWindowName("IsApplicationModalSubWindowShowing_SubWindow2");
318 sptr<WindowSceneSessionImpl> subWindow2 = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
319 subWindow2->property_->SetPersistentId(103);
320 subWindow2->property_->SetParentPersistentId(101);
321 subWindow2->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
322 subWindow2->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_APPLICATION_MODAL);
323 subWindow2->state_ = WindowState::STATE_SHOWN;
324 window->subWindowSessionMap_[window->GetPersistentId()].push_back(subWindow2);
325 EXPECT_EQ(false, window->IsApplicationModalSubWindowShowing(101));
326 }
327
328 /**
329 * @tc.name: NotifyPrepareClosePiPWindow
330 * @tc.desc: NotifyPrepareClosePiPWindow
331 * @tc.type: FUNC
332 */
333 HWTEST_F(WindowSceneSessionImplTest3, NotifyPrepareClosePiPWindow, TestSize.Level1)
334 {
335 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
336 option->SetWindowName("NotifyPrepareClosePiPWindow");
337 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
338 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
339 auto ret = windowSceneSessionImpl->NotifyPrepareClosePiPWindow();
340 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
341
342 auto ret1 = windowSceneSessionImpl->KeepKeyboardOnFocus(true);
343 EXPECT_EQ(WmErrorCode::WM_OK, ret1);
344 }
345
346 /**
347 * @tc.name: NotifyWindowSessionProperty
348 * @tc.desc: NotifyWindowSessionProperty
349 * @tc.type: FUNC
350 */
351 HWTEST_F(WindowSceneSessionImplTest3, NotifyWindowSessionProperty, TestSize.Level1)
352 {
353 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
354 option->SetWindowName("NotifyWindowSessionProperty");
355 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
356
357 auto ret = windowSceneSessionImpl->NotifyWindowSessionProperty();
358 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
359 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
360 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
361 windowSceneSessionImpl->property_->SetPersistentId(1);
362 windowSceneSessionImpl->hostSession_ = session;
363 ret = windowSceneSessionImpl->NotifyWindowSessionProperty();
364 EXPECT_EQ(WMError::WM_OK, ret);
365 }
366
367 /**
368 * @tc.name: AddWindowFlag01
369 * @tc.desc: AddWindowFlag
370 * @tc.type: FUNC
371 */
372 HWTEST_F(WindowSceneSessionImplTest3, AddWindowFlag01, TestSize.Level1)
373 {
374 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
375 option->SetWindowName("AddWindowFlag");
376 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
377
378 auto ret = windowSceneSessionImpl->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
379 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
380 }
381
382 /**
383 * @tc.name: AddWindowFlag02
384 * @tc.desc: AddWindowFlag
385 * @tc.type: FUNC
386 */
387 HWTEST_F(WindowSceneSessionImplTest3, AddWindowFlag02, TestSize.Level1)
388 {
389 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
390 option->SetWindowName("AddWindowFlag02");
391 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
392 windowSceneSessionImpl->property_->SetPersistentId(10001);
393 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
394 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
395 windowSceneSessionImpl->hostSession_ = session;
396
397 auto ret = windowSceneSessionImpl->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
398 EXPECT_EQ(WMError::WM_OK, ret);
399 EXPECT_TRUE(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID) & windowSceneSessionImpl->GetWindowFlags());
400 }
401
402 /**
403 * @tc.name: AddWindowFlag03
404 * @tc.desc: AddWindowFlag
405 * @tc.type: FUNC
406 */
407 HWTEST_F(WindowSceneSessionImplTest3, AddWindowFlag03, TestSize.Level1)
408 {
409 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
410 option->SetWindowName("AddWindowFlag03");
411 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
412 windowSceneSessionImpl->property_->SetPersistentId(10001);
413 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
414 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
415 windowSceneSessionImpl->hostSession_ = session;
416
417 auto ret = windowSceneSessionImpl->AddWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
418 EXPECT_EQ(WMError::WM_OK, ret);
419 EXPECT_TRUE(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE) &
420 windowSceneSessionImpl->GetWindowFlags());
421 }
422
423 /**
424 * @tc.name: AddWindowFlag04
425 * @tc.desc: AddWindowFlag
426 * @tc.type: FUNC
427 */
428 HWTEST_F(WindowSceneSessionImplTest3, AddWindowFlag04, TestSize.Level1)
429 {
430 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
431 option->SetWindowName("AddWindowFlag04");
432 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
433 windowSceneSessionImpl->property_->SetPersistentId(10001);
434 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
435 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
436 windowSceneSessionImpl->hostSession_ = session;
437
438 auto ret = windowSceneSessionImpl->AddWindowFlag(WindowFlag::WINDOW_FLAG_HANDWRITING);
439 EXPECT_EQ(WMError::WM_OK, ret);
440 EXPECT_TRUE(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_HANDWRITING) & windowSceneSessionImpl->GetWindowFlags());
441 }
442
443 /**
444 * @tc.name: AddWindowFlag05
445 * @tc.desc: AddWindowFlag
446 * @tc.type: FUNC
447 */
448 HWTEST_F(WindowSceneSessionImplTest3, AddWindowFlag05, TestSize.Level1)
449 {
450 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
451 option->SetWindowName("AddWindowFlag05");
452 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
453 windowSceneSessionImpl->property_->SetPersistentId(10001);
454 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
455 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
456 windowSceneSessionImpl->hostSession_ = session;
457
458 auto ret = windowSceneSessionImpl->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
459 EXPECT_EQ(WMError::WM_OK, ret);
460 EXPECT_TRUE(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED) &
461 windowSceneSessionImpl->GetWindowFlags());
462 }
463
464 /**
465 * @tc.name: SetDefaultProperty
466 * @tc.desc: SetDefaultProperty
467 * @tc.type: FUNC
468 */
469 HWTEST_F(WindowSceneSessionImplTest3, SetDefaultProperty, TestSize.Level1)
470 {
471 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
472 option->SetWindowName("SetDefaultProperty");
473 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
474 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_TOAST);
475 windowSceneSessionImpl->SetDefaultProperty();
476 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_POINTER);
477 windowSceneSessionImpl->SetDefaultProperty();
478
479 auto ret = windowSceneSessionImpl->UpdateDisplayId(0);
480 EXPECT_EQ(WSError::WS_OK, ret);
481 }
482
483 /**
484 * @tc.name: SetCallingWindow
485 * @tc.desc: SetCallingWindow
486 * @tc.type: FUNC
487 */
488 HWTEST_F(WindowSceneSessionImplTest3, SetCallingWindow, TestSize.Level1)
489 {
490 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
491 option->SetWindowName("SetCallingWindow");
492 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
493
494 windowSceneSessionImpl->hostSession_ = nullptr;
495 auto ret = windowSceneSessionImpl->SetCallingWindow(0);
496 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
497
498 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
499 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
500 windowSceneSessionImpl->hostSession_ = session;
501 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
502 windowSceneSessionImpl->property_->SetPersistentId(1);
503 ret = windowSceneSessionImpl->SetCallingWindow(0);
504 EXPECT_EQ(WMError::WM_OK, ret);
505 EXPECT_EQ(0, windowSceneSessionImpl->property_->callingSessionId_);
506 }
507
508 /**
509 * @tc.name: RaiseToAppTop
510 * @tc.desc: RaiseToAppTop
511 * @tc.type: FUNC
512 */
513 HWTEST_F(WindowSceneSessionImplTest3, RaiseToAppTop, TestSize.Level1)
514 {
515 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
516 option->SetWindowName("RaiseToAppTop");
517 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
518 windowSceneSessionImpl->property_->SetPersistentId(6);
519 windowSceneSessionImpl->property_->SetParentPersistentId(0);
520 auto ret = windowSceneSessionImpl->RaiseToAppTop();
521 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
522
523 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
524 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
525 windowSceneSessionImpl->hostSession_ = session;
526 ret = windowSceneSessionImpl->RaiseToAppTop();
527 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, ret);
528 }
529
530 /**
531 * @tc.name: SetTouchHotAreas
532 * @tc.desc: SetTouchHotAreas
533 * @tc.type: FUNC
534 */
535 HWTEST_F(WindowSceneSessionImplTest3, SetTouchHotAreas, TestSize.Level1)
536 {
537 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
538 option->SetWindowName("SetTouchHotAreas");
539 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
540
541 std::vector<Rect> rects;
542 Rect rect = { 800, 800, 1200, 1200 };
543 rects.push_back(rect);
544 auto ret = windowSceneSessionImpl->SetTouchHotAreas(rects);
545 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
546 }
547
548 /**
549 * @tc.name: SetKeyboardTouchHotAreas
550 * @tc.desc: SetKeyboardTouchHotAreas
551 * @tc.type: FUNC
552 */
553 HWTEST_F(WindowSceneSessionImplTest3, SetKeyboardTouchHotAreas, TestSize.Level1)
554 {
555 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
556 option->SetWindowName("SetKeyboardTouchHotAreas");
557 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
558
559 KeyboardTouchHotAreas hotAreas;
560 Rect rect = { 800, 800, 1200, 1200 };
561 hotAreas.landscapeKeyboardHotAreas_.push_back(rect);
562 hotAreas.landscapePanelHotAreas_.push_back(rect);
563 hotAreas.portraitKeyboardHotAreas_.push_back(rect);
564 hotAreas.portraitPanelHotAreas_.push_back(rect);
565 auto ret = windowSceneSessionImpl->SetKeyboardTouchHotAreas(hotAreas);
566 EXPECT_EQ(WMError::WM_ERROR_INVALID_TYPE, ret);
567 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
568 ret = windowSceneSessionImpl->SetKeyboardTouchHotAreas(hotAreas);
569 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
570
571 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
572 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
573 windowSceneSessionImpl->hostSession_ = session;
574 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
575 windowSceneSessionImpl->property_->SetPersistentId(1);
576 ret = windowSceneSessionImpl->SetKeyboardTouchHotAreas(hotAreas);
577 EXPECT_EQ(WMError::WM_OK, ret);
578 }
579
580 /**
581 * @tc.name: GetWindowLimits01
582 * @tc.desc: GetWindowLimits
583 * @tc.type: FUNC
584 */
585 HWTEST_F(WindowSceneSessionImplTest3, GetWindowLimits01, TestSize.Level1)
586 {
587 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
588 option->SetWindowName("GetWindowLimits01");
589 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
590 WindowLimits oldWindowLimits = { 4000, 4000, 2000, 2000, 0.0f, 0.0f };
591
592 windowSceneSessionImpl->property_->SetPersistentId(1);
593 windowSceneSessionImpl->property_->SetDisplayId(0);
594 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
595 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
596 windowSceneSessionImpl->hostSession_ = session;
597 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
598 auto ret = windowSceneSessionImpl->SetWindowLimits(oldWindowLimits, false);
599 EXPECT_EQ(WMError::WM_OK, ret);
600
601 WindowLimits newWindowLimits;
602 ret = windowSceneSessionImpl->GetWindowLimits(newWindowLimits);
603 EXPECT_EQ(WMError::WM_OK, ret);
604 EXPECT_EQ(oldWindowLimits.maxWidth_, newWindowLimits.maxWidth_);
605 EXPECT_EQ(oldWindowLimits.maxHeight_, newWindowLimits.maxHeight_);
606 EXPECT_EQ(oldWindowLimits.minWidth_, newWindowLimits.minWidth_);
607 EXPECT_EQ(oldWindowLimits.minHeight_, newWindowLimits.minHeight_);
608 }
609
610 /**
611 * @tc.name: GetWindowLimits02
612 * @tc.desc: GetWindowLimits
613 * @tc.type: FUNC
614 */
615 HWTEST_F(WindowSceneSessionImplTest3, GetWindowLimits02, TestSize.Level1)
616 {
617 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
618 option->SetWindowName("GetWindowLimits02");
619 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
620 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
621
622 windowSceneSessionImpl->hostSession_ = nullptr;
623 auto ret = windowSceneSessionImpl->GetWindowLimits(windowLimits);
624 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
625 }
626
627 /**
628 * @tc.name: IsValidSystemWindowType
629 * @tc.desc: IsValidSystemWindowType
630 * @tc.type: FUNC
631 */
632 HWTEST_F(WindowSceneSessionImplTest3, IsValidSystemWindowType, TestSize.Level1)
633 {
634 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
635 option->SetWindowName("IsValidSystemWindowType");
636 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
637
638 WindowType type = WindowType::WINDOW_TYPE_DRAGGING_EFFECT;
639 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
640 type = WindowType::WINDOW_TYPE_SEARCHING_BAR;
641 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
642 type = WindowType::WINDOW_TYPE_PANEL;
643 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
644 type = WindowType::WINDOW_TYPE_VOLUME_OVERLAY;
645 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
646 type = WindowType::WINDOW_TYPE_INPUT_METHOD_STATUS_BAR;
647 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
648 type = WindowType::WINDOW_TYPE_SYSTEM_TOAST;
649 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
650 type = WindowType::WINDOW_TYPE_SYSTEM_FLOAT;
651 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
652 type = WindowType::WINDOW_TYPE_HANDWRITE;
653 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
654 type = WindowType::WINDOW_TYPE_NEGATIVE_SCREEN;
655 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
656 type = WindowType::WINDOW_TYPE_THEME_EDITOR;
657 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
658 }
659
660 /**
661 * @tc.name: UpdateFloatingWindowSizeBySizeLimits
662 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
663 * @tc.type: FUNC
664 */
665 HWTEST_F(WindowSceneSessionImplTest3, UpdateFloatingWindowSizeBySizeLimits, TestSize.Level1)
666 {
667 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
668 ASSERT_NE(nullptr, option);
669 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits");
670 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
671
672 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_END);
673 uint32_t maxWidth = 32;
674 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
675 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
676 WindowLimits windowLimits = { 0, 0, 0, 0, 0.0f, 0.0f };
677 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
678 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
679 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
680 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
681 }
682
683 /**
684 * @tc.name: UpdateFloatingWindowSizeBySizeLimits01
685 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
686 * @tc.type: FUNC
687 */
688 HWTEST_F(WindowSceneSessionImplTest3, UpdateFloatingWindowSizeBySizeLimits01, TestSize.Level1)
689 {
690 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
691 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits01");
692 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
693 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
694 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
695 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
696 uint32_t maxWidth = 32;
697 WindowLimits windowLimits = { 1, 1, 1, 1, 0.0f, 2.0f };
698 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
699 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
700 WindowLimits windowLimits1 = { 1, 2, 2, 2, 0.0f, 0.0f };
701 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits1);
702 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
703 WindowLimits windowLimits2 = { 1, 2, 2, 2, 0.0f, 2.0f };
704 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits2);
705 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
706 }
707
708 /**
709 * @tc.name: IsDecorEnable
710 * @tc.desc: IsDecorEnable
711 * @tc.type: FUNC
712 */
713 HWTEST_F(WindowSceneSessionImplTest3, IsDecorEnable, TestSize.Level1)
714 {
715 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
716 option->SetWindowName("IsDecorEnable");
717 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
718
719 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
720 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
721 windowSceneSessionImpl->hostSession_ = session;
722 windowSceneSessionImpl->property_->SetPersistentId(1);
723 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
724 windowSceneSessionImpl->DisableAppWindowDecor();
725 auto ret = windowSceneSessionImpl->IsDecorEnable();
726 EXPECT_EQ(false, ret);
727 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = false;
728 ret = windowSceneSessionImpl->IsDecorEnable();
729 EXPECT_EQ(false, ret);
730 }
731
732 /**
733 * @tc.name: UpdateWindowState
734 * @tc.desc: UpdateWindowState
735 * @tc.type: FUNC
736 */
737 HWTEST_F(WindowSceneSessionImplTest3, UpdateWindowState, TestSize.Level1)
738 {
739 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
740 option->SetWindowName("UpdateWindowState");
741 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
742
743 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
744 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = UINT32_MAX;
745 windowSceneSessionImpl->UpdateWindowState();
746
747 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = 1920;
748 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(true);
749 windowSceneSessionImpl->UpdateWindowState();
750 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(false);
751 windowSceneSessionImpl->UpdateWindowState();
752 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
753 windowSceneSessionImpl->property_->SetDragEnabled(true);
754 windowSceneSessionImpl->UpdateWindowState();
755 windowSceneSessionImpl->property_->SetDragEnabled(false);
756 windowSceneSessionImpl->UpdateWindowState();
757 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
758 windowSceneSessionImpl->property_->SetDragEnabled(true);
759 windowSceneSessionImpl->UpdateWindowState();
760 windowSceneSessionImpl->property_->SetDragEnabled(false);
761 windowSceneSessionImpl->UpdateWindowState();
762 auto ret = windowSceneSessionImpl->property_->GetIsNeedUpdateWindowMode();
763 EXPECT_EQ(false, ret);
764 }
765
766 /**
767 * @tc.name: Resize
768 * @tc.desc: Resize
769 * @tc.type: FUNC
770 */
771 HWTEST_F(WindowSceneSessionImplTest3, Resize, TestSize.Level1)
772 {
773 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
774 option->SetWindowName("Resize");
775 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
776 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
777 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
778 auto ret = windowSceneSessionImpl->Resize(0, 0);
779 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
780 ret = windowSceneSessionImpl->Resize(100, 100);
781 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
782 windowSceneSessionImpl->property_->SetPersistentId(1);
783 windowSceneSessionImpl->property_->SetDisplayId(0);
784 windowSceneSessionImpl->hostSession_ = session;
785 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
786 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
787 ret = windowSceneSessionImpl->Resize(100, 100);
788 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
789 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
790 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
791 ret = windowSceneSessionImpl->Resize(100, 100);
792 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
793 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
794 ret = windowSceneSessionImpl->Resize(100, 100);
795 EXPECT_EQ(WMError::WM_OK, ret);
796 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
797 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
798 windowSceneSessionImpl->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
799 windowSceneSessionImpl->property_->SetDragEnabled(false);
800 ret = windowSceneSessionImpl->Resize(100, 100);
801 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
802 windowSceneSessionImpl->property_->SetDragEnabled(true);
803 WindowLimits windowLimits = {5000, 5000, 50, 50, 0.0f, 0.0f};
804 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
805 ret = windowSceneSessionImpl->Resize(100, 100);
806 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
807 WindowLimits windowLimits1 = {800, 800, 50, 50, 0.0f, 0.0f};
808 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits1);
809 ret = windowSceneSessionImpl->Resize(100, 100);
810 if (!windowSceneSessionImpl->IsFreeMultiWindowMode()) {
811 EXPECT_EQ(WMError::WM_OK, ret);
812 } else {
813 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
814 }
815 }
816
817 /**
818 * @tc.name: Resize01
819 * @tc.desc: Resize
820 * @tc.type: FUNC
821 */
822 HWTEST_F(WindowSceneSessionImplTest3, Resize01, TestSize.Level1)
823 {
824 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
825 subOption->SetWindowName("Resize01SubWindow");
826 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
827 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
828 subWindow->property_->SetPersistentId(1002);
829 SessionInfo subSessionInfo = { "CreateSubTestBundle", "CreateSubTestModule", "CreateSubTestAbility" };
830 sptr<SessionMocker> subSession = sptr<SessionMocker>::MakeSptr(subSessionInfo);
831 subWindow->hostSession_ = subSession;
832 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, subWindow->Resize(100, 100));
833 subWindow->SetWindowType(WindowType::WINDOW_TYPE_PIP);
834 subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
835 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
836 option->SetWindowName("Resize01");
837 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
838 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
839 window->property_->SetPersistentId(1003);
840 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
841 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
842 window->hostSession_ = session;
843 Rect request = { 100, 100, 100, 100 };
844 subWindow->property_->SetRequestRect(request);
845 subWindow->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
846 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 100));
847 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
848 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
849 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
850 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 100));
851 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(200, 200));
852 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
853 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 200));
854 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(200, 200));
855 }
856
857 /**
858 * @tc.name: GetAvoidAreaByType
859 * @tc.desc: GetAvoidAreaByType
860 * @tc.type: FUNC
861 */
862 HWTEST_F(WindowSceneSessionImplTest3, GetAvoidAreaByType, TestSize.Level1)
863 {
864 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
865 option->SetWindowName("GetAvoidAreaByType");
866 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
867
868 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
869 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
870 windowSceneSessionImpl->property_->SetPersistentId(1);
871 windowSceneSessionImpl->hostSession_ = session;
872 AvoidArea avoidArea;
873 auto ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
874 EXPECT_EQ(WMError::WM_OK, ret);
875 windowSceneSessionImpl->hostSession_ = nullptr;
876 ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
877 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
878 }
879
880 /**
881 * @tc.name: IsLayoutFullScreen
882 * @tc.desc: IsLayoutFullScreen
883 * @tc.type: FUNC
884 */
885 HWTEST_F(WindowSceneSessionImplTest3, IsLayoutFullScreen, TestSize.Level1)
886 {
887 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
888 option->SetWindowName("IsLayoutFullScreen");
889 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
890
891 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
892 auto ret = windowSceneSessionImpl->IsLayoutFullScreen();
893 EXPECT_EQ(false, ret);
894 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
895 ret = windowSceneSessionImpl->IsLayoutFullScreen();
896 EXPECT_EQ(false, ret);
897 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
898 ret = windowSceneSessionImpl->IsLayoutFullScreen();
899 EXPECT_EQ(false, ret);
900 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
901 ret = windowSceneSessionImpl->IsLayoutFullScreen();
902 EXPECT_EQ(false, ret);
903 }
904
905 /**
906 * @tc.name: IsLayoutFullScreen
907 * @tc.desc: IsLayoutFullScreen
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowSceneSessionImplTest3, IsLayoutFullScreen002, TestSize.Level1)
911 {
912 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
913 option->SetWindowName("IsLayoutFullScreen002");
914 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
915
916 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
917 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
918 windowSceneSessionImpl->property_->SetPersistentId(1);
919 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
920 windowSceneSessionImpl->hostSession_ = session;
921 windowSceneSessionImpl->property_->SetWindowState(WindowState::STATE_SHOWN);
922 auto ret = windowSceneSessionImpl->IsLayoutFullScreen();
923 EXPECT_EQ(false, ret);
924 }
925
926 /**
927 * @tc.name: MaximizeFloating
928 * @tc.desc: MaximizeFloating
929 * @tc.type: FUNC
930 */
931 HWTEST_F(WindowSceneSessionImplTest3, MaximizeFloating, TestSize.Level1)
932 {
933 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
934 option->SetWindowName("MaximizeFloating");
935 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
936
937 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
938 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
939 windowSceneSessionImpl->property_->SetPersistentId(1);
940 windowSceneSessionImpl->hostSession_ = session;
941 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
942 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
943 auto ret = windowSceneSessionImpl->MaximizeFloating();
944 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
945 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
946 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
947 ret = windowSceneSessionImpl->MaximizeFloating();
948 EXPECT_EQ(WMError::WM_OK, ret);
949 auto ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
950 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
951 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_FULL_FILL);
952 ret = windowSceneSessionImpl->MaximizeFloating();
953 EXPECT_EQ(WMError::WM_OK, ret);
954 windowSceneSessionImpl->property_->SetWindowModeSupportType(WINDOW_MODE_SUPPORT_FLOATING);
955 ret = windowSceneSessionImpl->MaximizeFloating();
956 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
957 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
958 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
959 windowSceneSessionImpl->hostSession_ = nullptr;
960 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
961 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
962 }
963
964 /**
965 * @tc.name: MaximizeFloating01
966 * @tc.desc: MaximizeFloating
967 * @tc.type: FUNC
968 */
969 HWTEST_F(WindowSceneSessionImplTest3, MaximizeFloating01, TestSize.Level1)
970 {
971 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
972 option->SetWindowName("MaximizeFloating01");
973 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
974 auto ret = window->MaximizeFloating();
975 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
976
977 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
978 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
979 window->property_->SetPersistentId(1);
980 window->hostSession_ = session;
981 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
982 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
983 compatibleModeProperty->SetDisableFullScreen(true);
984 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
985 ret = window->MaximizeFloating();
986 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
987 compatibleModeProperty->SetDisableFullScreen(false);
988 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
989 EXPECT_CALL(*(session), GetGlobalMaximizeMode(_)).WillRepeatedly(DoAll(
990 SetArgReferee<0>(MaximizeMode::MODE_AVOID_SYSTEM_BAR),
991 Return(WSError::WS_OK)
992 ));
993 EXPECT_EQ(MaximizeMode::MODE_AVOID_SYSTEM_BAR, window->GetGlobalMaximizeMode());
994 ret = window->MaximizeFloating();
995 EXPECT_EQ(WMError::WM_OK, ret);
996 }
997
998 /**
999 * @tc.name: Recover
1000 * @tc.desc: Recover
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(WindowSceneSessionImplTest3, Recover, TestSize.Level1)
1004 {
1005 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1006 option->SetWindowName("Recover");
1007 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1008 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSessionImpl->Recover());
1009
1010 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1011 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1012 windowSceneSessionImpl->property_->SetPersistentId(1);
1013 windowSceneSessionImpl->hostSession_ = session;
1014 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1015 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1016 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1017 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1018 auto ret = windowSceneSessionImpl->Recover();
1019 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1020 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1021 ret = windowSceneSessionImpl->Recover();
1022 EXPECT_EQ(WMError::WM_OK, ret);
1023 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1024 ret = windowSceneSessionImpl->Recover();
1025 windowSceneSessionImpl->enableImmersiveMode_ = true;
1026 EXPECT_EQ(WMError::WM_OK, ret);
1027 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1028 ret = windowSceneSessionImpl->Recover();
1029 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1030 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1031 ret = windowSceneSessionImpl->Recover();
1032 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1033 }
1034
1035 /**
1036 * @tc.name: RestorePcMainWindow
1037 * @tc.desc: RestorePcMainWindow
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(WindowSceneSessionImplTest3, RestorePcMainWindow, TestSize.Level1)
1041 {
1042 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1043 option->SetWindowName("Restore");
1044 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1045 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSessionImpl->Restore());
1046 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1047 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1048
1049 windowSceneSessionImpl->property_->SetPersistentId(1);
1050 windowSceneSessionImpl->hostSession_ = session;
1051 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1052 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1053 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1054 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1055 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1056 auto ret = windowSceneSessionImpl->Restore();
1057 EXPECT_EQ(WMError::WM_OK, ret);
1058
1059 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1060 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1061 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1062 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1063 ret = windowSceneSessionImpl->Restore();
1064 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1065 }
1066
1067 /**
1068 * @tc.name: RestorePcSubWindow
1069 * @tc.desc: RestorePcSubWindow
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(WindowSceneSessionImplTest3, RestorePcSubWindow, TestSize.Level1)
1073 {
1074 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1075 option->SetWindowName("Restore");
1076 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1077 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1078 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1079
1080 windowSceneSessionImpl->property_->SetPersistentId(1);
1081 windowSceneSessionImpl->hostSession_ = session;
1082 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1083 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1084 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1085 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1086 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1087 auto ret = windowSceneSessionImpl->Restore();
1088 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1089
1090 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1091 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1092 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1093 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1094 ret = windowSceneSessionImpl->Restore();
1095 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1096 }
1097
1098 /**
1099 * @tc.name: RestorePadMainWindow
1100 * @tc.desc: RestorePadMainWindow
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(WindowSceneSessionImplTest3, RestorePadMainWindow, TestSize.Level1)
1104 {
1105 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1106 option->SetWindowName("Restore");
1107 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1108 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1109 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1110
1111 windowSceneSessionImpl->property_->SetPersistentId(1);
1112 windowSceneSessionImpl->hostSession_ = session;
1113 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1114 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1115 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1116 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1117 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1118 auto ret = windowSceneSessionImpl->Restore();
1119 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1120
1121 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1122 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1123 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1124 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1125 ret = windowSceneSessionImpl->Restore();
1126 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1127
1128 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1129 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1130 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1131 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1132 ret = windowSceneSessionImpl->Restore();
1133 EXPECT_EQ(WMError::WM_OK, ret);
1134 }
1135
1136 /**
1137 * @tc.name: RestorePadSubWindow
1138 * @tc.desc: RestorePadSubWindow
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(WindowSceneSessionImplTest3, RestorePadSubWindow, TestSize.Level1)
1142 {
1143 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1144 option->SetWindowName("Restore");
1145 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1146 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1147 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1148
1149 windowSceneSessionImpl->property_->SetPersistentId(1);
1150 windowSceneSessionImpl->hostSession_ = session;
1151 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1152 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1153 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1154 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1155 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1156 auto ret = windowSceneSessionImpl->Restore();
1157 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1158
1159 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1160 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1161 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1162 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1163 ret = windowSceneSessionImpl->Restore();
1164 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1165
1166 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1167 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1168 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1169 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1170 ret = windowSceneSessionImpl->Restore();
1171 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1172 }
1173
1174 /**
1175 * @tc.name: RestorePadFloatingMainWindow
1176 * @tc.desc: RestorePadFloatingMainWindow
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(WindowSceneSessionImplTest3, RestorePadFloatingMainWindow, TestSize.Level1)
1180 {
1181 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1182 option->SetWindowName("Restore");
1183 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1184 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1185 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1186
1187 windowSceneSessionImpl->property_->SetPersistentId(1);
1188 windowSceneSessionImpl->hostSession_ = session;
1189 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1190 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1191 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1192 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1193 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1194 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1195 auto ret = windowSceneSessionImpl->Restore();
1196 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1197
1198 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1199 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1200 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1201 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1202 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1203 ret = windowSceneSessionImpl->Restore();
1204 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1205
1206 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1207 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1208 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1209 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1210 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1211 ret = windowSceneSessionImpl->Restore();
1212 EXPECT_EQ(WMError::WM_OK, ret);
1213 }
1214
1215 /**
1216 * @tc.name: RestorePadFloatingSubWindow
1217 * @tc.desc: RestorePadFloatingSubWindow
1218 * @tc.type: FUNC
1219 */
1220 HWTEST_F(WindowSceneSessionImplTest3, RestorePadFloatingSubWindow, TestSize.Level1)
1221 {
1222 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1223 option->SetWindowName("Restore");
1224 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1225 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1226 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1227
1228 windowSceneSessionImpl->property_->SetPersistentId(1);
1229 windowSceneSessionImpl->hostSession_ = session;
1230 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1231 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1232 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1233 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1234 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1235 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1236 auto ret = windowSceneSessionImpl->Restore();
1237 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1238
1239 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1240 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1241 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1242 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1243 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1244 ret = windowSceneSessionImpl->Restore();
1245 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1246
1247 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1248 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1249 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1250 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1251 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1252 ret = windowSceneSessionImpl->Restore();
1253 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1254 }
1255
1256 /**
1257 * @tc.name: StartMove
1258 * @tc.desc: StartMove
1259 * @tc.type: FUNC
1260 */
1261 HWTEST_F(WindowSceneSessionImplTest3, StartMove, TestSize.Level1)
1262 {
1263 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1264 option->SetWindowName("StartMove");
1265 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1266
1267 windowSceneSessionImpl->hostSession_ = nullptr;
1268 windowSceneSessionImpl->StartMove();
1269 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1270 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1271 windowSceneSessionImpl->property_->SetPersistentId(1);
1272 windowSceneSessionImpl->hostSession_ = session;
1273 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1274 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1275 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1276 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1277 windowSceneSessionImpl->StartMove();
1278 }
1279
1280 /**
1281 * @tc.name: IsStartMoving01
1282 * @tc.desc: get main window move flag, test IsStartMoving
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(WindowSceneSessionImplTest3, IsStartMoving01, TestSize.Level1)
1286 {
1287 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1288 option->SetWindowName("IsStartMoving");
1289 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1290
1291 bool isMoving = windowSceneSessionImpl->IsStartMoving();
1292 EXPECT_EQ(false, isMoving);
1293 }
1294
1295 /**
1296 * @tc.name: DisableAppWindowDecor
1297 * @tc.desc: DisableAppWindowDecor
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(WindowSceneSessionImplTest3, DisableAppWindowDecor, TestSize.Level1)
1301 {
1302 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1303 option->SetWindowName("DisableAppWindowDecor");
1304 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1305 windowSceneSessionImpl->property_->SetPersistentId(1);
1306 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1307 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1308 windowSceneSessionImpl->hostSession_ = session;
1309
1310 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1311 auto ret = windowSceneSessionImpl->DisableAppWindowDecor();
1312 EXPECT_EQ(WMError::WM_OK, ret);
1313 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1314 ret = windowSceneSessionImpl->DisableAppWindowDecor();
1315 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1316 }
1317
1318 /**
1319 * @tc.name: UpdateMaximizeMode
1320 * @tc.desc: UpdateMaximizeMode
1321 * @tc.type: FUNC
1322 */
1323 HWTEST_F(WindowSceneSessionImplTest3, UpdateMaximizeMode, TestSize.Level1)
1324 {
1325 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1326 option->SetWindowName("UpdateMaximizeMode");
1327 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1328 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1329 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1330
1331 windowSceneSessionImpl->hostSession_ = session;
1332 windowSceneSessionImpl->enableImmersiveMode_ = true;
1333 windowSceneSessionImpl->uiContent_ = nullptr;
1334 auto ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1335 EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
1336
1337 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1338 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1339 EXPECT_EQ(WSError::WS_OK, ret);
1340 EXPECT_TRUE(windowSceneSessionImpl->enableImmersiveMode_);
1341
1342 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1343 EXPECT_EQ(WSError::WS_OK, ret);
1344 EXPECT_FALSE(windowSceneSessionImpl->enableImmersiveMode_);
1345
1346 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1347 EXPECT_EQ(WSError::WS_OK, ret);
1348
1349 windowSceneSessionImpl->enableImmersiveMode_ = true;
1350 windowSceneSessionImpl->hostSession_ = nullptr;
1351 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1352 EXPECT_EQ(WSError::WS_OK, ret);
1353 }
1354
1355 /**
1356 * @tc.name: GetSystemBarProperties
1357 * @tc.desc: GetSystemBarProperties
1358 * @tc.type: FUNC
1359 */
1360 HWTEST_F(WindowSceneSessionImplTest3, GetSystemBarProperties, TestSize.Level1)
1361 {
1362 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1363 option->SetWindowName("GetSystemBarProperties");
1364 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1365 std::map<WindowType, SystemBarProperty> properties;
1366 auto ret = windowSceneSessionImpl->GetSystemBarProperties(properties);
1367 EXPECT_EQ(WMError::WM_OK, ret);
1368 }
1369
1370 /**
1371 * @tc.name: Hide
1372 * @tc.desc: Hide
1373 * @tc.type: FUNC
1374 */
1375 HWTEST_F(WindowSceneSessionImplTest3, Hide, TestSize.Level1)
1376 {
1377 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1378 option->SetWindowName("Hide");
1379 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1380
1381 windowSceneSessionImpl->hostSession_ = nullptr;
1382 auto ret = windowSceneSessionImpl->Hide(2, false, false);
1383 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1384 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1385 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1386 windowSceneSessionImpl->hostSession_ = session;
1387 windowSceneSessionImpl->property_->SetPersistentId(0);
1388 ret = windowSceneSessionImpl->Hide(2, false, false);
1389 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1390 windowSceneSessionImpl->property_->SetPersistentId(1);
1391 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1392 ret = windowSceneSessionImpl->Hide(2, false, false);
1393 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1394 }
1395
1396 /**
1397 * @tc.name: Hide
1398 * @tc.desc: reason = WindowStateChangeReason::USER_SWITCH
1399 * @tc.type: FUNC
1400 */
1401 HWTEST_F(WindowSceneSessionImplTest3, Hide002, TestSize.Level1)
1402 {
1403 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1404 option->SetWindowName("Hide002");
1405 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1406
1407 windowSceneSessionImpl->hostSession_ = nullptr;
1408 auto reason = static_cast<uint32_t>(WindowStateChangeReason::USER_SWITCH);
1409 auto ret = windowSceneSessionImpl->Hide(reason, false, false);
1410 EXPECT_EQ(WMError::WM_OK, ret);
1411 }
1412
1413 /**
1414 * @tc.name: IsSessionMainWindow
1415 * @tc.desc: IsSessionMainWindow
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(WindowSceneSessionImplTest3, IsSessionMainWindow, TestSize.Level1)
1419 {
1420 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1421 option->SetWindowName("IsSessionMainWindow");
1422 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1423
1424 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1425 windowSession->property_->SetPersistentId(1);
1426 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1427 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1428 auto ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1429 EXPECT_EQ(true, ret);
1430 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1431 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1432 ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1433 EXPECT_EQ(false, ret);
1434 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1435 EXPECT_EQ(false, ret);
1436 windowSession = nullptr;
1437 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1438 EXPECT_EQ(false, ret);
1439 }
1440
1441 /**
1442 * @tc.name: Show
1443 * @tc.desc: Show
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(WindowSceneSessionImplTest3, Show, TestSize.Level1)
1447 {
1448 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1449 option->SetWindowName("Show");
1450 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1451
1452 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1453 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1454 windowSceneSessionImpl->property_->SetPersistentId(1);
1455 windowSceneSessionImpl->hostSession_ = session;
1456 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1457 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1458 auto ret = windowSceneSessionImpl->Show(2, true);
1459 EXPECT_EQ(WMError::WM_OK, ret);
1460 ret = windowSceneSessionImpl->Maximize();
1461 EXPECT_EQ(WMError::WM_OK, ret);
1462 ret = windowSceneSessionImpl->Minimize();
1463 EXPECT_EQ(WMError::WM_OK, ret);
1464 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1465 ret = windowSceneSessionImpl->Minimize();
1466 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1467 ret = windowSceneSessionImpl->Maximize();
1468 EXPECT_EQ(WMError::WM_OK, ret);
1469 ret = windowSceneSessionImpl->Minimize();
1470 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1471 }
1472
1473 /**
1474 * @tc.name: Show
1475 * @tc.desc: Show01
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(WindowSceneSessionImplTest3, Show01, TestSize.Level1)
1479 {
1480 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1481 option->SetWindowName("Show01");
1482 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1483
1484 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1485 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1486 windowSceneSessionImpl->property_->SetPersistentId(1);
1487 windowSceneSessionImpl->hostSession_ = session;
1488 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1489 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1490 auto ret = windowSceneSessionImpl->Show(2, true);
1491 EXPECT_EQ(WMError::WM_OK, ret);
1492 }
1493
1494 /**
1495 * @tc.name: Show02
1496 * @tc.desc: Show withFocus params
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(WindowSceneSessionImplTest3, Show02, TestSize.Level1)
1500 {
1501 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1502 option->SetWindowName("Show02");
1503 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1504
1505 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1506 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1507 windowSceneSessionImpl->property_->SetPersistentId(1);
1508 windowSceneSessionImpl->hostSession_ = session;
1509 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1510 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1511 auto ret = windowSceneSessionImpl->Show(0, false, true);
1512 EXPECT_EQ(WMError::WM_OK, ret);
1513 ret = windowSceneSessionImpl->Show(0, false, false);
1514 EXPECT_EQ(WMError::WM_OK, ret);
1515 }
1516
1517 /**
1518 * @tc.name: Show02
1519 * @tc.desc: Show withFocus params
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(WindowSceneSessionImplTest3, Show03, TestSize.Level1)
1523 {
1524 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1525 option->SetWindowName("Show03");
1526 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1527
1528 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1529 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1530 windowSceneSessionImpl->property_->SetPersistentId(1);
1531 windowSceneSessionImpl->hostSession_ = session;
1532 windowSceneSessionImpl->property_->SetWindowState(WindowState::STATE_SHOWN);
1533 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1534 auto reason = static_cast<uint32_t>(WindowStateChangeReason::USER_SWITCH);
1535 auto ret = windowSceneSessionImpl->Show(reason, false, true);
1536 EXPECT_EQ(WMError::WM_OK, ret);
1537 }
1538
1539 /**
1540 * @tc.name: NotifySpecificWindowSessionProperty
1541 * @tc.desc: NotifySpecificWindowSessionProperty
1542 * @tc.type: FUNC
1543 */
1544 HWTEST_F(WindowSceneSessionImplTest3, NotifySpecificWindowSessionProperty, TestSize.Level1)
1545 {
1546 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1547 option->SetWindowName("NotifySpecificWindowSessionProperty");
1548 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1549
1550 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1551 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1552 windowSceneSessionImpl->property_->SetPersistentId(1);
1553 windowSceneSessionImpl->hostSession_ = session;
1554 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1555 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
1556 SystemBarProperty property;
1557 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1558 auto ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1559 EXPECT_EQ(WMError::WM_OK, ret);
1560 ret = windowSceneSessionImpl->SetWindowFlags(0);
1561 EXPECT_EQ(WMError::WM_OK, ret);
1562 type = WindowType::WINDOW_TYPE_NAVIGATION_BAR;
1563 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1564 EXPECT_EQ(WMError::WM_OK, ret);
1565 type = WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR;
1566 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1567 EXPECT_EQ(WMError::WM_OK, ret);
1568 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1569 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
1570 EXPECT_EQ(WMError::WM_OK, ret);
1571 windowSceneSessionImpl->hostSession_ = nullptr;
1572 ret = windowSceneSessionImpl->SetWindowFlags(0);
1573 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1574 }
1575
1576 /**
1577 * @tc.name: Close
1578 * @tc.desc: Close
1579 * @tc.type: FUNC
1580 */
1581 HWTEST_F(WindowSceneSessionImplTest3, Close, TestSize.Level1)
1582 {
1583 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1584 option->SetWindowName("Close");
1585 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1586
1587 windowSceneSessionImpl->hostSession_ = nullptr;
1588 auto ret = windowSceneSessionImpl->Close();
1589 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1590 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1591 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1592 windowSceneSessionImpl->property_->SetPersistentId(1);
1593 windowSceneSessionImpl->hostSession_ = session;
1594 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1595 windowSceneSessionImpl->context_ = abilityContext_;
1596 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1597 ret = windowSceneSessionImpl->Close();
1598 EXPECT_EQ(WMError::WM_OK, ret);
1599 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1600 ret = windowSceneSessionImpl->Close();
1601 EXPECT_EQ(WMError::WM_OK, ret);
1602 windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1603 ret = windowSceneSessionImpl->Close();
1604 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1605 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1606 ret = windowSceneSessionImpl->Close();
1607 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1608 }
1609
1610 /**
1611 * @tc.name: GetWindowWithId
1612 * @tc.desc: GetWindowWithId
1613 * @tc.type: FUNC
1614 */
1615 HWTEST_F(WindowSceneSessionImplTest3, GetWindowWithId, TestSize.Level1)
1616 {
1617 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1618 option->SetWindowName("GetWindowWithId");
1619 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1620
1621 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1622 windowSession->property_->SetPersistentId(1);
1623 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1624 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1625 auto ret = windowSceneSessionImpl->GetWindowWithId(1);
1626 EXPECT_FALSE(ret == nullptr);
1627 ret = windowSceneSessionImpl->GetWindowWithId(0);
1628 EXPECT_FALSE(ret == nullptr);
1629 windowSession = nullptr;
1630 ret = windowSceneSessionImpl->GetWindowWithId(0);
1631 EXPECT_FALSE(ret == nullptr);
1632 }
1633
1634 /**
1635 * @tc.name: GetMainWindowWithId
1636 * @tc.desc: GetMainWindowWithId
1637 * @tc.type: FUNC
1638 */
1639 HWTEST_F(WindowSceneSessionImplTest3, GetMainWindowWithId, TestSize.Level1)
1640 {
1641 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1642 option->SetWindowName("GetMainWindowWithId");
1643 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1644
1645 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1646 windowSession->property_->SetPersistentId(1);
1647 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1648 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_MEDIA);
1649 auto ret = windowSceneSessionImpl->GetMainWindowWithId(1);
1650 EXPECT_TRUE(ret == nullptr);
1651 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1652 ret = windowSceneSessionImpl->GetMainWindowWithId(1);
1653 EXPECT_TRUE(ret == nullptr);
1654 ret = windowSceneSessionImpl->GetMainWindowWithId(0);
1655 EXPECT_TRUE(ret == nullptr);
1656 }
1657
1658 /**
1659 * @tc.name: PreNotifyKeyEvent
1660 * @tc.desc: PreNotifyKeyEvent
1661 * @tc.type: FUNC
1662 */
1663 HWTEST_F(WindowSceneSessionImplTest3, PreNotifyKeyEvent, TestSize.Level1)
1664 {
1665 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1666 option->SetWindowName("PreNotifyKeyEvent");
1667 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1668
1669 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
1670 windowSceneSessionImpl->uiContent_ = nullptr;
1671 auto ret = windowSceneSessionImpl->PreNotifyKeyEvent(keyEvent);
1672 EXPECT_EQ(false, ret);
1673 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1674 EXPECT_EQ(false, ret);
1675 }
1676
1677 /**
1678 * @tc.name: Recover01
1679 * @tc.desc: Recover
1680 * @tc.type: FUNC
1681 */
1682 HWTEST_F(WindowSceneSessionImplTest3, Recover01, TestSize.Level1)
1683 {
1684 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1685 option->SetWindowName("Recover");
1686 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1687 windowSceneSessionImpl->hostSession_ = nullptr;
1688 auto ret = windowSceneSessionImpl->Recover(1);
1689 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1690 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1691 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1692 windowSceneSessionImpl->property_->SetPersistentId(1);
1693 windowSceneSessionImpl->hostSession_ = session;
1694 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1695 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1696 ret = windowSceneSessionImpl->Recover(1);
1697 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1698 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = true;
1699 ret = windowSceneSessionImpl->Recover(1);
1700 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1701 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1702 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1703 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1704 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1705 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1706 ret = windowSceneSessionImpl->Recover(1);
1707 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1708 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
1709 ret = windowSceneSessionImpl->Recover(1);
1710 EXPECT_EQ(WMError::WM_OK, ret);
1711 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1712 ret = windowSceneSessionImpl->Recover(1);
1713 EXPECT_EQ(WMError::WM_OK, ret);
1714 ret = windowSceneSessionImpl->Recover(0);
1715 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1716 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1717 ret = windowSceneSessionImpl->Recover(0);
1718 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1719 windowSceneSessionImpl->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
1720 ret = windowSceneSessionImpl->Recover(0);
1721 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1722 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1723 windowSceneSessionImpl->property_->SetPcAppInpadCompatibleMode(true);
1724 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = false;
1725 ret = windowSceneSessionImpl->Recover(0);
1726 EXPECT_EQ(WMError::WM_OK, ret);
1727 }
1728
1729 /**
1730 * @tc.name: FindParentSessionByParentId
1731 * @tc.desc: FindParentSessionByParentId
1732 * @tc.type: FUNC
1733 */
1734 HWTEST_F(WindowSceneSessionImplTest3, FindParentSessionByParentId, TestSize.Level1)
1735 {
1736 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1737 option->SetWindowName("FindParentSessionByParentId");
1738 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1739
1740 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1741 windowSession->property_->SetPersistentId(1);
1742
1743 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1744 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1745 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1746 windowSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1747 windowSession->property_->SetParentPersistentId(1);
1748 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1749 windowSession->property_->SetParentPersistentId(0);
1750 windowSession->property_->SetIsUIExtFirstSubWindow(true);
1751 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1752 }
1753
1754 /**
1755 * @tc.name: PreLayoutOnShow
1756 * @tc.desc: PreLayoutOnShow
1757 * @tc.type: FUNC
1758 */
1759 HWTEST_F(WindowSceneSessionImplTest3, PreLayoutOnShow, TestSize.Level1)
1760 {
1761 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1762 option->SetWindowName("PreLayoutOnShow");
1763 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1764 window->property_->SetPersistentId(1);
1765 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1766 window->PreLayoutOnShow(window->property_->GetWindowType()); // uicontent is nullptr
1767 ASSERT_EQ(WindowState::STATE_INITIAL, window->state_);
1768 ASSERT_EQ(WindowState::STATE_INITIAL, window->requestState_);
1769
1770 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1771 Rect request = { 100, 100, 100, 100 };
1772 window->property_->SetRequestRect(request);
1773 // uicontent is not nullptr and session is nullptr
1774 window->PreLayoutOnShow(window->property_->GetWindowType());
1775 ASSERT_EQ(WindowState::STATE_SHOWN, window->state_);
1776 ASSERT_EQ(WindowState::STATE_SHOWN, window->requestState_);
1777
1778 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1779 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1780 window->hostSession_ = session;
1781 // uicontent is not nullptr and session is not nullptr
1782 window->PreLayoutOnShow(window->property_->GetWindowType());
1783 ASSERT_EQ(WindowState::STATE_SHOWN, window->state_);
1784 ASSERT_EQ(WindowState::STATE_SHOWN, window->requestState_);
1785
1786 request = { 100, 100, 0, 100 };
1787 window->property_->SetRequestRect(request);
1788 window->PreLayoutOnShow(window->property_->GetWindowType());
1789 ASSERT_EQ(WindowState::STATE_SHOWN, window->state_);
1790 ASSERT_EQ(WindowState::STATE_SHOWN, window->requestState_);
1791
1792 request = { 100, 100, 100, 0 };
1793 window->property_->SetRequestRect(request);
1794 window->PreLayoutOnShow(window->property_->GetWindowType());
1795 ASSERT_EQ(WindowState::STATE_SHOWN, window->state_);
1796 ASSERT_EQ(WindowState::STATE_SHOWN, window->requestState_);
1797 }
1798
1799 /**
1800 * @tc.name: InitSystemSessionDragEnable_IsDialogOrNot
1801 * @tc.desc: InitSystemSessionDragEnable Test, is dialog window or not
1802 * @tc.type: FUNC
1803 */
1804 HWTEST_F(WindowSceneSessionImplTest3, InitSystemSessionDragEnable_IsDialogOrNot, TestSize.Level1)
1805 {
1806 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1807 option->SetWindowName("InitSystemSessionDragEnable_IsDialogOrNot");
1808 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1809 window->property_->SetPersistentId(1);
1810 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1811 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1812 window->hostSession_ = session;
1813
1814 window->property_->SetDragEnabled(true);
1815 window->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1816 window->InitSystemSessionDragEnable();
1817 ASSERT_EQ(window->property_->GetDragEnabled(), false);
1818
1819 window->property_->SetDragEnabled(true);
1820 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1821 window->InitSystemSessionDragEnable();
1822 ASSERT_EQ(window->property_->GetDragEnabled(), true);
1823 }
1824
1825 /**
1826 * @tc.name: SetWindowRectAutoSave
1827 * @tc.desc: SetWindowRectAutoSave
1828 * @tc.type: FUNC
1829 */
1830 HWTEST_F(WindowSceneSessionImplTest3, SetWindowRectAutoSave, TestSize.Level1)
1831 {
1832 GTEST_LOG_(INFO) << "WindowSceneSessionImplTest3: SetWindowRectAutoSave start";
1833 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1834 option->SetWindowName("SetWindowRectAutoSave");
1835 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1836 auto ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1837 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1838 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1839 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1840 windowSceneSessionImpl->property_->SetPersistentId(1);
1841 windowSceneSessionImpl->hostSession_ = session;
1842 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1843 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1844 EXPECT_EQ(WMError::WM_OK, ret);
1845 ret = windowSceneSessionImpl->SetWindowRectAutoSave(false, false);
1846 EXPECT_EQ(WMError::WM_OK, ret);
1847 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1848 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1849 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1850 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1851 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1852 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1853 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1854 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1855 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1856 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1857 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = false;
1858 windowSceneSessionImpl->property_->SetPcAppInpadCompatibleMode(true);
1859 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true, false);
1860 EXPECT_EQ(WMError::WM_OK, ret);
1861 GTEST_LOG_(INFO) << "WindowSceneSessionImplTest3: SetWindowRectAutoSave end";
1862 }
1863
1864 /**
1865 * @tc.name: SetSupportedWindowModes
1866 * @tc.desc: SetSupportedWindowModes
1867 * @tc.type: FUNC
1868 */
1869 HWTEST_F(WindowSceneSessionImplTest3, SetSupportedWindowModes, TestSize.Level1)
1870 {
1871 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1872 option->SetWindowName("SetSupportedWindowModes");
1873 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1874 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1875 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1876 windowSceneSessionImpl->property_->SetPersistentId(1);
1877 windowSceneSessionImpl->hostSession_ = session;
1878 std::vector<AppExecFwk::SupportWindowMode> supportedWindowModes = { AppExecFwk::SupportWindowMode::FULLSCREEN,
1879 AppExecFwk::SupportWindowMode::SPLIT,
1880 AppExecFwk::SupportWindowMode::FLOATING };
1881
1882 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1883 auto ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1884 EXPECT_EQ(WMError::WM_OK, ret);
1885 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1886 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1887 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1888 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1889 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1890 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1891
1892 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1893 supportedWindowModes.clear();
1894 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1895 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1896
1897 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FULLSCREEN);
1898 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1899 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
1900 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
1901 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
1902 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1903 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1904
1905 supportedWindowModes.clear();
1906 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FULLSCREEN);
1907 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1908 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1909 EXPECT_EQ(WMError::WM_OK, ret);
1910
1911 supportedWindowModes.clear();
1912 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
1913 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1914 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1915 EXPECT_EQ(WMError::WM_OK, ret);
1916
1917 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1918 windowSceneSessionImpl->property_->SetPcAppInpadCompatibleMode(true);
1919 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = false;
1920 ret = windowSceneSessionImpl->SetSupportedWindowModes(supportedWindowModes);
1921 EXPECT_EQ(WMError::WM_OK, ret);
1922 }
1923
1924 /**
1925 * @tc.name: SetSupportedWindowModes01
1926 * @tc.desc: SetSupportedWindowModes
1927 * @tc.type: FUNC
1928 */
1929 HWTEST_F(WindowSceneSessionImplTest3, SetSupportedWindowModes01, TestSize.Level1)
1930 {
1931 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1932 option->SetWindowName("SetSupportedWindowModes01");
1933 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1934 std::vector<AppExecFwk::SupportWindowMode> supportedWindowModes;
1935 auto ret = window->SetSupportedWindowModes(supportedWindowModes);
1936 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1937 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1938 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1939 window->hostSession_ = session;
1940 window->property_->SetPersistentId(1);
1941 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1942 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1943 ret = window->SetSupportedWindowModes(supportedWindowModes);
1944 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1945 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1946 supportedWindowModes.push_back(static_cast<AppExecFwk::SupportWindowMode>(10));
1947 ret = window->SetSupportedWindowModes(supportedWindowModes);
1948 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1949 supportedWindowModes.clear();
1950 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1951 ret = window->SetSupportedWindowModes(supportedWindowModes);
1952 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1953 }
1954
1955 /**
1956 * @tc.name: SetSupportedWindowModes02
1957 * @tc.desc: SetSupportedWindowModes
1958 * @tc.type: FUNC
1959 */
1960 HWTEST_F(WindowSceneSessionImplTest3, SetSupportedWindowModes02, TestSize.Level1)
1961 {
1962 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1963 option->SetWindowName("SetSupportedWindowModes02");
1964 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1965 std::vector<AppExecFwk::SupportWindowMode> supportedWindowModes;
1966 auto ret = window->SetSupportedWindowModes(supportedWindowModes);
1967 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1968 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1969 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1970 window->hostSession_ = session;
1971 window->property_->SetPersistentId(1);
1972 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1973 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1974 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
1975 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1976
1977 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1978 supportedWindowModes.push_back(static_cast<AppExecFwk::SupportWindowMode>(10));
1979 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
1980 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1981
1982 supportedWindowModes.clear();
1983 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1984 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
1985 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1986
1987 supportedWindowModes.clear();
1988 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
1989 EXPECT_EQ(WMError::WM_ERROR_ILLEGAL_PARAM, ret);
1990
1991 supportedWindowModes.clear();
1992 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FULLSCREEN);
1993 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
1994 EXPECT_EQ(WMError::WM_ERROR_ILLEGAL_PARAM, ret);
1995
1996 supportedWindowModes.clear();
1997 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1998 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
1999 ret = window->SetSupportedWindowModes(supportedWindowModes, true);
2000 EXPECT_EQ(WMError::WM_OK, ret);
2001
2002 supportedWindowModes.clear();
2003 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
2004 supportedWindowModes.push_back(AppExecFwk::SupportWindowMode::FLOATING);
2005 window->grayOutMaximizeButton_ = true;
2006 ret = window->SetSupportedWindowModes(supportedWindowModes, false);
2007 EXPECT_EQ(WMError::WM_OK, ret);
2008 }
2009
2010 /**
2011 * @tc.name: GrayOutMaximizeButton
2012 * @tc.desc: GrayOutMaximizeButton
2013 * @tc.type: FUNC
2014 */
2015 HWTEST_F(WindowSceneSessionImplTest3, GrayOutMaximizeButton, TestSize.Level1)
2016 {
2017 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2018 option->SetWindowName("GrayOutMaximizeButton");
2019 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2020 auto ret = window->GrayOutMaximizeButton(true);
2021 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2022 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2023 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2024 window->hostSession_ = session;
2025 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2026 std::unique_ptr<Ace::UIContent> uiContent = Ace::UIContent::Create(nullptr, nullptr);
2027 window->uiContent_ = std::move(uiContent);
2028 ret = window->GrayOutMaximizeButton(true);
2029 EXPECT_EQ(WMError::WM_OK, ret);
2030 ret = window->GrayOutMaximizeButton(true);
2031 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
2032 }
2033
2034 /**
2035 * @tc.name: CheckAndModifyWindowRect
2036 * @tc.desc: CheckAndModifyWindowRect
2037 * @tc.type: FUNC
2038 */
2039 HWTEST_F(WindowSceneSessionImplTest3, CheckAndModifyWindowRect, Function | SmallTest | Level2)
2040 {
2041 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2042 option->SetWindowName("CheckAndModifyWindowRect");
2043 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2044 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2045 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2046 uint32_t width = 0;
2047 uint32_t height = 0;
2048 auto ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2049 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
2050 width = 100;
2051 height = 100;
2052 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2053 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
2054
2055 windowSceneSessionImpl->property_->SetPersistentId(1);
2056 windowSceneSessionImpl->hostSession_ = session;
2057 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
2058 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
2059 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2060 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
2061 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
2062 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
2063 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2064 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
2065 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2066 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2067 EXPECT_EQ(WMError::WM_OK, ret);
2068 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
2069 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
2070 windowSceneSessionImpl->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
2071 windowSceneSessionImpl->property_->SetDragEnabled(false);
2072 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2073 EXPECT_EQ(WMError::WM_OK, ret);
2074 windowSceneSessionImpl->property_->SetDragEnabled(true);
2075 WindowLimits windowLimits = {5000, 5000, 50, 50, 0.0f, 0.0f};
2076 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
2077 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2078 EXPECT_EQ(WMError::WM_OK, ret);
2079 WindowLimits windowLimits1 = {800, 800, 50, 50, 0.0f, 0.0f};
2080 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits1);
2081 ret = windowSceneSessionImpl->CheckAndModifyWindowRect(width, height);
2082 if (!windowSceneSessionImpl->IsFreeMultiWindowMode()) {
2083 EXPECT_EQ(WMError::WM_OK, ret);
2084 } else {
2085 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
2086 }
2087 }
2088 } // namespace
2089 } // namespace Rosen
2090 } // namespace OHOS