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: IsValidSystemWindowType
641 * @tc.desc: IsValidSystemWindowType
642 * @tc.type: FUNC
643 */
644 HWTEST_F(WindowSceneSessionImplTest3, IsValidSystemWindowType, Function | SmallTest | Level2)
645 {
646 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
647 ASSERT_NE(nullptr, option);
648 option->SetWindowName("IsValidSystemWindowType");
649 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
650 ASSERT_NE(nullptr, windowSceneSessionImpl);
651
652 WindowType type = WindowType::WINDOW_TYPE_DRAGGING_EFFECT;
653 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
654 type = WindowType::WINDOW_TYPE_SEARCHING_BAR;
655 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
656 type = WindowType::WINDOW_TYPE_PANEL;
657 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
658 type = WindowType::WINDOW_TYPE_VOLUME_OVERLAY;
659 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
660 type = WindowType::WINDOW_TYPE_INPUT_METHOD_STATUS_BAR;
661 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
662 type = WindowType::WINDOW_TYPE_SYSTEM_TOAST;
663 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
664 type = WindowType::WINDOW_TYPE_SYSTEM_FLOAT;
665 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
666 type = WindowType::WINDOW_TYPE_HANDWRITE;
667 EXPECT_FALSE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
668 type = WindowType::WINDOW_TYPE_NEGATIVE_SCREEN;
669 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
670 type = WindowType::WINDOW_TYPE_THEME_EDITOR;
671 EXPECT_TRUE(!windowSceneSessionImpl->IsValidSystemWindowType(type));
672 }
673
674 /**
675 * @tc.name: UpdateFloatingWindowSizeBySizeLimits
676 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
677 * @tc.type: FUNC
678 */
679 HWTEST_F(WindowSceneSessionImplTest3, UpdateFloatingWindowSizeBySizeLimits, Function | SmallTest | Level2)
680 {
681 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
682 ASSERT_NE(nullptr, option);
683 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits");
684 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
685 ASSERT_NE(nullptr, windowSceneSessionImpl);
686
687 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
688 windowSceneSessionImpl->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_END);
689 uint32_t maxWidth = 32;
690 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
691 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
692 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
693 WindowLimits windowLimits = {0, 0, 0, 0, 0.0f, 0.0f};
694 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
695 windowSceneSessionImpl->property_->SetWindowLimits(windowLimits);
696 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
697 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
698 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
699 windowSceneSessionImpl->UpdateFloatingWindowSizeBySizeLimits(maxWidth, maxWidth);
700 }
701
702 /**
703 * @tc.name: IsDecorEnable
704 * @tc.desc: IsDecorEnable
705 * @tc.type: FUNC
706 */
707 HWTEST_F(WindowSceneSessionImplTest3, IsDecorEnable, Function | SmallTest | Level2)
708 {
709 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
710 ASSERT_NE(nullptr, option);
711 option->SetWindowName("IsDecorEnable");
712 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
713 ASSERT_NE(nullptr, windowSceneSessionImpl);
714
715 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
716 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
717 ASSERT_NE(nullptr, session);
718 windowSceneSessionImpl->hostSession_ = session;
719 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
720 windowSceneSessionImpl->property_->SetPersistentId(1);
721 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
722 windowSceneSessionImpl->DisableAppWindowDecor();
723 auto ret = windowSceneSessionImpl->IsDecorEnable();
724 EXPECT_EQ(false, ret);
725 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = false;
726 ret = windowSceneSessionImpl->IsDecorEnable();
727 EXPECT_EQ(false, ret);
728 }
729
730 /**
731 * @tc.name: SetDefaultDensityEnabled
732 * @tc.desc: SetDefaultDensityEnabled
733 * @tc.type: FUNC
734 */
735 HWTEST_F(WindowSceneSessionImplTest3, SetDefaultDensityEnabled, Function | SmallTest | Level2)
736 {
737 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
738 ASSERT_NE(nullptr, option);
739 option->SetWindowName("SetDefaultDensityEnabled");
740 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
741 ASSERT_NE(nullptr, windowSceneSessionImpl);
742
743 windowSceneSessionImpl->hostSession_ = nullptr;
744 auto ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
745 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
746 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
747 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
748 ASSERT_NE(nullptr, session);
749 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
750 windowSceneSessionImpl->property_->SetPersistentId(1);
751 windowSceneSessionImpl->hostSession_ = session;
752 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
753 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
754 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
755 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
756 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
757 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
758 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
759 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(false);
760 EXPECT_EQ(WMError::WM_OK, ret);
761 ret = windowSceneSessionImpl->SetDefaultDensityEnabled(true);
762 EXPECT_EQ(WMError::WM_OK, ret);
763 }
764
765 /**
766 * @tc.name: RecoverAndReconnectSceneSession
767 * @tc.desc: RecoverAndReconnectSceneSession
768 * @tc.type: FUNC
769 */
770 HWTEST_F(WindowSceneSessionImplTest3, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
771 {
772 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
773 ASSERT_NE(nullptr, option);
774 option->SetWindowName("RecoverAndReconnectSceneSession");
775 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
776 ASSERT_NE(nullptr, windowSceneSessionImpl);
777
778 auto ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
779 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
780 windowSceneSessionImpl->isFocused_ = true;
781 ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
782 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
783 }
784
785 /**
786 * @tc.name: UpdateWindowState
787 * @tc.desc: UpdateWindowState
788 * @tc.type: FUNC
789 */
790 HWTEST_F(WindowSceneSessionImplTest3, UpdateWindowState, Function | SmallTest | Level2)
791 {
792 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
793 ASSERT_NE(nullptr, option);
794 option->SetWindowName("UpdateWindowState");
795 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
796 ASSERT_NE(nullptr, windowSceneSessionImpl);
797
798 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
799 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
800 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = UINT32_MAX;
801 windowSceneSessionImpl->UpdateWindowState();
802
803 windowSceneSessionImpl->windowSystemConfig_.maxFloatingWindowSize_ = 1920;
804 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
805 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(true);
806 windowSceneSessionImpl->UpdateWindowState();
807 EXPECT_EQ(1920, windowSceneSessionImpl->maxFloatingWindowSize_);
808 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
809 auto ret = windowSceneSessionImpl->property_->GetIsNeedUpdateWindowMode();
810 EXPECT_EQ(false, ret);
811 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
812 windowSceneSessionImpl->property_->SetIsNeedUpdateWindowMode(false);
813 windowSceneSessionImpl->UpdateWindowState();
814 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
815 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
816 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
817 windowSceneSessionImpl->property_->SetDragEnabled(true);
818 windowSceneSessionImpl->UpdateWindowState();
819 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
820 windowSceneSessionImpl->property_->SetDragEnabled(false);
821 windowSceneSessionImpl->UpdateWindowState();
822 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
823 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
824 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
825 windowSceneSessionImpl->property_->SetDragEnabled(true);
826 windowSceneSessionImpl->UpdateWindowState();
827 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
828 windowSceneSessionImpl->property_->SetDragEnabled(false);
829 windowSceneSessionImpl->UpdateWindowState();
830 }
831
832 /**
833 * @tc.name: Resize
834 * @tc.desc: Resize
835 * @tc.type: FUNC
836 */
837 HWTEST_F(WindowSceneSessionImplTest3, Resize, Function | SmallTest | Level2)
838 {
839 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
840 ASSERT_NE(nullptr, option);
841 option->SetWindowName("Resize");
842 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
843 ASSERT_NE(nullptr, windowSceneSessionImpl);
844
845 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
846 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
847 ASSERT_NE(nullptr, session);
848 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
849 windowSceneSessionImpl->property_->SetPersistentId(1);
850 windowSceneSessionImpl->hostSession_ = session;
851 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
852 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
853 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
854 auto ret = windowSceneSessionImpl->Resize(100, 100);
855 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
856 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
857 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
858 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
859 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
860 ret = windowSceneSessionImpl->Resize(100, 100);
861 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
862 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
863 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
864 ret = windowSceneSessionImpl->Resize(100, 100);
865 EXPECT_EQ(WMError::WM_OK, ret);
866 }
867
868 /**
869 * @tc.name: ResetAspectRatio
870 * @tc.desc: ResetAspectRatio
871 * @tc.type: FUNC
872 */
873 HWTEST_F(WindowSceneSessionImplTest3, ResetAspectRatio, Function | SmallTest | Level2)
874 {
875 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
876 ASSERT_NE(nullptr, option);
877 option->SetWindowName("ResetAspectRatio");
878 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
879 ASSERT_NE(nullptr, windowSceneSessionImpl);
880
881 windowSceneSessionImpl->hostSession_ = nullptr;
882 auto ret = windowSceneSessionImpl->ResetAspectRatio();
883 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
884 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
885 windowSceneSessionImpl->property_->SetPersistentId(1);
886 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
887 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
888 ASSERT_NE(nullptr, session);
889 windowSceneSessionImpl->hostSession_ = session;
890 windowSceneSessionImpl->state_ = WindowState::STATE_CREATED;
891 ret = windowSceneSessionImpl->ResetAspectRatio();
892 EXPECT_EQ(WMError::WM_OK, ret);
893 }
894
895 /**
896 * @tc.name: GetAvoidAreaByType
897 * @tc.desc: GetAvoidAreaByType
898 * @tc.type: FUNC
899 */
900 HWTEST_F(WindowSceneSessionImplTest3, GetAvoidAreaByType, Function | SmallTest | Level2)
901 {
902 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
903 ASSERT_NE(nullptr, option);
904 option->SetWindowName("GetAvoidAreaByType");
905 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
906 ASSERT_NE(nullptr, windowSceneSessionImpl);
907
908 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
909 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
910 ASSERT_NE(nullptr, session);
911 windowSceneSessionImpl->property_->SetPersistentId(1);
912 windowSceneSessionImpl->hostSession_ = session;
913 AvoidArea avoidArea;
914 auto ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
915 EXPECT_EQ(WMError::WM_OK, ret);
916 windowSceneSessionImpl->hostSession_ = nullptr;
917 ret = windowSceneSessionImpl->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidArea);
918 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
919 }
920
921 /**
922 * @tc.name: IsLayoutFullScreen
923 * @tc.desc: IsLayoutFullScreen
924 * @tc.type: FUNC
925 */
926 HWTEST_F(WindowSceneSessionImplTest3, IsLayoutFullScreen, Function | SmallTest | Level2)
927 {
928 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
929 ASSERT_NE(nullptr, option);
930 option->SetWindowName("IsLayoutFullScreen");
931 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
932 ASSERT_NE(nullptr, windowSceneSessionImpl);
933
934 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
935 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
936 auto ret = windowSceneSessionImpl->IsLayoutFullScreen();
937 EXPECT_EQ(false, ret);
938 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
939 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
940 ret = windowSceneSessionImpl->IsLayoutFullScreen();
941 EXPECT_EQ(false, ret);
942 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
943 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
944 ret = windowSceneSessionImpl->IsLayoutFullScreen();
945 EXPECT_EQ(false, ret);
946 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
947 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_END);
948 ret = windowSceneSessionImpl->IsLayoutFullScreen();
949 EXPECT_EQ(false, ret);
950 }
951
952 /**
953 * @tc.name: MaximizeFloating
954 * @tc.desc: MaximizeFloating
955 * @tc.type: FUNC
956 */
957 HWTEST_F(WindowSceneSessionImplTest3, MaximizeFloating, Function | SmallTest | Level2)
958 {
959 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
960 ASSERT_NE(nullptr, option);
961 option->SetWindowName("MaximizeFloating");
962 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
963 ASSERT_NE(nullptr, windowSceneSessionImpl);
964
965 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
966 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
967 ASSERT_NE(nullptr, session);
968 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
969 windowSceneSessionImpl->property_->SetPersistentId(1);
970 windowSceneSessionImpl->hostSession_ = session;
971 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
972 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
973 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
974 auto ret = windowSceneSessionImpl->MaximizeFloating();
975 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
976 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
977 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
978 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
979 ret = windowSceneSessionImpl->MaximizeFloating();
980 EXPECT_EQ(WMError::WM_OK, ret);
981 auto ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
982 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
983 windowSceneSessionImpl->SetGlobalMaximizeMode(MaximizeMode::MODE_FULL_FILL);
984 ret = windowSceneSessionImpl->MaximizeFloating();
985 EXPECT_EQ(WMError::WM_OK, ret);
986 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
987 windowSceneSessionImpl->property_->SetModeSupportInfo(WINDOW_MODE_SUPPORT_FLOATING);
988 ret = windowSceneSessionImpl->MaximizeFloating();
989 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
990 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
991 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
992 windowSceneSessionImpl->hostSession_ = nullptr;
993 ret1 = windowSceneSessionImpl->GetGlobalMaximizeMode();
994 EXPECT_EQ(MaximizeMode::MODE_RECOVER, ret1);
995 }
996
997 /**
998 * @tc.name: Recover
999 * @tc.desc: Recover
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(WindowSceneSessionImplTest3, Recover, Function | SmallTest | Level2)
1003 {
1004 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1005 ASSERT_NE(nullptr, option);
1006 option->SetWindowName("Recover");
1007 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1008 ASSERT_NE(nullptr, windowSceneSessionImpl);
1009
1010 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1011 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1012 ASSERT_NE(nullptr, session);
1013 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1014 windowSceneSessionImpl->property_->SetPersistentId(1);
1015 windowSceneSessionImpl->hostSession_ = session;
1016 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1017 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1018 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1019 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1020 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1021 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1022 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1023 auto ret = windowSceneSessionImpl->Recover();
1024 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1025 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1026 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
1027 ret = windowSceneSessionImpl->Recover();
1028 EXPECT_EQ(WMError::WM_OK, ret);
1029 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1030 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1031 ret = windowSceneSessionImpl->Recover();
1032 EXPECT_EQ(WMError::WM_OK, ret);
1033 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1034 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1035 ret = windowSceneSessionImpl->Recover();
1036 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1037 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1038 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1039 ret = windowSceneSessionImpl->Recover();
1040 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1041 }
1042
1043 /**
1044 * @tc.name: StartMove
1045 * @tc.desc: StartMove
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(WindowSceneSessionImplTest3, StartMove, Function | SmallTest | Level2)
1049 {
1050 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1051 ASSERT_NE(nullptr, option);
1052 option->SetWindowName("StartMove");
1053 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1054 ASSERT_NE(nullptr, windowSceneSessionImpl);
1055
1056 windowSceneSessionImpl->hostSession_ = nullptr;
1057 windowSceneSessionImpl->StartMove();
1058 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1059 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1060 ASSERT_NE(nullptr, session);
1061 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1062 windowSceneSessionImpl->property_->SetPersistentId(1);
1063 windowSceneSessionImpl->hostSession_ = session;
1064 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1065 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1066 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1067 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1068 windowSceneSessionImpl->StartMove();
1069 }
1070
1071 /**
1072 * @tc.name: DisableAppWindowDecor
1073 * @tc.desc: DisableAppWindowDecor
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(WindowSceneSessionImplTest3, DisableAppWindowDecor, Function | SmallTest | Level2)
1077 {
1078 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1079 ASSERT_NE(nullptr, option);
1080 option->SetWindowName("DisableAppWindowDecor");
1081 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1082 ASSERT_NE(nullptr, windowSceneSessionImpl);
1083
1084 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1085 windowSceneSessionImpl->property_->SetPersistentId(1);
1086 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1087 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1088 ASSERT_NE(nullptr, session);
1089 windowSceneSessionImpl->hostSession_ = session;
1090
1091 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1092 auto ret = windowSceneSessionImpl->DisableAppWindowDecor();
1093 EXPECT_EQ(WMError::WM_OK, ret);
1094 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1095 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1096 ret = windowSceneSessionImpl->DisableAppWindowDecor();
1097 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1098 }
1099
1100 /**
1101 * @tc.name: SetShadowRadius
1102 * @tc.desc: SetShadowRadius
1103 * @tc.type: FUNC
1104 */
1105 HWTEST_F(WindowSceneSessionImplTest3, SetShadowRadius, Function | SmallTest | Level2)
1106 {
1107 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1108 ASSERT_NE(nullptr, option);
1109 option->SetWindowName("SetShadowRadius");
1110 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1111 ASSERT_NE(nullptr, windowSceneSessionImpl);
1112
1113 windowSceneSessionImpl->surfaceNode_ = nullptr;
1114 auto ret = windowSceneSessionImpl->SetShadowRadius(1.0f);
1115 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1116 ret = windowSceneSessionImpl->SetShadowOffsetY(1.0f);
1117 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1118
1119 Transform trans;
1120 windowSceneSessionImpl->hostSession_ = nullptr;
1121 ret = windowSceneSessionImpl->SetTransform(trans);
1122 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1123 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1124 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1125 ASSERT_NE(nullptr, session);
1126 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1127 windowSceneSessionImpl->property_->SetPersistentId(1);
1128 windowSceneSessionImpl->hostSession_ = session;
1129 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1130 ret = windowSceneSessionImpl->SetTransform(trans);
1131 EXPECT_EQ(WMError::WM_OK, ret);
1132 }
1133
1134 /**
1135 * @tc.name: UpdateMaximizeMode
1136 * @tc.desc: UpdateMaximizeMode
1137 * @tc.type: FUNC
1138 */
1139 HWTEST_F(WindowSceneSessionImplTest3, UpdateMaximizeMode, Function | SmallTest | Level2)
1140 {
1141 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1142 ASSERT_NE(nullptr, option);
1143 option->SetWindowName("UpdateMaximizeMode");
1144 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1145 ASSERT_NE(nullptr, windowSceneSessionImpl);
1146
1147 windowSceneSessionImpl->uiContent_ = nullptr;
1148 auto ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1149 EXPECT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
1150 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1151 ASSERT_NE(nullptr, windowSceneSessionImpl->uiContent_);
1152 ret = windowSceneSessionImpl->UpdateMaximizeMode(MaximizeMode::MODE_RECOVER);
1153 EXPECT_EQ(WSError::WS_OK, ret);
1154 }
1155
1156 /**
1157 * @tc.name: GetSystemBarProperties
1158 * @tc.desc: GetSystemBarProperties
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(WindowSceneSessionImplTest3, GetSystemBarProperties, Function | SmallTest | Level2)
1162 {
1163 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1164 ASSERT_NE(nullptr, option);
1165 option->SetWindowName("GetSystemBarProperties");
1166 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1167 ASSERT_NE(nullptr, windowSceneSessionImpl);
1168 std::map<WindowType, SystemBarProperty> properties;
1169
1170 auto ret = windowSceneSessionImpl->GetSystemBarProperties(properties);
1171 EXPECT_EQ(WMError::WM_OK, ret);
1172 }
1173
1174 /**
1175 * @tc.name: Hide
1176 * @tc.desc: Hide
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(WindowSceneSessionImplTest3, Hide, Function | SmallTest | Level2)
1180 {
1181 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1182 ASSERT_NE(nullptr, option);
1183 option->SetWindowName("Hide");
1184 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1185 ASSERT_NE(nullptr, windowSceneSessionImpl);
1186
1187 windowSceneSessionImpl->hostSession_ = nullptr;
1188 auto ret = windowSceneSessionImpl->Hide(2, false, false);
1189 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
1190 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1191 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1192 ASSERT_NE(nullptr, session);
1193 windowSceneSessionImpl->hostSession_ = session;
1194 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1195 windowSceneSessionImpl->property_->SetPersistentId(0);
1196 ret = windowSceneSessionImpl->Hide(2, false, false);
1197 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1198 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1199 windowSceneSessionImpl->property_->SetPersistentId(1);
1200 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1201 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1202 ret = windowSceneSessionImpl->Hide(2, false, false);
1203 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1204 }
1205
1206 /**
1207 * @tc.name: IsSessionMainWindow
1208 * @tc.desc: IsSessionMainWindow
1209 * @tc.type: FUNC
1210 */
1211 HWTEST_F(WindowSceneSessionImplTest3, IsSessionMainWindow, Function | SmallTest | Level2)
1212 {
1213 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1214 ASSERT_NE(nullptr, option);
1215 option->SetWindowName("IsSessionMainWindow");
1216 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1217 ASSERT_NE(nullptr, windowSceneSessionImpl);
1218
1219 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1220 ASSERT_NE(nullptr, windowSession);
1221 ASSERT_NE(nullptr, windowSession->property_);
1222 windowSession->property_->SetPersistentId(1);
1223 ASSERT_NE(nullptr, windowSession->property_);
1224 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1225 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1226 auto ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1227 EXPECT_EQ(true, ret);
1228 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1229 ASSERT_NE(nullptr, windowSession->property_);
1230 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1231 ret = windowSceneSessionImpl->IsSessionMainWindow(1);
1232 EXPECT_EQ(false, ret);
1233 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1234 EXPECT_EQ(false, ret);
1235 windowSession = nullptr;
1236 ret = windowSceneSessionImpl->IsSessionMainWindow(0);
1237 EXPECT_EQ(false, ret);
1238 }
1239
1240 /**
1241 * @tc.name: Show
1242 * @tc.desc: Show
1243 * @tc.type: FUNC
1244 */
1245 HWTEST_F(WindowSceneSessionImplTest3, Show, Function | SmallTest | Level2)
1246 {
1247 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1248 ASSERT_NE(nullptr, option);
1249 option->SetWindowName("Show");
1250 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1251 ASSERT_NE(nullptr, windowSceneSessionImpl);
1252
1253 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1254 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1255 ASSERT_NE(nullptr, session);
1256 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1257 windowSceneSessionImpl->property_->SetPersistentId(1);
1258 windowSceneSessionImpl->hostSession_ = session;
1259 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1260 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1261 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1262 auto ret = windowSceneSessionImpl->Show(2, true);
1263 EXPECT_EQ(WMError::WM_OK, ret);
1264 ret = windowSceneSessionImpl->Maximize();
1265 EXPECT_EQ(WMError::WM_OK, ret);
1266 ret = windowSceneSessionImpl->Minimize();
1267 EXPECT_EQ(WMError::WM_OK, ret);
1268 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1269 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1270 ret = windowSceneSessionImpl->Minimize();
1271 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1272 ret = windowSceneSessionImpl->Maximize();
1273 EXPECT_EQ(WMError::WM_OK, ret);
1274 ret = windowSceneSessionImpl->Minimize();
1275 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
1276 }
1277
1278 /**
1279 * @tc.name: Show02
1280 * @tc.desc: Show withFocus params
1281 * @tc.type: FUNC
1282 */
1283 HWTEST_F(WindowSceneSessionImplTest3, Show02, Function | SmallTest | Level2)
1284 {
1285 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1286 option->SetWindowName("Show02");
1287 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1288
1289 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1290 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1291 windowSceneSessionImpl->property_->SetPersistentId(1);
1292 windowSceneSessionImpl->hostSession_ = session;
1293 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1294 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1295 auto ret = windowSceneSessionImpl->Show(0, false, true);
1296 EXPECT_EQ(WMError::WM_OK, ret);
1297 ret = windowSceneSessionImpl->Show(0, false, false);
1298 EXPECT_EQ(WMError::WM_OK, ret);
1299 }
1300
1301 /**
1302 * @tc.name: NotifySpecificWindowSessionProperty
1303 * @tc.desc: NotifySpecificWindowSessionProperty
1304 * @tc.type: FUNC
1305 */
1306 HWTEST_F(WindowSceneSessionImplTest3, NotifySpecificWindowSessionProperty, Function | SmallTest | Level2)
1307 {
1308 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1309 ASSERT_NE(nullptr, option);
1310 option->SetWindowName("NotifySpecificWindowSessionProperty");
1311 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1312 ASSERT_NE(nullptr, windowSceneSessionImpl);
1313
1314 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1315 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1316 ASSERT_NE(nullptr, session);
1317 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1318 windowSceneSessionImpl->property_->SetPersistentId(1);
1319 windowSceneSessionImpl->hostSession_ = session;
1320 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1321 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
1322 SystemBarProperty property;
1323 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1324 auto ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1325 EXPECT_EQ(WMError::WM_OK, ret);
1326 ret = windowSceneSessionImpl->SetWindowFlags(0);
1327 EXPECT_EQ(WMError::WM_OK, ret);
1328 type = WindowType::WINDOW_TYPE_NAVIGATION_BAR;
1329 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1330 EXPECT_EQ(WMError::WM_OK, ret);
1331 type = WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR;
1332 ret = windowSceneSessionImpl->NotifySpecificWindowSessionProperty(type, property);
1333 EXPECT_EQ(WMError::WM_OK, ret);
1334 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1335 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1336 ret = windowSceneSessionImpl->SetSpecificBarProperty(type, property);
1337 EXPECT_EQ(WMError::WM_OK, ret);
1338 windowSceneSessionImpl->hostSession_ = nullptr;
1339 ret = windowSceneSessionImpl->SetWindowFlags(0);
1340 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1341 }
1342
1343 /**
1344 * @tc.name: Close
1345 * @tc.desc: Close
1346 * @tc.type: FUNC
1347 */
1348 HWTEST_F(WindowSceneSessionImplTest3, Close, Function | SmallTest | Level2)
1349 {
1350 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1351 ASSERT_NE(nullptr, option);
1352 option->SetWindowName("Close");
1353 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1354 ASSERT_NE(nullptr, windowSceneSessionImpl);
1355
1356 windowSceneSessionImpl->hostSession_ = nullptr;
1357 auto ret = windowSceneSessionImpl->Close();
1358 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1359 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1360 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1361 ASSERT_NE(nullptr, session);
1362 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1363 windowSceneSessionImpl->property_->SetPersistentId(1);
1364 windowSceneSessionImpl->hostSession_ = session;
1365 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1366 ASSERT_NE(nullptr, abilityContext_);
1367 windowSceneSessionImpl->context_ = abilityContext_;
1368 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1369 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1370 ret = windowSceneSessionImpl->Close();
1371 EXPECT_EQ(WMError::WM_OK, ret);
1372 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1373 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1374 ret = windowSceneSessionImpl->Close();
1375 EXPECT_EQ(WMError::WM_OK, ret);
1376 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1377 windowSceneSessionImpl->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1378 ret = windowSceneSessionImpl->Close();
1379 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1380 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1381 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1382 ret = windowSceneSessionImpl->Close();
1383 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1384 }
1385
1386 /**
1387 * @tc.name: GetWindowWithId
1388 * @tc.desc: GetWindowWithId
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(WindowSceneSessionImplTest3, GetWindowWithId, Function | SmallTest | Level2)
1392 {
1393 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1394 ASSERT_NE(nullptr, option);
1395 option->SetWindowName("GetWindowWithId");
1396 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1397 ASSERT_NE(nullptr, windowSceneSessionImpl);
1398
1399 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1400 ASSERT_NE(nullptr, windowSession);
1401 ASSERT_NE(nullptr, windowSession->property_);
1402 windowSession->property_->SetPersistentId(1);
1403 ASSERT_NE(nullptr, windowSession->property_);
1404 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1405 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1406 auto ret = windowSceneSessionImpl->GetWindowWithId(1);
1407 EXPECT_FALSE(ret == nullptr);
1408 ret = windowSceneSessionImpl->GetWindowWithId(0);
1409 EXPECT_FALSE(ret == nullptr);
1410 windowSession = nullptr;
1411 ret = windowSceneSessionImpl->GetWindowWithId(0);
1412 EXPECT_FALSE(ret == nullptr);
1413 }
1414
1415 /**
1416 * @tc.name: PreNotifyKeyEvent
1417 * @tc.desc: PreNotifyKeyEvent
1418 * @tc.type: FUNC
1419 */
1420 HWTEST_F(WindowSceneSessionImplTest3, PreNotifyKeyEvent, Function | SmallTest | Level2)
1421 {
1422 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1423 ASSERT_NE(nullptr, option);
1424 option->SetWindowName("PreNotifyKeyEvent");
1425 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1426 ASSERT_NE(nullptr, windowSceneSessionImpl);
1427
1428 std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
1429 windowSceneSessionImpl->uiContent_ = nullptr;
1430 auto ret = windowSceneSessionImpl->PreNotifyKeyEvent(keyEvent);
1431 EXPECT_EQ(false, ret);
1432 windowSceneSessionImpl->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1433 ASSERT_NE(nullptr, windowSceneSessionImpl->uiContent_);
1434 EXPECT_EQ(false, ret);
1435 }
1436
1437 /**
1438 * @tc.name: Recover01
1439 * @tc.desc: Recover
1440 * @tc.type: FUNC
1441 */
1442 HWTEST_F(WindowSceneSessionImplTest3, Recover01, Function | SmallTest | Level2)
1443 {
1444 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1445 ASSERT_NE(nullptr, option);
1446 option->SetWindowName("Recover");
1447 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1448 ASSERT_NE(nullptr, windowSceneSessionImpl);
1449
1450 windowSceneSessionImpl->hostSession_ = nullptr;
1451 auto ret = windowSceneSessionImpl->Recover(1);
1452 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1453 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1454 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1455 ASSERT_NE(nullptr, session);
1456 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1457 windowSceneSessionImpl->property_->SetPersistentId(1);
1458 windowSceneSessionImpl->hostSession_ = session;
1459 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1460 windowSceneSessionImpl->windowSystemConfig_.uiType_ = "phone";
1461 ret = windowSceneSessionImpl->Recover(1);
1462 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1463 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowEnable_ = true;
1464 ret = windowSceneSessionImpl->Recover(1);
1465 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
1466 windowSceneSessionImpl->windowSystemConfig_.freeMultiWindowSupport_ = true;
1467 windowSceneSessionImpl->windowSystemConfig_.uiType_ = "pc";
1468 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1469 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1470 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1471 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
1472 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1473 windowSceneSessionImpl->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1474 ret = windowSceneSessionImpl->Recover(1);
1475 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1476 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1477 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
1478 ret = windowSceneSessionImpl->Recover(1);
1479 EXPECT_EQ(WMError::WM_OK, ret);
1480 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1481 windowSceneSessionImpl->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
1482 ret = windowSceneSessionImpl->Recover(1);
1483 EXPECT_EQ(WMError::WM_OK, ret);
1484 ret = windowSceneSessionImpl->Recover(0);
1485 EXPECT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, ret);
1486 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
1487 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1488 ret = windowSceneSessionImpl->Recover(0);
1489 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, ret);
1490 }
1491
1492 /**
1493 * @tc.name: FindParentSessionByParentId
1494 * @tc.desc: FindParentSessionByParentId
1495 * @tc.type: FUNC
1496 */
1497 HWTEST_F(WindowSceneSessionImplTest3, FindParentSessionByParentId, Function | SmallTest | Level2)
1498 {
1499 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1500 ASSERT_NE(nullptr, option);
1501 option->SetWindowName("FindParentSessionByParentId");
1502 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1503 ASSERT_NE(nullptr, windowSceneSessionImpl);
1504
1505 sptr<WindowSessionImpl> windowSession = sptr<WindowSessionImpl>::MakeSptr(option);
1506 ASSERT_NE(nullptr, windowSession);
1507 ASSERT_NE(nullptr, windowSession->property_);
1508 windowSession->property_->SetPersistentId(1);
1509
1510 ASSERT_NE(nullptr, windowSession->property_);
1511 windowSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1512 windowSceneSessionImpl->windowSessionMap_.insert(std::make_pair("window1", std::make_pair(1, windowSession)));
1513 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1514 ASSERT_NE(nullptr, windowSession->property_);
1515 windowSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1516 ASSERT_NE(nullptr, windowSession->property_);
1517 windowSession->property_->SetParentPersistentId(1);
1518 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1519 ASSERT_NE(nullptr, windowSession->property_);
1520 windowSession->property_->SetParentPersistentId(0);
1521 ASSERT_NE(nullptr, windowSession->property_);
1522 windowSession->property_->SetExtensionFlag(true);
1523 EXPECT_FALSE(nullptr != windowSceneSessionImpl->FindParentSessionByParentId(1));
1524 }
1525
1526 /**
1527 * @tc.name: PreLayoutOnShow
1528 * @tc.desc: PreLayoutOnShow
1529 * @tc.type: FUNC
1530 */
1531 HWTEST_F(WindowSceneSessionImplTest3, PreLayoutOnShow, Function | SmallTest | Level2)
1532 {
1533 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1534 ASSERT_NE(nullptr, option);
1535 option->SetWindowName("PreLayoutOnShow");
1536 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1537 ASSERT_NE(nullptr, window);
1538 ASSERT_NE(nullptr, window->property_);
1539 window->property_->SetPersistentId(1);
1540
1541 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1542 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1543 ASSERT_NE(nullptr, session);
1544
1545 window->hostSession_ = session;
1546 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1547 ASSERT_NE(nullptr, window->uiContent_);
1548 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1549
1550 Rect request = { 100, 100, 100, 100 };
1551 window->property_->SetRequestRect(request);
1552 window->PreLayoutOnShow(window->property_->GetWindowType());
1553 request = { 100, 100, 0, 100 };
1554 window->property_->SetRequestRect(request);
1555 window->PreLayoutOnShow(window->property_->GetWindowType());
1556 request = { 100, 100, 100, 0 };
1557 window->property_->SetRequestRect(request);
1558 window->PreLayoutOnShow(window->property_->GetWindowType());
1559 }
1560 }
1561 } // namespace Rosen
1562 } // namespace OHOS