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 ASSERT_NE(nullptr, option);
564 option->SetWindowName("SetTouchHotAreas");
565 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
566 ASSERT_NE(nullptr, windowSceneSessionImpl);
567
568 std::vector<Rect> rects;
569 Rect rect = {800, 800, 1200, 1200};
570 rects.push_back(rect);
571 auto ret = windowSceneSessionImpl->SetTouchHotAreas(rects);
572 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
573 }
574
575 /**
576 * @tc.name: GetWindowLimits
577 * @tc.desc: GetWindowLimits
578 * @tc.type: FUNC
579 */
580 HWTEST_F(WindowSceneSessionImplTest3, GetWindowLimits, Function | SmallTest | Level2)
581 {
582 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
583 ASSERT_NE(nullptr, option);
584 option->SetWindowName("GetWindowLimits");
585 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
586 ASSERT_NE(nullptr, windowSceneSessionImpl);
587 WindowLimits windowLimits = {1000, 1000, 1000, 1000, 0.0f, 0.0f};
588
589 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
590 windowSceneSessionImpl->property_->SetPersistentId(1);
591 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
592 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
593 ASSERT_NE(nullptr, session);
594 windowSceneSessionImpl->hostSession_ = session;
595 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
596 auto ret = windowSceneSessionImpl->GetWindowLimits(windowLimits);
597 EXPECT_EQ(WMError::WM_OK, ret);
598
599 windowSceneSessionImpl->hostSession_ = nullptr;
600 ret = windowSceneSessionImpl->GetWindowLimits(windowLimits);
601 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
602 }
603
604 /**
605 * @tc.name: SetWindowLimits
606 * @tc.desc: SetWindowLimits
607 * @tc.type: FUNC
608 */
609 HWTEST_F(WindowSceneSessionImplTest3, SetWindowLimits, Function | SmallTest | Level2)
610 {
611 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
612 ASSERT_NE(nullptr, option);
613 option->SetWindowName("SetWindowLimits");
614 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
615 ASSERT_NE(nullptr, windowSceneSessionImpl);
616 WindowLimits windowLimits = {1000, 1000, 1000, 1000, 0.0f, 0.0f};
617
618 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
619 windowSceneSessionImpl->property_->SetPersistentId(1);
620 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
621 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
622 ASSERT_NE(nullptr, session);
623 windowSceneSessionImpl->hostSession_ = session;
624 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
625 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
626 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
627 auto ret = windowSceneSessionImpl->SetWindowLimits(windowLimits);
628 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
629 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
630 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
631 ret = windowSceneSessionImpl->MoveTo(0, 0);
632 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
633 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
634 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
635 ret = windowSceneSessionImpl->MoveTo(0, 0);
636 EXPECT_EQ(WMError::WM_OK, ret);
637 }
638
639 /**
640 * @tc.name: SetWindowLimits01
641 * @tc.desc: SetWindowLimits
642 * @tc.type: FUNC
643 */
644 HWTEST_F(WindowSceneSessionImplTest3, SetWindowLimits01, Function | SmallTest | Level2)
645 {
646 sptr<WindowOption> subWindow = sptr<WindowOption>::MakeSptr();
647 ASSERT_NE(nullptr, subWindow);
648 subWindow->SetWindowName("SetWindowLimits01");
649 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(subWindow);
650 ASSERT_NE(nullptr, windowSceneSessionImpl);
651 WindowLimits windowLimits = {1000, 1000, 1000, 1000, 0.0f, 0.0f};
652 windowSceneSessionImpl->SetWindowLimits(windowLimits);
653 windowSceneSessionImpl->property_->SetPersistentId(1004);
654 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestMoudle", "CreateTestAbility"};
655 sptr<SessionMocker> subSesssion = sptr<SessionMocker>::MakeSptr(sessionInfo);
656 ASSERT_NE(nullptr, subSesssion);
657 windowSceneSessionImpl->hostSession_ = subSesssion;
658 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
659 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSessionImpl->SetWindowLimits(windowLimits));
660 }
661
662 /**
663 * @tc.name: IsValidSystemWindowType
664 * @tc.desc: IsValidSystemWindowType
665 * @tc.type: FUNC
666 */
667 HWTEST_F(WindowSceneSessionImplTest3, IsValidSystemWindowType, Function | SmallTest | Level2)
668 {
669 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
670 ASSERT_NE(nullptr, option);
671 option->SetWindowName("IsValidSystemWindowType");
672 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
673 ASSERT_NE(nullptr, windowSceneSessionImpl);
674
675 WindowType type = WindowType::WINDOW_TYPE_DRAGGING_EFFECT;
676 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
677 type = WindowType::WINDOW_TYPE_SEARCHING_BAR;
678 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
679 type = WindowType::WINDOW_TYPE_PANEL;
680 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
681 type = WindowType::WINDOW_TYPE_VOLUME_OVERLAY;
682 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
683 type = WindowType::WINDOW_TYPE_INPUT_METHOD_STATUS_BAR;
684 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
685 type = WindowType::WINDOW_TYPE_SYSTEM_TOAST;
686 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
687 type = WindowType::WINDOW_TYPE_SYSTEM_FLOAT;
688 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
689 type = WindowType::WINDOW_TYPE_HANDWRITE;
690 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
691 type = WindowType::WINDOW_TYPE_NEGATIVE_SCREEN;
692 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
693 type = WindowType::WINDOW_TYPE_THEME_EDITOR;
694 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
695 }
696
697 /**
698 * @tc.name: UpdateFloatingWindowSizeBySizeLimits
699 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
700 * @tc.type: FUNC
701 */
702 HWTEST_F(WindowSceneSessionImplTest3, UpdateFloatingWindowSizeBySizeLimits, Function | SmallTest | Level2)
703 {
704 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
705 ASSERT_NE(nullptr, option);
706 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits");
707 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
708 ASSERT_NE(nullptr, windowSceneSessionImpl);
709
710 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
711 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_END);
712 uint32_t maxWidth = 32;
713 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
714 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
715 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
716 WindowLimits windowLimits = {0, 0, 0, 0, 0.0f, 0.0f};
717 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
718 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
719 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
720 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
721 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
722 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
723 }
724
725 /**
726 * @tc.name: UpdateFloatingWindowSizeBySizeLimits01
727 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
728 * @tc.type: FUNC
729 */
730 HWTEST_F(WindowSceneSessionImplTest3, UpdateFloatingWindowSizeBySizeLimits01, Function | SmallTest | Level2)
731 {
732 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
733 ASSERT_NE(nullptr, option);
734 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits01");
735 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
736 ASSERT_NE(nullptr, windowSceneSessionImpl);
737 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
738 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
739 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
740 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
741 uint32_t maxWidth = 32;
742 WindowLimits windowLimits = {1, 1, 1, 1, 0.0f, 2.0f};
743 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
744 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
745 WindowLimits windowLimits1 = {1, 2, 2, 2, 0.0f, 0.0f};
746 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits1);
747 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
748 WindowLimits windowLimits2 = {1, 2, 2, 2, 0.0f, 2.0f};
749 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits2);
750 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
751 }
752
753 /**
754 * @tc.name: IsDecorEnable
755 * @tc.desc: IsDecorEnable
756 * @tc.type: FUNC
757 */
758 HWTEST_F(WindowSceneSessionImplTest3, IsDecorEnable, Function | SmallTest | Level2)
759 {
760 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
761 ASSERT_NE(nullptr, option);
762 option->SetWindowName("IsDecorEnable");
763 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
764 ASSERT_NE(nullptr, windowSceneSessionImpl);
765
766 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
767 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
768 ASSERT_NE(nullptr, session);
769 windowSceneSessionImpl->hostSession_ = session;
770 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
771 windowSceneSessionImpl->property_->SetPersistentId(1);
772 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
773 windowSceneSessionImpl->DisableAppWindowDecor();
774 auto ret = windowSceneSessionImpl->IsDecorEnable();
775 EXPECT_EQ(false, ret);
776 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = false;
777 ret = windowSceneSessionImpl->IsDecorEnable();
778 EXPECT_EQ(false, ret);
779 }
780
781 /**
782 * @tc.name: Resize01
783 * @tc.desc: Resize
784 * @tc.type: FUNC
785 */
786 HWTEST_F(WindowSceneSessionImplTest3, Resize01, Function | SmallTest | Level2)
787 {
788 sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
789 ASSERT_NE(nullptr, subOption);
790 subOption->SetWindowName("Resize01SubWindow");
791 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
792 sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
793 ASSERT_NE(nullptr, subWindow);
794 ASSERT_NE(nullptr, subWindow->property_);
795 subWindow->property_->SetPersistentId(1002);
796 SessionInfo subSessionInfo = {"CreateSubTestBundle", "CreateSubTestMoudle", "CreateSubTestAbility"};
797 sptr<SessionMocker> subSession = new (std::nothrow) SessionMocker(subSessionInfo);
798 ASSERT_NE(nullptr, subSession);
799 subWindow->hostSession_ = subSession;
800 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, subWindow->Resize(100, 100));
801 subWindow->SetWindowType(WindowType::WINDOW_TYPE_PIP);
802 subWindow->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
803 sptr<WindowOption> option = new (std::nothrow) WindowOption();
804 ASSERT_NE(nullptr, option);
805 option->SetWindowName("Resize01");
806 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
807 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
808 ASSERT_NE(nullptr, window);
809 ASSERT_NE(nullptr, window->property_);
810 window->property_->SetPersistentId(1003);
811 SessionInfo sessionInfo = {"CreateSubTestBundle", "CreateSubTestMoudle", "CreateSubTestAbility"};
812 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
813 ASSERT_NE(nullptr, session);
814 window->hostSession_ = session;
815 Rect request = {100, 100, 100, 100};
816 subWindow->property_->SetRequestRect(request);
817 subWindow->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
818 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 100));
819 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
820 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
821 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
822 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 100));
823 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 200));
824 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
825 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(100, 200));
826 ASSERT_EQ(WMError::WM_OK, subWindow->Resize(200, 200));
827 ASSERT_EQ(WMError::WM_OK, subWindow->Destroy(true));
828 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
829 }
830
831 /**
832 * @tc.name: SetDefaultDensityEnabled
833 * @tc.desc: SetDefaultDensityEnabled
834 * @tc.type: FUNC
835 */
836 HWTEST_F(WindowSceneSessionImplTest3, SetDefaultDensityEnabled, Function | SmallTest | Level2)
837 {
838 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
839 ASSERT_NE(nullptr, option);
840 option->SetWindowName("SetDefaultDensityEnabled");
841 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
842 ASSERT_NE(nullptr, windowSceneSessionImpl);
843
844 windowSceneSessionImpl->hostSession_ = nullptr;
845 auto ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
846 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
847 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
848 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
849 ASSERT_NE(nullptr, session);
850 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
851 windowSceneSessionImpl->property_->SetPersistentId(1);
852 windowSceneSessionImpl->hostSession_ = session;
853 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
854 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
855 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
856 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
857 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
858 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
859 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
860 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(false);
861 EXPECT_EQ(WMError::WM_OK, ret);
862 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
863 EXPECT_EQ(WMError::WM_OK, ret);
864 }
865
866 /**
867 * @tc.name: RecoverAndReconnectSceneSession
868 * @tc.desc: RecoverAndReconnectSceneSession
869 * @tc.type: FUNC
870 */
871 HWTEST_F(WindowSceneSessionImplTest3, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
872 {
873 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
874 ASSERT_NE(nullptr, option);
875 option->SetWindowName("RecoverAndReconnectSceneSession");
876 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
877 ASSERT_NE(nullptr, windowSceneSessionImpl);
878
879 auto ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
880 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
881 windowSceneSessionImpl->isFocused_ = true;
882 ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
883 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
884 }
885
886 /**
887 * @tc.name: UpdateWindowState
888 * @tc.desc: UpdateWindowState
889 * @tc.type: FUNC
890 */
891 HWTEST_F(WindowSceneSessionImplTest3, UpdateWindowState, Function | SmallTest | Level2)
892 {
893 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
894 ASSERT_NE(nullptr, option);
895 option->SetWindowName("UpdateWindowState");
896 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
897 ASSERT_NE(nullptr, windowSceneSessionImpl);
898
899 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
900 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
901 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = UINT32_MAX;
902 windowSceneSessionImpl->UpdateWindowState();
903
904 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = 1920;
905 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
906 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(true);
907 windowSceneSessionImpl->UpdateWindowState();
908 EXPECT_EQ(1920, windowSceneSessionImpl->maxFloatingWindowSize_);
909 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
910 auto ret = windowSceneSessionImpl->property_->GetIsNeedUpdateWindowMode();
911 EXPECT_EQ(false, ret);
912 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
913 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(false);
914 windowSceneSessionImpl->UpdateWindowState();
915 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
916 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
917 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
918 windowSceneSessionImpl->property_->SetDragEnabled(true);
919 windowSceneSessionImpl->UpdateWindowState();
920 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
921 windowSceneSessionImpl->property_->SetDragEnabled(false);
922 windowSceneSessionImpl->UpdateWindowState();
923 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
924 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
925 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
926 windowSceneSessionImpl->property_->SetDragEnabled(true);
927 windowSceneSessionImpl->UpdateWindowState();
928 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
929 windowSceneSessionImpl->property_->SetDragEnabled(false);
930 windowSceneSessionImpl->UpdateWindowState();
931 }
932
933 /**
934 * @tc.name: Resize
935 * @tc.desc: Resize
936 * @tc.type: FUNC
937 */
938 HWTEST_F(WindowSceneSessionImplTest3, Resize, Function | SmallTest | Level2)
939 {
940 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
941 ASSERT_NE(nullptr, option);
942 option->SetWindowName("Resize");
943 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
944 ASSERT_NE(nullptr, windowSceneSessionImpl);
945
946 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
947 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
948 ASSERT_NE(nullptr, session);
949 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
950 windowSceneSessionImpl->property_->SetPersistentId(1);
951 windowSceneSessionImpl->hostSession_ = session;
952 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
953 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
954 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
955 auto ret = windowSceneSessionImpl->Resize(100, 100);
956 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
957 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
958 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
959 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
960 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
961 ret = windowSceneSessionImpl->Resize(100, 100);
962 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
963 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
964 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
965 ret = windowSceneSessionImpl->Resize(100, 100);
966 EXPECT_EQ(WMError::WM_OK, ret);
967 }
968
969 /**
970 * @tc.name: ResetAspectRatio
971 * @tc.desc: ResetAspectRatio
972 * @tc.type: FUNC
973 */
974 HWTEST_F(WindowSceneSessionImplTest3, ResetAspectRatio, Function | SmallTest | Level2)
975 {
976 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
977 ASSERT_NE(nullptr, option);
978 option->SetWindowName("ResetAspectRatio");
979 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
980 ASSERT_NE(nullptr, windowSceneSessionImpl);
981
982 windowSceneSessionImpl->hostSession_ = nullptr;
983 auto ret = windowSceneSessionImpl->ResetAspectRatio();
984 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
985 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
986 windowSceneSessionImpl->property_->SetPersistentId(1);
987 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
988 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
989 ASSERT_NE(nullptr, session);
990 windowSceneSessionImpl->hostSession_ = session;
991 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
992 ret = windowSceneSessionImpl->ResetAspectRatio();
993 EXPECT_EQ(WMError::WM_OK, ret);
994 }
995
996 /**
997 * @tc.name: GetAvoidAreaByType
998 * @tc.desc: GetAvoidAreaByType
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F(WindowSceneSessionImplTest3, GetAvoidAreaByType, Function | SmallTest | Level2)
1002 {
1003 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1004 ASSERT_NE(nullptr, option);
1005 option->SetWindowName("GetAvoidAreaByType");
1006 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1007 ASSERT_NE(nullptr, windowSceneSessionImpl);
1008
1009 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1010 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1011 ASSERT_NE(nullptr, session);
1012 windowSceneSessionImpl->property_->SetPersistentId(1);
1013 windowSceneSessionImpl->hostSession_ = session;
1014 AvoidArea avoidArea;
1015 auto ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
1016 EXPECT_EQ(WMError::WM_OK, ret);
1017 windowSceneSessionImpl->hostSession_ = nullptr;
1018 ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
1019 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1020 }
1021
1022 /**
1023 * @tc.name: IsLayoutFullScreen
1024 * @tc.desc: IsLayoutFullScreen
1025 * @tc.type: FUNC
1026 */
1027 HWTEST_F(WindowSceneSessionImplTest3, IsLayoutFullScreen, Function | SmallTest | Level2)
1028 {
1029 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1030 ASSERT_NE(nullptr, option);
1031 option->SetWindowName("IsLayoutFullScreen");
1032 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1033 ASSERT_NE(nullptr, windowSceneSessionImpl);
1034
1035 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1036 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1037 auto ret = windowSceneSessionImpl->IsLayoutFullScreen();
1038 EXPECT_EQ(false, ret);
1039 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1040 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1041 ret = windowSceneSessionImpl->IsLayoutFullScreen();
1042 EXPECT_EQ(false, ret);
1043 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1044 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1045 ret = windowSceneSessionImpl->IsLayoutFullScreen();
1046 EXPECT_EQ(false, ret);
1047 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1048 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
1049 ret = windowSceneSessionImpl->IsLayoutFullScreen();
1050 EXPECT_EQ(false, ret);
1051 }
1052
1053 /**
1054 * @tc.name: MaximizeFloating
1055 * @tc.desc: MaximizeFloating
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F(WindowSceneSessionImplTest3, MaximizeFloating, Function | SmallTest | Level2)
1059 {
1060 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1061 ASSERT_NE(nullptr, option);
1062 option->SetWindowName("MaximizeFloating");
1063 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1064 ASSERT_NE(nullptr, windowSceneSessionImpl);
1065
1066 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1067 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1068 ASSERT_NE(nullptr, session);
1069 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1070 windowSceneSessionImpl->property_->SetPersistentId(1);
1071 windowSceneSessionImpl->hostSession_ = session;
1072 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1073 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1074 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1075 auto ret = windowSceneSessionImpl->MaximizeFloating();
1076 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1077 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1078 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1079 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
1080 ret = windowSceneSessionImpl->MaximizeFloating();
1081 EXPECT_EQ(WMError::WM_OK, ret);
1082 auto ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
1083 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
1084 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1085 ret = windowSceneSessionImpl->MaximizeFloating();
1086 EXPECT_EQ(WMError::WM_OK, ret);
1087 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1088 windowSceneSessionImpl->property_->SetWindowModeSupportType(WINDOW_MODE_SUPPORT_FLOATING);
1089 ret = windowSceneSessionImpl->MaximizeFloating();
1090 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1091 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
1092 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
1093 windowSceneSessionImpl->hostSession_ = nullptr;
1094 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
1095 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
1096 }
1097
1098 /**
1099 * @tc.name: Recover
1100 * @tc.desc: Recover
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(WindowSceneSessionImplTest3, Recover, Function | SmallTest | Level2)
1104 {
1105 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1106 ASSERT_NE(nullptr, option);
1107 option->SetWindowName("Recover");
1108 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1109 ASSERT_NE(nullptr, windowSceneSessionImpl);
1110
1111 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1112 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1113 ASSERT_NE(nullptr, session);
1114 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1115 windowSceneSessionImpl->property_->SetPersistentId(1);
1116 windowSceneSessionImpl->hostSession_ = session;
1117 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1118 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1119 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1120 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1121 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1122 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1123 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1124 auto ret = windowSceneSessionImpl->Recover();
1125 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1126 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1127 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1128 ret = windowSceneSessionImpl->Recover();
1129 EXPECT_EQ(WMError::WM_OK, ret);
1130 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1131 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1132 ret = windowSceneSessionImpl->Recover();
1133 EXPECT_EQ(WMError::WM_OK, ret);
1134 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1135 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1136 ret = windowSceneSessionImpl->Recover();
1137 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1138 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1139 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1140 ret = windowSceneSessionImpl->Recover();
1141 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1142 }
1143
1144 /**
1145 * @tc.name: RestorePcMainWindow
1146 * @tc.desc: RestorePcMainWindow
1147 * @tc.type: FUNC
1148 */
1149 HWTEST_F(WindowSceneSessionImplTest3, RestorePcMainWindow, Function | SmallTest | Level2)
1150 {
1151 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1152 option->SetWindowName("Restore");
1153 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1154 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1155 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1156
1157 windowSceneSessionImpl->property_->SetPersistentId(1);
1158 windowSceneSessionImpl->hostSession_ = session;
1159 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1160 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PC;
1161 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1162 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1163 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1164 auto ret = windowSceneSessionImpl->Restore();
1165 EXPECT_EQ(WMError::WM_OK, ret);
1166
1167 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PC;
1168 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1169 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1170 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1171 ret = windowSceneSessionImpl->Restore();
1172 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1173 }
1174
1175 /**
1176 * @tc.name: RestorePcSubWindow
1177 * @tc.desc: RestorePcSubWindow
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(WindowSceneSessionImplTest3, RestorePcSubWindow, Function | SmallTest | Level2)
1181 {
1182 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1183 option->SetWindowName("Restore");
1184 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1185 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1186 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1187
1188 windowSceneSessionImpl->property_->SetPersistentId(1);
1189 windowSceneSessionImpl->hostSession_ = session;
1190 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1191 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PC;
1192 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1193 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1194 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1195 auto ret = windowSceneSessionImpl->Restore();
1196 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1197
1198 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PC;
1199 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1200 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1201 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1202 ret = windowSceneSessionImpl->Restore();
1203 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1204 }
1205
1206 /**
1207 * @tc.name: RestorePadMainWindow
1208 * @tc.desc: RestorePadMainWindow
1209 * @tc.type: FUNC
1210 */
1211 HWTEST_F(WindowSceneSessionImplTest3, RestorePadMainWindow, Function | SmallTest | Level2)
1212 {
1213 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1214 option->SetWindowName("Restore");
1215 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1216 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1217 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1218
1219 windowSceneSessionImpl->property_->SetPersistentId(1);
1220 windowSceneSessionImpl->hostSession_ = session;
1221 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1222 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1223 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1224 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1225 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1226 auto ret = windowSceneSessionImpl->Restore();
1227 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1228
1229 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1230 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1231 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1232 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1233 ret = windowSceneSessionImpl->Restore();
1234 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1235
1236 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1237 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1238 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1239 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1240 ret = windowSceneSessionImpl->Restore();
1241 EXPECT_EQ(WMError::WM_OK, ret);
1242 }
1243
1244 /**
1245 * @tc.name: RestorePadSubWindow
1246 * @tc.desc: RestorePadSubWindow
1247 * @tc.type: FUNC
1248 */
1249 HWTEST_F(WindowSceneSessionImplTest3, RestorePadSubWindow, Function | SmallTest | Level2)
1250 {
1251 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1252 option->SetWindowName("Restore");
1253 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1254 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1255 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1256
1257 windowSceneSessionImpl->property_->SetPersistentId(1);
1258 windowSceneSessionImpl->hostSession_ = session;
1259 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1260 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1261 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1262 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1263 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1264 auto ret = windowSceneSessionImpl->Restore();
1265 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1266
1267 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1268 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1269 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1270 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1271 ret = windowSceneSessionImpl->Restore();
1272 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1273
1274 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1275 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1276 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1277 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1278 ret = windowSceneSessionImpl->Restore();
1279 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1280 }
1281
1282 /**
1283 * @tc.name: RestorePadFloatingMainWindow
1284 * @tc.desc: RestorePadFloatingMainWindow
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(WindowSceneSessionImplTest3, RestorePadFloatingMainWindow, Function | SmallTest | Level2)
1288 {
1289 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1290 option->SetWindowName("Restore");
1291 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1292 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1293 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1294
1295 windowSceneSessionImpl->property_->SetPersistentId(1);
1296 windowSceneSessionImpl->hostSession_ = session;
1297 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1298 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1299 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1300 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1301 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1302 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1303 auto ret = windowSceneSessionImpl->Restore();
1304 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1305
1306 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1307 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1308 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1309 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1310 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1311 ret = windowSceneSessionImpl->Restore();
1312 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1313
1314 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1315 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1316 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1317 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1318 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1319 ret = windowSceneSessionImpl->Restore();
1320 EXPECT_EQ(WMError::WM_OK, ret);
1321 }
1322
1323 /**
1324 * @tc.name: RestorePadFloatingSubWindow
1325 * @tc.desc: RestorePadFloatingSubWindow
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(WindowSceneSessionImplTest3, RestorePadFloatingSubWindow, Function | SmallTest | Level2)
1329 {
1330 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1331 option->SetWindowName("Restore");
1332 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1333 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1334 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1335
1336 windowSceneSessionImpl->property_->SetPersistentId(1);
1337 windowSceneSessionImpl->hostSession_ = session;
1338 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1339 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1340 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1341 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1342 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1343 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1344 auto ret = windowSceneSessionImpl->Restore();
1345 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1346
1347 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1348 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1349 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1350 windowSceneSessionImpl->property_->SetIsPcAppInPad(false);
1351 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(true);
1352 ret = windowSceneSessionImpl->Restore();
1353 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1354
1355 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1356 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1357 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1358 windowSceneSessionImpl->property_->SetIsPcAppInPad(true);
1359 windowSceneSessionImpl->property_->SetIsAppSupportPhoneInPc(false);
1360 ret = windowSceneSessionImpl->Restore();
1361 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1362 }
1363
1364 /**
1365 * @tc.name: StartMove
1366 * @tc.desc: StartMove
1367 * @tc.type: FUNC
1368 */
1369 HWTEST_F(WindowSceneSessionImplTest3, StartMove, Function | SmallTest | Level2)
1370 {
1371 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1372 ASSERT_NE(nullptr, option);
1373 option->SetWindowName("StartMove");
1374 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1375 ASSERT_NE(nullptr, windowSceneSessionImpl);
1376
1377 windowSceneSessionImpl->hostSession_ = nullptr;
1378 windowSceneSessionImpl->StartMove();
1379 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1380 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1381 ASSERT_NE(nullptr, session);
1382 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1383 windowSceneSessionImpl->property_->SetPersistentId(1);
1384 windowSceneSessionImpl->hostSession_ = session;
1385 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1386 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1387 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1388 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1389 windowSceneSessionImpl->StartMove();
1390 }
1391
1392 /**
1393 * @tc.name: IsStartMoving
1394 * @tc.desc: get main window move flag, test IsStartMoving
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(WindowSceneSessionImplTest3, IsStartMoving, Function | SmallTest | Level2)
1398 {
1399 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1400 ASSERT_NE(nullptr, option);
1401 option->SetWindowName("IsStartMoving");
1402 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1403 ASSERT_NE(nullptr, windowSceneSessionImpl);
1404
1405 bool isMoving = windowSceneSessionImpl->IsStartMoving();
1406 EXPECT_EQ(false, isMoving);
1407 }
1408
1409 /**
1410 * @tc.name: DisableAppWindowDecor
1411 * @tc.desc: DisableAppWindowDecor
1412 * @tc.type: FUNC
1413 */
1414 HWTEST_F(WindowSceneSessionImplTest3, DisableAppWindowDecor, Function | SmallTest | Level2)
1415 {
1416 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1417 ASSERT_NE(nullptr, option);
1418 option->SetWindowName("DisableAppWindowDecor");
1419 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1420 ASSERT_NE(nullptr, windowSceneSessionImpl);
1421
1422 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1423 windowSceneSessionImpl->property_->SetPersistentId(1);
1424 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1425 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1426 ASSERT_NE(nullptr, session);
1427 windowSceneSessionImpl->hostSession_ = session;
1428
1429 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1430 auto ret = windowSceneSessionImpl->DisableAppWindowDecor();
1431 EXPECT_EQ(WMError::WM_OK, ret);
1432 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1433 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1434 ret = windowSceneSessionImpl->DisableAppWindowDecor();
1435 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1436 }
1437
1438 /**
1439 * @tc.name: SetShadowRadius
1440 * @tc.desc: SetShadowRadius
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(WindowSceneSessionImplTest3, SetShadowRadius, Function | SmallTest | Level2)
1444 {
1445 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1446 ASSERT_NE(nullptr, option);
1447 option->SetWindowName("SetShadowRadius");
1448 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1449 ASSERT_NE(nullptr, windowSceneSessionImpl);
1450
1451 windowSceneSessionImpl->surfaceNode_ = nullptr;
1452 auto ret = windowSceneSessionImpl->SetShadowRadius(1.0f);
1453 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1454 ret = windowSceneSessionImpl->SetShadowOffsetY(1.0f);
1455 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1456
1457 Transform trans;
1458 windowSceneSessionImpl->hostSession_ = nullptr;
1459 ret = windowSceneSessionImpl->SetTransform(trans);
1460 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1461 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1462 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1463 ASSERT_NE(nullptr, session);
1464 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1465 windowSceneSessionImpl->property_->SetPersistentId(1);
1466 windowSceneSessionImpl->hostSession_ = session;
1467 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1468 ret = windowSceneSessionImpl->SetTransform(trans);
1469 EXPECT_EQ(WMError::WM_OK, ret);
1470 }
1471
1472 /**
1473 * @tc.name: UpdateMaximizeMode
1474 * @tc.desc: UpdateMaximizeMode
1475 * @tc.type: FUNC
1476 */
1477 HWTEST_F(WindowSceneSessionImplTest3, UpdateMaximizeMode, Function | SmallTest | Level2)
1478 {
1479 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1480 ASSERT_NE(nullptr, option);
1481 option->SetWindowName("UpdateMaximizeMode");
1482 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1483 ASSERT_NE(nullptr, windowSceneSessionImpl);
1484
1485 windowSceneSessionImpl->uiContent_ = nullptr;
1486 auto ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1487 EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
1488 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1489 ASSERT_NE(nullptr, windowSceneSessionImpl->uiContent_);
1490 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1491 EXPECT_EQ(WSError::WS_OK, ret);
1492 }
1493
1494 /**
1495 * @tc.name: GetSystemBarProperties
1496 * @tc.desc: GetSystemBarProperties
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(WindowSceneSessionImplTest3, GetSystemBarProperties, Function | SmallTest | Level2)
1500 {
1501 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1502 ASSERT_NE(nullptr, option);
1503 option->SetWindowName("GetSystemBarProperties");
1504 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1505 ASSERT_NE(nullptr, windowSceneSessionImpl);
1506 std::map<WindowType, SystemBarProperty> properties;
1507
1508 auto ret = windowSceneSessionImpl->GetSystemBarProperties(properties);
1509 EXPECT_EQ(WMError::WM_OK, ret);
1510 }
1511
1512 /**
1513 * @tc.name: Hide
1514 * @tc.desc: Hide
1515 * @tc.type: FUNC
1516 */
1517 HWTEST_F(WindowSceneSessionImplTest3, Hide, Function | SmallTest | Level2)
1518 {
1519 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1520 ASSERT_NE(nullptr, option);
1521 option->SetWindowName("Hide");
1522 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1523 ASSERT_NE(nullptr, windowSceneSessionImpl);
1524
1525 windowSceneSessionImpl->hostSession_ = nullptr;
1526 auto ret = windowSceneSessionImpl->Hide(2, false, false);
1527 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1528 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1529 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1530 ASSERT_NE(nullptr, session);
1531 windowSceneSessionImpl->hostSession_ = session;
1532 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1533 windowSceneSessionImpl->property_->SetPersistentId(0);
1534 ret = windowSceneSessionImpl->Hide(2, false, false);
1535 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1536 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1537 windowSceneSessionImpl->property_->SetPersistentId(1);
1538 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1539 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1540 ret = windowSceneSessionImpl->Hide(2, false, false);
1541 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1542 }
1543
1544 /**
1545 * @tc.name: IsSessionMainWindow
1546 * @tc.desc: IsSessionMainWindow
1547 * @tc.type: FUNC
1548 */
1549 HWTEST_F(WindowSceneSessionImplTest3, IsSessionMainWindow, Function | SmallTest | Level2)
1550 {
1551 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1552 ASSERT_NE(nullptr, option);
1553 option->SetWindowName("IsSessionMainWindow");
1554 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1555 ASSERT_NE(nullptr, windowSceneSessionImpl);
1556
1557 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1558 ASSERT_NE(nullptr, windowSession);
1559 ASSERT_NE(nullptr, windowSession->property_);
1560 windowSession->property_->SetPersistentId(1);
1561 ASSERT_NE(nullptr, windowSession->property_);
1562 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1563 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1564 auto ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1565 EXPECT_EQ(true, ret);
1566 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1567 ASSERT_NE(nullptr, windowSession->property_);
1568 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1569 ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1570 EXPECT_EQ(false, ret);
1571 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1572 EXPECT_EQ(false, ret);
1573 windowSession = nullptr;
1574 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1575 EXPECT_EQ(false, ret);
1576 }
1577
1578 /**
1579 * @tc.name: Show
1580 * @tc.desc: Show
1581 * @tc.type: FUNC
1582 */
1583 HWTEST_F(WindowSceneSessionImplTest3, Show, Function | SmallTest | Level2)
1584 {
1585 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1586 ASSERT_NE(nullptr, option);
1587 option->SetWindowName("Show");
1588 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1589 ASSERT_NE(nullptr, windowSceneSessionImpl);
1590
1591 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1592 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1593 ASSERT_NE(nullptr, session);
1594 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1595 windowSceneSessionImpl->property_->SetPersistentId(1);
1596 windowSceneSessionImpl->hostSession_ = session;
1597 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1598 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1599 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1600 auto ret = windowSceneSessionImpl->Show(2, true);
1601 EXPECT_EQ(WMError::WM_OK, ret);
1602 ret = windowSceneSessionImpl->Maximize();
1603 EXPECT_EQ(WMError::WM_OK, ret);
1604 ret = windowSceneSessionImpl->Minimize();
1605 EXPECT_EQ(WMError::WM_OK, ret);
1606 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1607 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1608 ret = windowSceneSessionImpl->Minimize();
1609 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1610 ret = windowSceneSessionImpl->Maximize();
1611 EXPECT_EQ(WMError::WM_OK, ret);
1612 ret = windowSceneSessionImpl->Minimize();
1613 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1614 }
1615
1616 /**
1617 * @tc.name: Show01
1618 * @tc.desc: Show withFocus params
1619 * @tc.type: FUNC
1620 */
1621 HWTEST_F(WindowSceneSessionImplTest3, Show01, Function | SmallTest | Level2)
1622 {
1623 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1624 ASSERT_NE(nullptr, option);
1625 option->SetWindowName("Show01");
1626 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1627 ASSERT_NE(nullptr, windowSceneSessionImpl);
1628
1629 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1630 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1631 ASSERT_NE(nullptr, session);
1632 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1633 windowSceneSessionImpl->property_->SetPersistentId(1);
1634 windowSceneSessionImpl->hostSession_ = session;
1635 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1636 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1637 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1638 auto ret = windowSceneSessionImpl->Show(2, true);
1639 EXPECT_EQ(WMError::WM_OK, ret);
1640 }
1641
1642 /**
1643 * @tc.name: Show02
1644 * @tc.desc: Show withFocus params
1645 * @tc.type: FUNC
1646 */
1647 HWTEST_F(WindowSceneSessionImplTest3, Show02, Function | SmallTest | Level2)
1648 {
1649 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1650 option->SetWindowName("Show02");
1651 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1652
1653 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1654 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1655 windowSceneSessionImpl->property_->SetPersistentId(1);
1656 windowSceneSessionImpl->hostSession_ = session;
1657 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1658 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1659 auto ret = windowSceneSessionImpl->Show(0, false, true);
1660 EXPECT_EQ(WMError::WM_OK, ret);
1661 ret = windowSceneSessionImpl->Show(0, false, false);
1662 EXPECT_EQ(WMError::WM_OK, ret);
1663 }
1664
1665 /**
1666 * @tc.name: NotifySpecificWindowSessionProperty
1667 * @tc.desc: NotifySpecificWindowSessionProperty
1668 * @tc.type: FUNC
1669 */
1670 HWTEST_F(WindowSceneSessionImplTest3, NotifySpecificWindowSessionProperty, Function | SmallTest | Level2)
1671 {
1672 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1673 ASSERT_NE(nullptr, option);
1674 option->SetWindowName("NotifySpecificWindowSessionProperty");
1675 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1676 ASSERT_NE(nullptr, windowSceneSessionImpl);
1677
1678 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1679 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1680 ASSERT_NE(nullptr, session);
1681 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1682 windowSceneSessionImpl->property_->SetPersistentId(1);
1683 windowSceneSessionImpl->hostSession_ = session;
1684 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1685 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
1686 SystemBarProperty property;
1687 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1688 auto ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1689 EXPECT_EQ(WMError::WM_OK, ret);
1690 ret = windowSceneSessionImpl->SetWindowFlags(0);
1691 EXPECT_EQ(WMError::WM_OK, ret);
1692 type = WindowType::WINDOW_TYPE_NAVIGATION_BAR;
1693 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1694 EXPECT_EQ(WMError::WM_OK, ret);
1695 type = WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR;
1696 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1697 EXPECT_EQ(WMError::WM_OK, ret);
1698 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1699 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1700 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
1701 EXPECT_EQ(WMError::WM_OK, ret);
1702 windowSceneSessionImpl->hostSession_ = nullptr;
1703 ret = windowSceneSessionImpl->SetWindowFlags(0);
1704 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1705 }
1706
1707 /**
1708 * @tc.name: Close
1709 * @tc.desc: Close
1710 * @tc.type: FUNC
1711 */
1712 HWTEST_F(WindowSceneSessionImplTest3, Close, Function | SmallTest | Level2)
1713 {
1714 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1715 ASSERT_NE(nullptr, option);
1716 option->SetWindowName("Close");
1717 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1718 ASSERT_NE(nullptr, windowSceneSessionImpl);
1719
1720 windowSceneSessionImpl->hostSession_ = nullptr;
1721 auto ret = windowSceneSessionImpl->Close();
1722 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1723 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1724 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1725 ASSERT_NE(nullptr, session);
1726 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1727 windowSceneSessionImpl->property_->SetPersistentId(1);
1728 windowSceneSessionImpl->hostSession_ = session;
1729 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1730 ASSERT_NE(nullptr, abilityContext_);
1731 windowSceneSessionImpl->context_ = abilityContext_;
1732 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1733 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1734 ret = windowSceneSessionImpl->Close();
1735 EXPECT_EQ(WMError::WM_OK, ret);
1736 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1737 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1738 ret = windowSceneSessionImpl->Close();
1739 EXPECT_EQ(WMError::WM_OK, ret);
1740 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1741 windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1742 ret = windowSceneSessionImpl->Close();
1743 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1744 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1745 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1746 ret = windowSceneSessionImpl->Close();
1747 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1748 }
1749
1750 /**
1751 * @tc.name: GetWindowWithId
1752 * @tc.desc: GetWindowWithId
1753 * @tc.type: FUNC
1754 */
1755 HWTEST_F(WindowSceneSessionImplTest3, GetWindowWithId, Function | SmallTest | Level2)
1756 {
1757 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1758 ASSERT_NE(nullptr, option);
1759 option->SetWindowName("GetWindowWithId");
1760 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1761 ASSERT_NE(nullptr, windowSceneSessionImpl);
1762
1763 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1764 ASSERT_NE(nullptr, windowSession);
1765 ASSERT_NE(nullptr, windowSession->property_);
1766 windowSession->property_->SetPersistentId(1);
1767 ASSERT_NE(nullptr, windowSession->property_);
1768 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1769 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1770 auto ret = windowSceneSessionImpl->GetWindowWithId(1);
1771 EXPECT_FALSE(ret == nullptr);
1772 ret = windowSceneSessionImpl->GetWindowWithId(0);
1773 EXPECT_FALSE(ret == nullptr);
1774 windowSession = nullptr;
1775 ret = windowSceneSessionImpl->GetWindowWithId(0);
1776 EXPECT_FALSE(ret == nullptr);
1777 }
1778
1779 /**
1780 * @tc.name: PreNotifyKeyEvent
1781 * @tc.desc: PreNotifyKeyEvent
1782 * @tc.type: FUNC
1783 */
1784 HWTEST_F(WindowSceneSessionImplTest3, PreNotifyKeyEvent, Function | SmallTest | Level2)
1785 {
1786 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1787 ASSERT_NE(nullptr, option);
1788 option->SetWindowName("PreNotifyKeyEvent");
1789 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1790 ASSERT_NE(nullptr, windowSceneSessionImpl);
1791
1792 std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
1793 windowSceneSessionImpl->uiContent_ = nullptr;
1794 auto ret = windowSceneSessionImpl->PreNotifyKeyEvent(keyEvent);
1795 EXPECT_EQ(false, ret);
1796 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1797 ASSERT_NE(nullptr, windowSceneSessionImpl->uiContent_);
1798 EXPECT_EQ(false, ret);
1799 }
1800
1801 /**
1802 * @tc.name: Recover01
1803 * @tc.desc: Recover
1804 * @tc.type: FUNC
1805 */
1806 HWTEST_F(WindowSceneSessionImplTest3, Recover01, Function | SmallTest | Level2)
1807 {
1808 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1809 ASSERT_NE(nullptr, option);
1810 option->SetWindowName("Recover");
1811 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1812 ASSERT_NE(nullptr, windowSceneSessionImpl);
1813
1814 windowSceneSessionImpl->hostSession_ = nullptr;
1815 auto ret = windowSceneSessionImpl->Recover(1);
1816 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1817 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1818 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1819 ASSERT_NE(nullptr, session);
1820 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1821 windowSceneSessionImpl->property_->SetPersistentId(1);
1822 windowSceneSessionImpl->hostSession_ = session;
1823 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1824 windowSceneSessionImpl->windowSystemConfig_.uiType_ = "phone";
1825 ret = windowSceneSessionImpl->Recover(1);
1826 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1827 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = true;
1828 ret = windowSceneSessionImpl->Recover(1);
1829 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1830 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1831 windowSceneSessionImpl->windowSystemConfig_.uiType_ = "pc";
1832 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1833 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1834 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1835 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1836 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1837 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1838 ret = windowSceneSessionImpl->Recover(1);
1839 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1840 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1841 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
1842 ret = windowSceneSessionImpl->Recover(1);
1843 EXPECT_EQ(WMError::WM_OK, ret);
1844 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1845 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1846 ret = windowSceneSessionImpl->Recover(1);
1847 EXPECT_EQ(WMError::WM_OK, ret);
1848 ret = windowSceneSessionImpl->Recover(0);
1849 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1850 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1851 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1852 ret = windowSceneSessionImpl->Recover(0);
1853 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1854 }
1855
1856 /**
1857 * @tc.name: FindParentSessionByParentId
1858 * @tc.desc: FindParentSessionByParentId
1859 * @tc.type: FUNC
1860 */
1861 HWTEST_F(WindowSceneSessionImplTest3, FindParentSessionByParentId, Function | SmallTest | Level2)
1862 {
1863 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1864 ASSERT_NE(nullptr, option);
1865 option->SetWindowName("FindParentSessionByParentId");
1866 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1867 ASSERT_NE(nullptr, windowSceneSessionImpl);
1868
1869 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1870 ASSERT_NE(nullptr, windowSession);
1871 ASSERT_NE(nullptr, windowSession->property_);
1872 windowSession->property_->SetPersistentId(1);
1873
1874 ASSERT_NE(nullptr, windowSession->property_);
1875 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1876 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1877 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1878 ASSERT_NE(nullptr, windowSession->property_);
1879 windowSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1880 ASSERT_NE(nullptr, windowSession->property_);
1881 windowSession->property_->SetParentPersistentId(1);
1882 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1883 ASSERT_NE(nullptr, windowSession->property_);
1884 windowSession->property_->SetParentPersistentId(0);
1885 ASSERT_NE(nullptr, windowSession->property_);
1886 windowSession->property_->SetExtensionFlag(true);
1887 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1888 }
1889
1890 /**
1891 * @tc.name: PreLayoutOnShow
1892 * @tc.desc: PreLayoutOnShow
1893 * @tc.type: FUNC
1894 */
1895 HWTEST_F(WindowSceneSessionImplTest3, PreLayoutOnShow, Function | SmallTest | Level2)
1896 {
1897 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1898 ASSERT_NE(nullptr, option);
1899 option->SetWindowName("PreLayoutOnShow");
1900 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1901 ASSERT_NE(nullptr, window);
1902 ASSERT_NE(nullptr, window->property_);
1903 window->property_->SetPersistentId(1);
1904
1905 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1906 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1907 ASSERT_NE(nullptr, session);
1908
1909 window->hostSession_ = session;
1910 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1911 ASSERT_NE(nullptr, window->uiContent_);
1912 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1913
1914 Rect request = { 100, 100, 100, 100 };
1915 window->property_->SetRequestRect(request);
1916 window->PreLayoutOnShow(window->property_->GetWindowType());
1917 request = { 100, 100, 0, 100 };
1918 window->property_->SetRequestRect(request);
1919 window->PreLayoutOnShow(window->property_->GetWindowType());
1920 request = { 100, 100, 100, 0 };
1921 window->property_->SetRequestRect(request);
1922 window->PreLayoutOnShow(window->property_->GetWindowType());
1923 }
1924
1925 /**
1926 * @tc.name: InitSystemSessionDragEnable_IsDialogOrNot
1927 * @tc.desc: InitSystemSessionDragEnable Test, is dialog window or not
1928 * @tc.type: FUNC
1929 */
1930 HWTEST_F(WindowSceneSessionImplTest3, InitSystemSessionDragEnable_IsDialogOrNot, Function | SmallTest | Level2)
1931 {
1932 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1933 option->SetWindowName("InitSystemSessionDragEnable_IsDialogOrNot");
1934 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1935 window->property_->SetPersistentId(1);
1936 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1937 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1938 window->hostSession_ = session;
1939
1940 window->property_->SetDragEnabled(true);
1941 window->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1942 window->InitSystemSessionDragEnable();
1943 ASSERT_EQ(window->property_->GetDragEnabled(), false);
1944
1945 window->property_->SetDragEnabled(true);
1946 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1947 window->InitSystemSessionDragEnable();
1948 ASSERT_EQ(window->property_->GetDragEnabled(), true);
1949 }
1950
1951 /**
1952 * @tc.name: SetWindowRectAutoSave
1953 * @tc.desc: SetWindowRectAutoSave
1954 * @tc.type: FUNC
1955 */
1956 HWTEST_F(WindowSceneSessionImplTest3, SetWindowRectAutoSave, Function | SmallTest | Level2)
1957 {
1958 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1959 option->SetWindowName("SetWindowRectAutoSave");
1960 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1961 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1962 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1963 windowSceneSessionImpl->property_->SetPersistentId(1);
1964 windowSceneSessionImpl->hostSession_ = session;
1965 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PC;
1966 auto ret = windowSceneSessionImpl->SetWindowRectAutoSave(true);
1967 EXPECT_EQ(WMError::WM_OK, ret);
1968 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
1969 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true);
1970 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1971 windowSceneSessionImpl->windowSystemConfig_.uiType_ = UI_TYPE_PHONE;
1972 ret = windowSceneSessionImpl->SetWindowRectAutoSave(true);
1973 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1974 }
1975 }
1976 } // namespace Rosen
1977 } // namespace OHOS