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