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