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