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 "display_info.h"
19 #include "ability_context_impl.h"
20 #include "mock_session.h"
21 #include "window_session_impl.h"
22 #include "wm_common.h"
23 #include "mock_uicontent.h"
24 #include "window_scene_session_impl.h"
25 #include "mock_window_adapter.h"
26 #include "singleton_mocker.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
34 uint32_t MaxWith = 32;
35
36 class WindowSceneSessionImplTest2 : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42
43 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
44 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
45
46 private:
47 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
48 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
49 };
50
SetUpTestCase()51 void WindowSceneSessionImplTest2::SetUpTestCase() {}
52
TearDownTestCase()53 void WindowSceneSessionImplTest2::TearDownTestCase() {}
54
SetUp()55 void WindowSceneSessionImplTest2::SetUp()
56 {
57 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
58 }
59
TearDown()60 void WindowSceneSessionImplTest2::TearDown()
61 {
62 usleep(WAIT_SYNC_IN_NS);
63 abilityContext_ = nullptr;
64 }
65
CreateRSSurfaceNode()66 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest2::CreateRSSurfaceNode()
67 {
68 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
69 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
70 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
71 return surfaceNode;
72 }
73
74 namespace {
75 /*
76 * @tc.name: SetBackdropBlur
77 * @tc.desc: SetBackdropBlur test
78 * @tc.type: FUNC
79 */
HWTEST_F(WindowSceneSessionImplTest2, SetBackdropBlur, Function | SmallTest | Level3)80 HWTEST_F(WindowSceneSessionImplTest2, SetBackdropBlur, Function | SmallTest | Level3)
81 {
82 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
83 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
84 window->property_->SetWindowName("SetBackdropBlur");
85 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
86
87 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlur(-1.0));
88 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(1.0));
89 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(0.0));
90 window->surfaceNode_ = nullptr;
91 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlur(1.0));
92 }
93
94 /*
95 * @tc.name: SetShadowColor
96 * @tc.desc: SetShadowColor test
97 * @tc.type: FUNC
98 */
HWTEST_F(WindowSceneSessionImplTest2, SetShadowColor, Function | SmallTest | Level3)99 HWTEST_F(WindowSceneSessionImplTest2, SetShadowColor, Function | SmallTest | Level3)
100 {
101 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
102 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
103 window->property_->SetWindowName("SetShadowColor");
104 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
105
106 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowColor("111ff22ee44"));
107 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#ff22ee44"));
108 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#000999"));
109 window->surfaceNode_ = nullptr;
110 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowColor("#ff22ee44"));
111 }
112
113 /*
114 * @tc.name: SetCornerRadius
115 * @tc.desc: SetCornerRadius test
116 * @tc.type: FUNC
117 */
HWTEST_F(WindowSceneSessionImplTest2, SetCornerRadius, Function | SmallTest | Level3)118 HWTEST_F(WindowSceneSessionImplTest2, SetCornerRadius, Function | SmallTest | Level3)
119 {
120 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
121 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
122 window->property_->SetWindowName("SetCornerRadius");
123 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
124
125 ASSERT_EQ(WMError::WM_OK, window->SetCornerRadius(1.0));
126 window->surfaceNode_ = nullptr;
127 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetCornerRadius(1.0));
128 }
129
130 /*
131 * @tc.name: SetShadowRadius
132 * @tc.desc: SetShadowRadius test
133 * @tc.type: FUNC
134 */
HWTEST_F(WindowSceneSessionImplTest2, SetShadowRadius, Function | SmallTest | Level3)135 HWTEST_F(WindowSceneSessionImplTest2, SetShadowRadius, Function | SmallTest | Level3)
136 {
137 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
138 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
139 window->property_->SetWindowName("SetShadowRadius");
140 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
141
142 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowRadius(-1.0));
143 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(0.0));
144 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(1.0));
145 window->surfaceNode_ = nullptr;
146 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowRadius(1.0));
147 }
148
149 /**
150 * @tc.name: SetTransform01
151 * @tc.desc: set transform
152 * @tc.type: FUNC
153 * @tc.require:issueI7IJVV
154 */
HWTEST_F(WindowSceneSessionImplTest2, SetTransform01, Function | SmallTest | Level3)155 HWTEST_F(WindowSceneSessionImplTest2, SetTransform01, Function | SmallTest | Level3)
156 {
157 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
158 sptr<WindowOption> option = new WindowOption();
159 option->SetWindowName("SetTransform01");
160 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
161 ASSERT_NE(nullptr, window);
162 window->property_->SetPersistentId(1);
163 Transform trans_;
164 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransform(trans_));
165
166 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
167 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
168 ASSERT_NE(nullptr, session);
169
170 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
171 window->hostSession_ = session;
172 ASSERT_EQ(WMError::WM_OK, window->SetTransform(trans_));
173 }
174
175 /**
176 * @tc.name: RegisterAnimationTransitionController01
177 * @tc.desc: RegisterAnimationTransitionController
178 * @tc.type: FUNC
179 * @tc.require:issueI7IJVV
180 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterAnimationTransitionController01, Function | SmallTest | Level3)181 HWTEST_F(WindowSceneSessionImplTest2, RegisterAnimationTransitionController01, Function | SmallTest | Level3)
182 {
183 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
184 sptr<WindowOption> option = new WindowOption();
185 option->SetWindowName("RegisterAnimationTransitionController01");
186 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
187 ASSERT_NE(nullptr, window);
188 window->property_->SetPersistentId(1);
189 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->RegisterAnimationTransitionController(nullptr));
190 }
191
192 /**
193 * @tc.name: SetNeedDefaultAnimation01
194 * @tc.desc: SetNeedDefaultAnimation
195 * @tc.type: FUNC
196 * @tc.require:issueI7IJVV
197 */
HWTEST_F(WindowSceneSessionImplTest2, SetNeedDefaultAnimation01, Function | SmallTest | Level3)198 HWTEST_F(WindowSceneSessionImplTest2, SetNeedDefaultAnimation01, Function | SmallTest | Level3)
199 {
200 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
201 sptr<WindowOption> option = new WindowOption();
202 option->SetWindowName("SetNeedDefaultAnimation01");
203 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
204 ASSERT_NE(nullptr, window);
205 auto ret = true;
206 window->property_->SetPersistentId(1);
207
208 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
209 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
210 ASSERT_NE(nullptr, session);
211 window->hostSession_ = session;
212 window->SetNeedDefaultAnimation(false);
213 ASSERT_TRUE(ret);
214 }
215
216 /**
217 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation01
218 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation
219 * @tc.type: FUNC
220 * @tc.require:issueI7IJVV
221 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)222 HWTEST_F(WindowSceneSessionImplTest2, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)
223 {
224 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
225 sptr<WindowOption> option = new WindowOption();
226 option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
227 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
228 ASSERT_NE(nullptr, window);
229
230 window->property_->SetPersistentId(1);
231
232 window->UpdateSurfaceNodeAfterCustomAnimation(false);
233 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->UpdateSurfaceNodeAfterCustomAnimation(false));
234 window->property_->SetPersistentId(1);
235 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
236 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
237 ASSERT_NE(nullptr, session);
238 window->hostSession_ = session;
239 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
240 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->UpdateSurfaceNodeAfterCustomAnimation(false));
241 }
242
243 /**
244 * @tc.name: SetAlpha01
245 * @tc.desc: SetAlpha
246 * @tc.type: FUNC
247 */
HWTEST_F(WindowSceneSessionImplTest2, SetAlpha01, Function | SmallTest | Level2)248 HWTEST_F(WindowSceneSessionImplTest2, SetAlpha01, Function | SmallTest | Level2)
249 {
250 sptr<WindowOption> option = new (std::nothrow) WindowOption();
251 option->SetWindowName("SetAlpha01");
252 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
253
254 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
255
256 ASSERT_NE(nullptr, windowSceneSession);
257 windowSceneSession->property_->SetPersistentId(11);
258 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
259
260 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->SetAlpha(1.0));
261 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
262 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
263 ASSERT_NE(nullptr, session);
264
265 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
266 windowSceneSession->hostSession_ = session;
267
268 ASSERT_EQ(WMError::WM_OK, windowSceneSession->SetAlpha(0.0));
269 ASSERT_EQ(WMError::WM_OK, windowSceneSession->SetAlpha(1.0));
270 }
271
272 /**
273 * @tc.name: DestroySubWindow01
274 * @tc.desc: DestroySubWindow
275 * @tc.type: FUNC
276 */
HWTEST_F(WindowSceneSessionImplTest2, DestroySubWindow01, Function | SmallTest | Level2)277 HWTEST_F(WindowSceneSessionImplTest2, DestroySubWindow01, Function | SmallTest | Level2)
278 {
279 sptr<WindowOption> option = new (std::nothrow) WindowOption();
280 option->SetWindowName("DestroySubWindow01");
281 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
282
283 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
284
285 ASSERT_NE(nullptr, windowSceneSession);
286
287 windowSceneSession->DestroySubWindow();
288 ASSERT_EQ(INVALID_SESSION_ID, windowSceneSession->property_->GetParentPersistentId());
289 }
290
291 /**
292 * @tc.name: UpdateFloatingWindowSizeBySizeLimits01
293 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
294 * @tc.type: FUNC
295 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateFloatingWindowSizeBySizeLimits01, Function | SmallTest | Level2)296 HWTEST_F(WindowSceneSessionImplTest2, UpdateFloatingWindowSizeBySizeLimits01, Function | SmallTest | Level2)
297 {
298 sptr<WindowOption> option = new (std::nothrow) WindowOption();
299 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits01");
300 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
301
302 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
303 ASSERT_NE(nullptr, windowSceneSession);
304 int ret = 0;
305 windowSceneSession->UpdateFloatingWindowSizeBySizeLimits(MaxWith, MaxWith);
306 ASSERT_EQ(0, ret);
307 }
308
309 /**
310 * @tc.name: UpdateAnimationFlagProperty01
311 * @tc.desc: UpdateAnimationFlagProperty
312 * @tc.type: FUNC
313 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateAnimationFlagProperty01, Function | SmallTest | Level2)314 HWTEST_F(WindowSceneSessionImplTest2, UpdateAnimationFlagProperty01, Function | SmallTest | Level2)
315 {
316 sptr<WindowOption> option = new (std::nothrow) WindowOption();
317 option->SetWindowName("UpdateAnimationFlagProperty01");
318 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
319
320 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
321 ASSERT_NE(nullptr, windowSceneSession);
322 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->UpdateAnimationFlagProperty(false));
323 }
324
325 /**
326 * @tc.name: UpdateWindowModeImmediately01
327 * @tc.desc: UpdateWindowModeImmediately
328 * @tc.type: FUNC
329 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowModeImmediately01, Function | SmallTest | Level2)330 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowModeImmediately01, Function | SmallTest | Level2)
331 {
332 sptr<WindowOption> option = new (std::nothrow) WindowOption();
333 option->SetWindowName("UpdateWindowModeImmediately01");
334 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
335
336 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
337 ASSERT_NE(nullptr, windowSceneSession);
338 ASSERT_EQ(WMError::WM_OK, windowSceneSession->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_UNDEFINED));
339 windowSceneSession->state_ = WindowState::STATE_CREATED;
340 ASSERT_EQ(WMError::WM_OK, windowSceneSession->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_UNDEFINED));
341 }
342
343 /**
344 * @tc.name: UpdateWindowMode01
345 * @tc.desc: UpdateWindowMode
346 * @tc.type: FUNC
347 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode01, Function | SmallTest | Level2)348 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode01, Function | SmallTest | Level2)
349 {
350 sptr<WindowOption> option = new (std::nothrow) WindowOption();
351 option->SetWindowName("UpdateWindowMode01");
352 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
353
354 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
355 ASSERT_NE(nullptr, windowSceneSession);
356 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
357 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
358 windowSceneSession->state_ = WindowState::STATE_CREATED;
359 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
360 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
361
362 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
363 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
364 ASSERT_NE(nullptr, session);
365 windowSceneSession->hostSession_ = session;
366 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
367 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
368 }
369
370 /**
371 * @tc.name: UpdateWindowMode02
372 * @tc.desc: UpdateWindowMode
373 * @tc.type: FUNC
374 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode02, Function | SmallTest | Level2)375 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode02, Function | SmallTest | Level2)
376 {
377 sptr<WindowOption> option = new (std::nothrow) WindowOption();
378 option->SetWindowName("UpdateWindowMode02");
379 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
380
381 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
382 ASSERT_NE(nullptr, windowSceneSession);
383 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
384 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
385 windowSceneSession->state_ = WindowState::STATE_CREATED;
386 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
387 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
388
389 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
390 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
391 ASSERT_NE(nullptr, session);
392 windowSceneSession->hostSession_ = session;
393 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
394 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
395 windowSceneSession->property_->SetPersistentId(1);
396 ASSERT_EQ(WSError::WS_OK,
397 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
398 }
399
400 /**
401 * @tc.name: RemoveWindowFlag01
402 * @tc.desc: RemoveWindowFlag
403 * @tc.type: FUNC
404 */
HWTEST_F(WindowSceneSessionImplTest2, RemoveWindowFlag01, Function | SmallTest | Level2)405 HWTEST_F(WindowSceneSessionImplTest2, RemoveWindowFlag01, Function | SmallTest | Level2)
406 {
407 sptr<WindowOption> option = new (std::nothrow) WindowOption();
408 option->SetWindowName("RemoveWindowFlag01");
409 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
410
411 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
412 ASSERT_NE(nullptr, windowSceneSession);
413 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
414 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
415 windowSceneSession->state_ = WindowState::STATE_CREATED;
416 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
417 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
418
419 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
420 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
421 ASSERT_NE(nullptr, session);
422 windowSceneSession->hostSession_ = session;
423 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
424 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
425 }
426
427 /**
428 * @tc.name: GetConfigurationFromAbilityInfo01
429 * @tc.desc: GetConfigurationFromAbilityInfo
430 * @tc.type: FUNC
431 */
HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo01, Function | SmallTest | Level2)432 HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo01, Function | SmallTest | Level2)
433 {
434 sptr<WindowOption> option = new (std::nothrow) WindowOption();
435 option->SetWindowName("GetConfigurationFromAbilityInfo01");
436 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
437 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
438 ASSERT_NE(nullptr, windowSceneSession);
439 int ret = 0;
440 windowSceneSession->GetConfigurationFromAbilityInfo();
441 ASSERT_EQ(ret, 0);
442 }
443
444 /**
445 * @tc.name: PreProcessCreate01
446 * @tc.desc: PreProcessCreate
447 * @tc.type: FUNC
448 */
HWTEST_F(WindowSceneSessionImplTest2, PreProcessCreate01, Function | SmallTest | Level2)449 HWTEST_F(WindowSceneSessionImplTest2, PreProcessCreate01, Function | SmallTest | Level2)
450 {
451 sptr<WindowOption> option = new (std::nothrow) WindowOption();
452 option->SetWindowName("PreProcessCreate01");
453 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
454 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
455 ASSERT_NE(nullptr, windowSceneSession);
456 int ret = 0;
457 windowSceneSession->PreProcessCreate();
458 ASSERT_EQ(ret, 0);
459 }
460
461 /**
462 * @tc.name: SetDefaultProperty01
463 * @tc.desc: SetDefaultProperty
464 * @tc.type: FUNC
465 */
HWTEST_F(WindowSceneSessionImplTest2, SetDefaultProperty01, Function | SmallTest | Level2)466 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultProperty01, Function | SmallTest | Level2)
467 {
468 sptr<WindowOption> option = new (std::nothrow) WindowOption();
469 option->SetWindowName("SetDefaultProperty01");
470 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
471 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
472 ASSERT_NE(nullptr, windowSceneSession);
473 int ret = 0;
474 windowSceneSession->SetDefaultProperty();
475 ASSERT_EQ(ret, 0);
476 }
477
478 /**
479 * @tc.name: UpdateConfiguration01
480 * @tc.desc: UpdateConfiguration
481 * @tc.type: FUNC
482 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateConfiguration01, Function | SmallTest | Level2)483 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfiguration01, Function | SmallTest | Level2)
484 {
485 sptr<WindowOption> option = new (std::nothrow) WindowOption();
486 option->SetWindowName("UpdateConfiguration01");
487 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
488 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
489 ASSERT_NE(nullptr, windowSceneSession);
490 int ret = 0;
491 std::shared_ptr<AppExecFwk::Configuration> configuration;
492 windowSceneSession->UpdateConfiguration(configuration);
493 windowSceneSession->uiContent_ = std::make_unique<Ace::UIContentMocker>();
494 windowSceneSession->UpdateConfiguration(configuration);
495 ASSERT_EQ(ret, 0);
496 }
497
498
499 /**
500 * @tc.name: UpdateConfigurationForAll01
501 * @tc.desc: UpdateConfigurationForAll
502 * @tc.type: FUNC
503 */
HWTEST_F(WindowSceneSessionImplTest2, UpdateConfigurationForAll01, Function | SmallTest | Level2)504 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfigurationForAll01, Function | SmallTest | Level2)
505 {
506 sptr<WindowOption> option = new (std::nothrow) WindowOption();
507 option->SetWindowName("UpdateConfigurationForAll01");
508 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
509 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
510 ASSERT_NE(nullptr, windowSceneSession);
511 int ret = 0;
512 std::shared_ptr<AppExecFwk::Configuration> configuration;
513 windowSceneSession->UpdateConfigurationForAll(configuration);
514 ASSERT_EQ(ret, 0);
515 }
516
517 /**
518 * @tc.name: GetTopWindowWithContext01
519 * @tc.desc: GetTopWindowWithContext
520 * @tc.type: FUNC
521 */
HWTEST_F(WindowSceneSessionImplTest2, GetTopWindowWithContext01, Function | SmallTest | Level2)522 HWTEST_F(WindowSceneSessionImplTest2, GetTopWindowWithContext01, Function | SmallTest | Level2)
523 {
524 sptr<WindowOption> option = new (std::nothrow) WindowOption();
525 option->SetWindowName("GetTopWindowWithContext01");
526 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
527 std::shared_ptr<AbilityRuntime::Context> context;
528 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
529 ASSERT_NE(nullptr, windowSceneSession);
530 if (windowSceneSession->GetTopWindowWithContext(context) == nullptr) {
531 ASSERT_EQ(nullptr, windowSceneSession->GetTopWindowWithContext(context));
532 }
533 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
534 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
535 ASSERT_NE(nullptr, session);
536 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
537 windowSceneSession->GetTopWindowWithContext(context);
538 windowSceneSession->Destroy(true);
539 }
540
541 /**
542 * @tc.name: GetMainWindowWithContext01
543 * @tc.desc: GetMainWindowWithContext
544 * @tc.type: FUNC
545 */
HWTEST_F(WindowSceneSessionImplTest2, GetMainWindowWithContext01, Function | SmallTest | Level2)546 HWTEST_F(WindowSceneSessionImplTest2, GetMainWindowWithContext01, Function | SmallTest | Level2)
547 {
548 sptr<WindowOption> option = new (std::nothrow) WindowOption();
549 option->SetWindowName("GetMainWindowWithContext01");
550 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
551 std::shared_ptr<AbilityRuntime::Context> context;
552 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
553 ASSERT_NE(nullptr, windowSceneSession);
554 if (windowSceneSession->GetMainWindowWithContext(context) == nullptr) {
555 ASSERT_EQ(nullptr, windowSceneSession->GetMainWindowWithContext(context));
556 }
557 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
558 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
559 ASSERT_NE(nullptr, session);
560 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
561 windowSceneSession->GetMainWindowWithContext(context);
562 windowSceneSession->Destroy(true);
563 }
564
565 /**
566 * @tc.name: NotifyMemoryLevel01
567 * @tc.desc: NotifyMemoryLevel
568 * @tc.type: FUNC
569 */
HWTEST_F(WindowSceneSessionImplTest2, NotifyMemoryLevel01, Function | SmallTest | Level2)570 HWTEST_F(WindowSceneSessionImplTest2, NotifyMemoryLevel01, Function | SmallTest | Level2)
571 {
572 sptr<WindowOption> option = new (std::nothrow) WindowOption();
573 option->SetWindowName("NotifyMemoryLevel01");
574 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
575 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
576 ASSERT_NE(nullptr, windowSceneSession);
577 std::shared_ptr<AppExecFwk::Configuration> configuration;
578 windowSceneSession->NotifyMemoryLevel(2);
579 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->NotifyMemoryLevel(2));
580 windowSceneSession->uiContent_ = std::make_unique<Ace::UIContentMocker>();
581 ASSERT_EQ(WMError::WM_OK, windowSceneSession->NotifyMemoryLevel(2));
582 }
583
584 /**
585 * @tc.name: GetSystemSizeLimits01
586 * @tc.desc: GetSystemSizeLimits
587 * @tc.type: FUNC
588 */
HWTEST_F(WindowSceneSessionImplTest2, GetSystemSizeLimits01, Function | SmallTest | Level2)589 HWTEST_F(WindowSceneSessionImplTest2, GetSystemSizeLimits01, Function | SmallTest | Level2)
590 {
591 constexpr uint32_t minMainWidth = 10;
592 constexpr uint32_t minMainHeight = 20;
593 constexpr uint32_t minSubWidth = 30;
594 constexpr uint32_t minSubHeight = 40;
595 constexpr uint32_t displayWidth = 100;
596 constexpr uint32_t displayHeight = 100;
597 constexpr float displayVpr = 1;
598
599 sptr<WindowOption> option = new (std::nothrow) WindowOption();
600 option->SetWindowName("GetSystemSizeLimits01");
601 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
602
603 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
604
605 ASSERT_NE(nullptr, windowSceneSession);
606 windowSceneSession->windowSystemConfig_.miniWidthOfMainWindow_ = minMainWidth;
607 windowSceneSession->windowSystemConfig_.miniHeightOfMainWindow_ = minMainHeight;
608 windowSceneSession->windowSystemConfig_.miniWidthOfSubWindow_ = minSubWidth;
609 windowSceneSession->windowSystemConfig_.miniHeightOfSubWindow_ = minSubHeight;
610
611 WindowLimits limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
612 ASSERT_EQ(limits.minWidth_, minMainWidth);
613 ASSERT_EQ(limits.minHeight_, minMainHeight);
614
615 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
616 limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
617 ASSERT_EQ(limits.minWidth_, minMainWidth);
618 ASSERT_EQ(limits.minHeight_, minMainHeight);
619
620 windowSceneSession->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
621 limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
622 ASSERT_EQ(limits.minWidth_, minMainWidth);
623 ASSERT_EQ(limits.minHeight_, minMainHeight);
624 }
625
626 /**
627 * @tc.name: DumpSessionElementInfo
628 * @tc.desc: DumpSessionElementInfo 1: params num
629 * @tc.type: FUNC
630 */
HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo1, Function | SmallTest | Level2)631 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo1, Function | SmallTest | Level2)
632 {
633 sptr<WindowOption> option = new (std::nothrow) WindowOption();
634 option->SetWindowName("DumpSessionElementInfo1");
635 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
636 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
637 ASSERT_NE(nullptr, window);
638 std::vector<std::string> params;
639 params.push_back("-h");
640 window->DumpSessionElementInfo(params);
641 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
642 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
643 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
644 }
645
646 /**
647 * @tc.name: DumpSessionElementInfo
648 * @tc.desc: DumpSessionElementInfo2
649 * @tc.type: FUNC
650 */
HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo2, Function | SmallTest | Level2)651 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo2, Function | SmallTest | Level2)
652 {
653 sptr<WindowOption> option = new (std::nothrow) WindowOption();
654 option->SetWindowName("DumpSessionElementInfo2");
655 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
656 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
657 ASSERT_NE(nullptr, window);
658 std::vector<std::string> params;
659 params.push_back("-h");
660 window->DumpSessionElementInfo(params);
661 params.push_back("-s");
662 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
663 window->DumpSessionElementInfo(params);
664 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
665 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
666 }
667
668 /**
669 * @tc.name: DumpSessionElementInfo
670 * @tc.desc: DumpSessionElementInfo3
671 * @tc.type: FUNC
672 */
HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo3, Function | SmallTest | Level2)673 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo3, Function | SmallTest | Level2)
674 {
675 sptr<WindowOption> option = new (std::nothrow) WindowOption();
676 option->SetWindowName("DumpSessionElementInfo3");
677 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
678 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
679 ASSERT_NE(nullptr, window);
680 std::vector<std::string> params;
681 params.push_back("-s");
682 window->DumpSessionElementInfo(params);
683 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
684 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
685 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
686 }
687
688 /**
689 * @tc.name: DisableAppWindowDecor02
690 * @tc.desc: DisableAppWindowDecor
691 * @tc.type: FUNC
692 */
HWTEST_F(WindowSceneSessionImplTest2, DisableAppWindowDecor02, Function | SmallTest | Level2)693 HWTEST_F(WindowSceneSessionImplTest2, DisableAppWindowDecor02, Function | SmallTest | Level2)
694 {
695 sptr<WindowOption> option = new (std::nothrow) WindowOption();
696 option->SetWindowName("DisableAppWindowDecor02");
697 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
698 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
699 ASSERT_NE(nullptr, windowSceneSession);
700 int ret = 0;
701 windowSceneSession->DisableAppWindowDecor();
702 ASSERT_EQ(ret, 0);
703 }
704
705 /**
706 * @tc.name: RaiseAboveTarget01
707 * @tc.desc: RaiseAboveTarget
708 * @tc.type: FUNC
709 */
HWTEST_F(WindowSceneSessionImplTest2, RaiseAboveTarget01, Function | SmallTest | Level2)710 HWTEST_F(WindowSceneSessionImplTest2, RaiseAboveTarget01, Function | SmallTest | Level2)
711 {
712 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
713 ASSERT_NE(nullptr, option);
714 option->SetWindowName("RaiseAboveTarget01");
715 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
716 ASSERT_NE(nullptr, windowSceneSessionImpl);
717
718 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
719 windowSceneSessionImpl->property_->SetPersistentId(6);
720 ASSERT_NE(nullptr, windowSceneSessionImpl->property_);
721 windowSceneSessionImpl->property_->SetParentPersistentId(0);
722 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
723 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
724 windowSceneSessionImpl->hostSession_ = session;
725 auto ret = windowSceneSessionImpl->RaiseAboveTarget(1);
726 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, ret);
727
728 windowSceneSessionImpl->property_->SetParentPersistentId(1);
729 ret = windowSceneSessionImpl->RaiseAboveTarget(1);
730 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
731
732 sptr<WindowSessionImpl> winSession = sptr<WindowSessionImpl>::MakeSptr(option);
733 WindowSessionImpl::subWindowSessionMap_.insert(
734 std::make_pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1, {winSession}));
735 winSession->property_->SetPersistentId(6);
736 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
737 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
738 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
739
740 winSession->state_ = WindowState::STATE_CREATED;
741 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
742 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
743 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
744
745 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
746 winSession->state_ = WindowState::STATE_SHOWN;
747 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
748 EXPECT_EQ(WMError::WM_OK, ret);
749
750 windowSceneSessionImpl->property_->SetPersistentId(3);
751 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
752 EXPECT_EQ(WMError::WM_OK, ret);
753
754 WindowSessionImpl::subWindowSessionMap_.erase(1);
755 }
756
757 /**
758 * @tc.name: FindParentSessionByParentId02
759 * @tc.desc: FindParentSessionByParentId
760 * @tc.type: FUNC
761 */
HWTEST_F(WindowSceneSessionImplTest2, FindParentSessionByParentId02, Function | SmallTest | Level2)762 HWTEST_F(WindowSceneSessionImplTest2, FindParentSessionByParentId02, Function | SmallTest | Level2)
763 {
764 sptr<WindowOption> option = new (std::nothrow) WindowOption();
765 option->SetWindowTag(WindowTag::MAIN_WINDOW);
766 option->SetWindowName("FindParentSessionByParentId02");
767 sptr<WindowSceneSessionImpl> parentSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
768 ASSERT_NE(nullptr, parentSceneSession);
769
770 ASSERT_EQ(nullptr, parentSceneSession->FindParentSessionByParentId(-1));
771 }
772
773 /**
774 * @tc.name: GetConfigurationFromAbilityInfo02
775 * @tc.desc: GetConfigurationFromAbilityInfo
776 * @tc.type: FUNC
777 */
HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo02, Function | SmallTest | Level2)778 HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo02, Function | SmallTest | Level2)
779 {
780 sptr<WindowOption> option = new (std::nothrow) WindowOption();
781 option->SetWindowName("GetConfigurationFromAbilityInfo02");
782 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
783 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
784 ASSERT_NE(nullptr, windowSceneSession);
785 int ret = 0;
786 windowSceneSession->GetConfigurationFromAbilityInfo();
787 ASSERT_EQ(ret, 0);
788 }
789
790 /**
791 * @tc.name: NotifyWindowSessionProperty01
792 * @tc.desc: NotifyWindowSessionProperty
793 * @tc.type: FUNC
794 */
HWTEST_F(WindowSceneSessionImplTest2, NotifyWindowSessionProperty01, Function | SmallTest | Level2)795 HWTEST_F(WindowSceneSessionImplTest2, NotifyWindowSessionProperty01, Function | SmallTest | Level2)
796 {
797 sptr<WindowOption> option = new (std::nothrow) WindowOption();
798 option->SetWindowName("NotifyWindowSessionProperty01");
799 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
800 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
801 ASSERT_NE(nullptr, windowSceneSession);
802 int ret = 0;
803 windowSceneSession->NotifyWindowSessionProperty();
804 ASSERT_EQ(ret, 0);
805 }
806
HWTEST_F(WindowSceneSessionImplTest2, IsTransparent01, Function | SmallTest | Level2)807 HWTEST_F(WindowSceneSessionImplTest2, IsTransparent01, Function | SmallTest | Level2)
808 {
809 sptr<WindowOption> option = new (std::nothrow) WindowOption();
810 option->SetWindowName("IsTransparent01");
811 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
812 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
813 ASSERT_NE(nullptr, windowSceneSession);
814 int ret = 0;
815 windowSceneSession->IsTransparent();
816 ASSERT_EQ(ret, 0);
817 }
818
819 /**
820 * @tc.name: SetTransparent02
821 * @tc.desc: SetTransparent
822 * @tc.type: FUNC
823 */
HWTEST_F(WindowSceneSessionImplTest2, SetTransparent02, Function | SmallTest | Level2)824 HWTEST_F(WindowSceneSessionImplTest2, SetTransparent02, Function | SmallTest | Level2)
825 {
826 sptr<WindowOption> option = new (std::nothrow) WindowOption();
827 option->SetWindowName("SetTransparent02");
828 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
829 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
830 ASSERT_NE(nullptr, windowSceneSession);
831 int ret = 0;
832 bool isTransparent = false;
833 windowSceneSession->SetTransparent(isTransparent);
834 ASSERT_EQ(ret, 0);
835 }
836
837 /**
838 * @tc.name: Snapshot01
839 * @tc.desc: Snapshot
840 * @tc.type: FUNC
841 */
HWTEST_F(WindowSceneSessionImplTest2, Snapshot01, Function | SmallTest | Level2)842 HWTEST_F(WindowSceneSessionImplTest2, Snapshot01, Function | SmallTest | Level2)
843 {
844 sptr<WindowOption> option = new (std::nothrow) WindowOption();
845 option->SetWindowName("Snapshot01");
846 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
847 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
848 ASSERT_NE(nullptr, windowSceneSession);
849 int ret = 0;
850 windowSceneSession->Snapshot();
851 ASSERT_EQ(ret, 0);
852 }
853
854 /**
855 * @tc.name: BindDialogTarget01
856 * @tc.desc: BindDialogTarget
857 * @tc.type: FUNC
858 */
HWTEST_F(WindowSceneSessionImplTest2, BindDialogTarget01, Function | SmallTest | Level2)859 HWTEST_F(WindowSceneSessionImplTest2, BindDialogTarget01, Function | SmallTest | Level2)
860 {
861 sptr<WindowOption> option = new (std::nothrow) WindowOption();
862 option->SetWindowName("BindDialogTarget01");
863 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
864 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
865 ASSERT_NE(nullptr, windowSceneSession);
866 sptr<IRemoteObject> targetToken;
867 WMError ret = windowSceneSession->BindDialogTarget(targetToken);
868 ASSERT_EQ(ret, WMError::WM_OK);
869 }
870
871 /**
872 * @tc.name: SetDialogBackGestureEnabled01
873 * @tc.desc: SetDialogBackGestureEnabled
874 * @tc.type: FUNC
875 */
HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled01, Function | SmallTest | Level2)876 HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled01, Function | SmallTest | Level2)
877 {
878 sptr<WindowOption> option = new (std::nothrow) WindowOption();
879 ASSERT_NE(nullptr, option);
880 option->SetWindowName("SetDialogBackGestureEnabled01");
881 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
882 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
883 ASSERT_NE(nullptr, windowSceneSession);
884 WMError ret = windowSceneSession->SetDialogBackGestureEnabled(true);
885 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
886 }
887
888 /**
889 * @tc.name: SetDialogBackGestureEnabled02
890 * @tc.desc: SetDialogBackGestureEnabled
891 * @tc.type: FUNC
892 */
HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled02, Function | SmallTest | Level2)893 HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled02, Function | SmallTest | Level2)
894 {
895 sptr<WindowOption> option = new (std::nothrow) WindowOption();
896 ASSERT_NE(nullptr, option);
897 option->SetWindowName("SetDialogBackGestureEnabled02");
898 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
899 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
900 ASSERT_NE(nullptr, windowSceneSession);
901
902 WMError ret = windowSceneSession->SetDialogBackGestureEnabled(true);
903 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
904 }
905
906 /**
907 * @tc.name: NotifySessionForeground
908 * @tc.desc: NotifySessionForeground
909 * @tc.type: FUNC
910 */
HWTEST_F(WindowSceneSessionImplTest2, NotifySessionForeground, Function | SmallTest | Level2)911 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionForeground, Function | SmallTest | Level2)
912 {
913 sptr<WindowOption> option = new (std::nothrow) WindowOption();
914 option->SetWindowName("NotifySessionForeground");
915 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
916 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
917 ASSERT_NE(nullptr, windowSceneSession);
918
919 uint32_t reason = 1;
920 bool withAnimation = true;
921 windowSceneSession->NotifySessionForeground(reason, withAnimation);
922 }
923
924 /**
925 * @tc.name: NotifySessionBackground
926 * @tc.desc: NotifySessionBackground
927 * @tc.type: FUNC
928 */
HWTEST_F(WindowSceneSessionImplTest2, NotifySessionBackground, Function | SmallTest | Level2)929 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionBackground, Function | SmallTest | Level2)
930 {
931 sptr<WindowOption> option = new (std::nothrow) WindowOption();
932 option->SetWindowName("NotifySessionBackground");
933 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
934 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
935 ASSERT_NE(nullptr, windowSceneSession);
936
937 uint32_t reason = 1;
938 bool withAnimation = true;
939 bool isFromInnerkits = true;
940 windowSceneSession->NotifySessionBackground(reason, withAnimation, isFromInnerkits);
941 }
942
943 /**
944 * @tc.name: NotifySessionFullScreen
945 * @tc.desc: NotifySessionFullScreen
946 * @tc.type: FUNC
947 */
HWTEST_F(WindowSceneSessionImplTest2, NotifySessionFullScreen, Function | SmallTest | Level2)948 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionFullScreen, Function | SmallTest | Level2)
949 {
950 sptr<WindowOption> option = new (std::nothrow) WindowOption();
951 ASSERT_NE(nullptr, option);
952 option->SetWindowName("NotifySessionFullScreen");
953 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
954 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
955 ASSERT_NE(nullptr, windowSceneSession);
956
957 bool fullScreen = true;
958 windowSceneSession->NotifySessionFullScreen(fullScreen);
959 }
960
961 /**
962 * @tc.name: NotifyPrepareClosePiPWindow01
963 * @tc.desc: NotifyPrepareClosePiPWindow
964 * @tc.type: FUNC
965 */
HWTEST_F(WindowSceneSessionImplTest2, NotifyPrepareClosePiPWindow01, Function | SmallTest | Level2)966 HWTEST_F(WindowSceneSessionImplTest2, NotifyPrepareClosePiPWindow01, Function | SmallTest | Level2)
967 {
968 sptr<WindowOption> option = new (std::nothrow) WindowOption();
969 option->SetWindowName("NotifyPrepareClosePiPWindow01");
970 option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
971 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
972 ASSERT_NE(nullptr, windowSceneSession);
973 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
974 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
975 ASSERT_NE(nullptr, session);
976 windowSceneSession->hostSession_ = session;
977 ASSERT_EQ(WMError::WM_OK, windowSceneSession->NotifyPrepareClosePiPWindow());
978 }
979
980 /**
981 * @tc.name: SetDefaultDensityEnabled01
982 * @tc.desc: normal test
983 * @tc.type: FUNC
984 */
HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled01, Function | SmallTest | Level2)985 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled01, Function | SmallTest | Level2)
986 {
987 sptr<WindowOption> option = new (std::nothrow) WindowOption();
988 option->SetWindowName("SetDefaultDensityEnabled01");
989 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
990 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
991 ASSERT_NE(nullptr, window);
992
993 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
994 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
995 ASSERT_NE(nullptr, session);
996 window->property_->SetPersistentId(1);
997 window->hostSession_ = session;
998 window->state_ = WindowState::STATE_SHOWN;
999 window->property_->SetDisplayId(0);
1000
1001 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
1002 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1003 ASSERT_EQ(WMError::WM_OK, window->SetDefaultDensityEnabled(true));
1004 ASSERT_EQ(true, window->GetDefaultDensityEnabled());
1005 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1006 }
1007
1008 /**
1009 * @tc.name: SetDefaultDensityEnabled02
1010 * @tc.desc: window session is invalid
1011 * @tc.type: FUNC
1012 */
HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled02, Function | SmallTest | Level2)1013 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled02, Function | SmallTest | Level2)
1014 {
1015 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1016 option->SetWindowName("SetDefaultDensityEnabled02");
1017 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1018 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1019 ASSERT_NE(nullptr, window);
1020 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1021 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1022 ASSERT_NE(nullptr, session);
1023 window->property_->SetPersistentId(1);
1024 window->state_ = WindowState::STATE_SHOWN;
1025 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetDefaultDensityEnabled(true));
1026 }
1027
1028 /**
1029 * @tc.name: SetDefaultDensityEnabled03
1030 * @tc.desc: not app main window
1031 * @tc.type: FUNC
1032 */
HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled03, Function | SmallTest | Level2)1033 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled03, Function | SmallTest | Level2)
1034 {
1035 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1036 option->SetWindowName("SetDefaultDensityEnabled03");
1037 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1038 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1039 ASSERT_NE(nullptr, window);
1040 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1041 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1042 ASSERT_NE(nullptr, session);
1043 window->property_->SetPersistentId(1);
1044 window->hostSession_ = session;
1045 window->state_ = WindowState::STATE_SHOWN;
1046 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetDefaultDensityEnabled(true));
1047 }
1048
1049 /**
1050 * @tc.name: SetDefaultDensityEnabled04
1051 * @tc.desc: isDefaultDensityEnabled_ not change
1052 * @tc.type: FUNC
1053 */
HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled04, Function | SmallTest | Level2)1054 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled04, Function | SmallTest | Level2)
1055 {
1056 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1057 option->SetWindowName("SetDefaultDensityEnabled04");
1058 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1059 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1060 ASSERT_NE(nullptr, window);
1061 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1062 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1063 ASSERT_NE(nullptr, session);
1064 window->property_->SetPersistentId(1);
1065 window->hostSession_ = session;
1066 window->state_ = WindowState::STATE_SHOWN;
1067 ASSERT_EQ(WMError::WM_OK, window->SetDefaultDensityEnabled(false));
1068 }
1069
1070 /**
1071 * @tc.name: GetDefaultDensityEnabled01
1072 * @tc.desc: normal test
1073 * @tc.type: FUNC
1074 */
HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled01, Function | SmallTest | Level2)1075 HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled01, Function | SmallTest | Level2)
1076 {
1077 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1078 option->SetWindowName("GetDefaultDensityEnabled01");
1079 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1080 window->isDefaultDensityEnabled_ = true;
1081 ASSERT_EQ(true, window->GetDefaultDensityEnabled());
1082 }
1083
1084 /**
1085 * @tc.name: GetDefaultDensityEnabled02
1086 * @tc.desc: test default value
1087 * @tc.type: FUNC
1088 */
HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled02, Function | SmallTest | Level2)1089 HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled02, Function | SmallTest | Level2)
1090 {
1091 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1092 option->SetWindowName("GetDefaultDensityEnabled02");
1093 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1094 ASSERT_EQ(false, window->GetDefaultDensityEnabled());
1095 }
1096
1097 /**
1098 * @tc.name: GetVirtualPixelRatio01
1099 * @tc.desc: main window isDefaultDensityEnabled_ true
1100 * @tc.type: FUNC
1101 */
HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio01, Function | SmallTest | Level2)1102 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio01, Function | SmallTest | Level2)
1103 {
1104 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1105 option->SetWindowName("GetVirtualPixelRatio01");
1106 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1107 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1108 ASSERT_NE(nullptr, window);
1109
1110 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1111 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1112 ASSERT_NE(nullptr, session);
1113 window->property_->SetPersistentId(1);
1114 window->hostSession_ = session;
1115 window->state_ = WindowState::STATE_SHOWN;
1116 window->property_->SetDisplayId(0);
1117
1118 window->isDefaultDensityEnabled_ = true;
1119 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1120 auto defautDensity = 1.0f;
1121 auto density = 2.0f;
1122 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1123 displayInfo->SetVirtualPixelRatio(density);
1124 ASSERT_EQ(defautDensity, window->GetVirtualPixelRatio(displayInfo));
1125 }
1126
1127 /**
1128 * @tc.name: GetVirtualPixelRatio02
1129 * @tc.desc: main window isDefaultDensityEnabled_ false
1130 * @tc.type: FUNC
1131 */
HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio02, Function | SmallTest | Level2)1132 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio02, Function | SmallTest | Level2)
1133 {
1134 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1135 option->SetWindowName("GetVirtualPixelRatio02");
1136 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1137 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1138 ASSERT_NE(nullptr, window);
1139
1140 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1141 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1142 ASSERT_NE(nullptr, session);
1143 window->property_->SetPersistentId(1);
1144 window->hostSession_ = session;
1145 window->state_ = WindowState::STATE_SHOWN;
1146 window->property_->SetDisplayId(0);
1147
1148 window->isDefaultDensityEnabled_ = false;
1149 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1150 auto defautDensity = 1.0f;
1151 auto density = 2.0f;
1152 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1153 displayInfo->SetVirtualPixelRatio(density);
1154 ASSERT_EQ(density, window->GetVirtualPixelRatio(displayInfo));
1155
1156 window->useUniqueDensity_ = true;
1157 ASSERT_EQ(window->virtualPixelRatio_, window->GetVirtualPixelRatio(displayInfo));
1158 }
1159
1160 /**
1161 * @tc.name: GetVirtualPixelRatio03
1162 * @tc.desc: sub window isDefaultDensityEnabled_ true
1163 * @tc.type: FUNC
1164 */
HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio03, Function | SmallTest | Level2)1165 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio03, Function | SmallTest | Level2)
1166 {
1167 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1168 option->SetWindowName("GetVirtualPixelRatio03");
1169 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1170 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1171 ASSERT_NE(nullptr, window);
1172
1173 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1174 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1175 ASSERT_NE(nullptr, session);
1176 window->property_->SetPersistentId(1);
1177 window->hostSession_ = session;
1178 window->state_ = WindowState::STATE_SHOWN;
1179 window->property_->SetDisplayId(0);
1180
1181 window->isDefaultDensityEnabled_ = true;
1182 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1183 auto defautDensity = 1.0f;
1184 auto density = 2.0f;
1185 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1186 displayInfo->SetVirtualPixelRatio(density);
1187
1188 sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1189 subOption->SetWindowName("GetVirtualPixelRatio03SubWindow");
1190 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1191 sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1192 ASSERT_NE(nullptr, subWindow);
1193 subWindow->property_->SetParentPersistentId(window->GetWindowId());
1194
1195 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
1196 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1197 ASSERT_EQ(density, subWindow->GetVirtualPixelRatio(displayInfo));
1198 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1199 }
1200
1201 /**
1202 * @tc.name: GetVirtualPixelRatio04
1203 * @tc.desc: sub window isDefaultDensityEnabled_ false
1204 * @tc.type: FUNC
1205 */
HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio04, Function | SmallTest | Level2)1206 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio04, Function | SmallTest | Level2)
1207 {
1208 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1209 option->SetWindowName("GetVirtualPixelRatio04");
1210 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1211 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1212 ASSERT_NE(nullptr, window);
1213
1214 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1215 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1216 ASSERT_NE(nullptr, session);
1217 window->property_->SetPersistentId(1);
1218 window->hostSession_ = session;
1219 window->state_ = WindowState::STATE_SHOWN;
1220 window->property_->SetDisplayId(0);
1221
1222 window->isDefaultDensityEnabled_ = false;
1223 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1224 auto defautDensity = 1.0f;
1225 auto density = 2.0f;
1226 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1227 displayInfo->SetVirtualPixelRatio(density);
1228
1229 sptr<WindowOption> subOption = new (std::nothrow) WindowOption();
1230 subOption->SetWindowName("GetVirtualPixelRatio04SubWindow");
1231 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1232 sptr<WindowSceneSessionImpl> subWindow = new (std::nothrow) WindowSceneSessionImpl(subOption);
1233 ASSERT_NE(nullptr, subWindow);
1234 subWindow->property_->SetParentPersistentId(window->GetWindowId());
1235
1236 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(window->GetWindowName(),
1237 std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1238 ASSERT_EQ(density, subWindow->GetVirtualPixelRatio(displayInfo));
1239 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1240 }
1241
1242 /**
1243 * @tc.name: GetWindowLimits01
1244 * @tc.desc: GetWindowLimits
1245 * @tc.type: FUNC
1246 */
HWTEST_F(WindowSceneSessionImplTest2, GetWindowLimits01, Function | SmallTest | Level2)1247 HWTEST_F(WindowSceneSessionImplTest2, GetWindowLimits01, Function | SmallTest | Level2)
1248 {
1249 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1250 option->SetWindowName("GetWindowLimits01");
1251
1252 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1253 ASSERT_NE(nullptr, window);
1254
1255 WindowLimits windowLimits = {1000, 1000, 1000, 1000, 0.0f, 0.0f};
1256 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1257 window->property_->SetWindowLimits(windowLimits);
1258 window->property_->SetPersistentId(1);
1259 window->state_ = WindowState::STATE_HIDDEN;
1260 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1261 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1262 ASSERT_NE(nullptr, session);
1263 window->hostSession_ = session;
1264
1265 WindowLimits windowSizeLimits;
1266 ASSERT_EQ(WMError::WM_OK, window->GetWindowLimits(windowSizeLimits));
1267 ASSERT_EQ(windowSizeLimits.maxWidth_, 1000);
1268 ASSERT_EQ(windowSizeLimits.maxHeight_, 1000);
1269 ASSERT_EQ(windowSizeLimits.minWidth_, 1000);
1270 ASSERT_EQ(windowSizeLimits.minHeight_, 1000);
1271 }
1272
1273 /**
1274 * @tc.name: SetWindowLimits01
1275 * @tc.desc: SetWindowLimits
1276 * @tc.type: FUNC
1277 */
HWTEST_F(WindowSceneSessionImplTest2, SetWindowLimits01, Function | SmallTest | Level2)1278 HWTEST_F(WindowSceneSessionImplTest2, SetWindowLimits01, Function | SmallTest | Level2)
1279 {
1280 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1281 option->SetWindowName("SetWindowLimits01");
1282 option->SetDisplayId(0);
1283
1284 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1285
1286 window->property_->SetPersistentId(1);
1287 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1288 window->state_ = WindowState::STATE_FROZEN;
1289 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1290 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1291 window->hostSession_ = session;
1292
1293 WindowLimits windowLimits = {2000, 2000, 2000, 2000, 0.0f, 0.0f};
1294 ASSERT_EQ(WMError::WM_OK, window->SetWindowLimits(windowLimits));
1295 WindowLimits windowSizeLimits = window->property_->GetWindowLimits();
1296 ASSERT_EQ(windowSizeLimits.maxWidth_, 2000);
1297 ASSERT_EQ(windowSizeLimits.maxHeight_, 2000);
1298 ASSERT_EQ(windowSizeLimits.minWidth_, 2000);
1299 ASSERT_EQ(windowSizeLimits.minHeight_, 2000);
1300 }
1301
1302 /**
1303 * @tc.name: AdjustKeyboardLayout01
1304 * @tc.desc: adjust keyboard layout
1305 * @tc.type: FUNC
1306 */
HWTEST_F(WindowSceneSessionImplTest2, AdjustKeyboardLayout01, Function | SmallTest | Level2)1307 HWTEST_F(WindowSceneSessionImplTest2, AdjustKeyboardLayout01, Function | SmallTest | Level2)
1308 {
1309 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1310 option->SetWindowName("AdjustKeyboardLayout01");
1311 option->SetDisplayId(0);
1312
1313 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1314 ASSERT_NE(nullptr, window);
1315
1316 window->property_->SetPersistentId(123);
1317 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1318 window->state_ = WindowState::STATE_FROZEN;
1319 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1320 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1321 ASSERT_NE(nullptr, session);
1322 window->hostSession_ = session;
1323
1324 KeyboardLayoutParams params;
1325 params.gravity_ = WindowGravity::WINDOW_GRAVITY_FLOAT;
1326 params.LandscapeKeyboardRect_ = {1, 2, 3, 4};
1327 params.PortraitKeyboardRect_ = {1, 2, 3, 4};
1328 params.LandscapePanelRect_ = {1, 2, 3, 4};
1329 params.PortraitPanelRect_ = {1, 2, 3, 4};
1330 ASSERT_EQ(WMError::WM_OK, window->AdjustKeyboardLayout(params));
1331 }
1332 /**
1333 * @tc.name: HideNonSecureWindows01
1334 * @tc.desc: HideNonSecureWindows
1335 * @tc.type: FUNC
1336 */
HWTEST_F(WindowSceneSessionImplTest2, HideNonSecureWindows01, Function | SmallTest | Level2)1337 HWTEST_F(WindowSceneSessionImplTest2, HideNonSecureWindows01, Function | SmallTest | Level2)
1338 {
1339 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1340 option->SetWindowName("HideNonSecureWindows01");
1341
1342 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1343 ASSERT_NE(nullptr, window);
1344
1345 ASSERT_EQ(WMError::WM_OK, window->HideNonSecureWindows(true));
1346 }
1347
1348 /**
1349 * @tc.name: SetGrayScale01
1350 * @tc.desc: SetGrayScale
1351 * @tc.type: FUNC
1352 */
HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale01, Function | SmallTest | Level3)1353 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale01, Function | SmallTest | Level3)
1354 {
1355 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1356 ASSERT_NE(nullptr, option);
1357 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1358 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1359 ASSERT_NE(nullptr, window);
1360
1361 constexpr float grayScale = 0.5f;
1362 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGrayScale(grayScale));
1363 }
1364
1365 /**
1366 * @tc.name: SetGrayScale02
1367 * @tc.desc: SetGrayScale
1368 * @tc.type: FUNC
1369 */
HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale02, Function | SmallTest | Level3)1370 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale02, Function | SmallTest | Level3)
1371 {
1372 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1373 ASSERT_NE(nullptr, option);
1374 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1375 ASSERT_NE(nullptr, window);
1376
1377 window->state_ = WindowState::STATE_SHOWN;
1378 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1379 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1380 ASSERT_NE(nullptr, session);
1381 window->property_->SetPersistentId(1);
1382 window->hostSession_ = session;
1383 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1384
1385 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
1386 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
1387 WindowType::SYSTEM_WINDOW_BASE };
1388 for (WindowType type : types) {
1389 window->SetWindowType(type);
1390 float grayScale = -0.001f;
1391 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGrayScale(grayScale));
1392 grayScale = 1.001f;
1393 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGrayScale(grayScale));
1394 }
1395 }
1396
1397 /**
1398 * @tc.name: SetGrayScale03
1399 * @tc.desc: SetGrayScale
1400 * @tc.type: FUNC
1401 */
HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale03, Function | SmallTest | Level3)1402 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale03, Function | SmallTest | Level3)
1403 {
1404 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1405 ASSERT_NE(nullptr, option);
1406 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1407 ASSERT_NE(nullptr, window);
1408
1409 window->state_ = WindowState::STATE_SHOWN;
1410 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1411 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1412 ASSERT_NE(nullptr, session);
1413 window->property_->SetPersistentId(1);
1414 window->hostSession_ = session;
1415
1416 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetGrayScale(0.5));
1417
1418 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1419
1420 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
1421 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
1422 WindowType::SYSTEM_WINDOW_BASE };
1423 for (WindowType type : types) {
1424 window->SetWindowType(type);
1425 float grayScale = 0.0f;
1426 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
1427 grayScale = 1.0f;
1428 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
1429 grayScale = 0.5f;
1430 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
1431 }
1432 }
1433
1434 /**
1435 * @tc.name: SetGrayScale04
1436 * @tc.desc: Infinite non-circulating decimals
1437 * @tc.type: FUNC
1438 */
HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale04, Function | SmallTest | Level3)1439 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale04, Function | SmallTest | Level3)
1440 {
1441 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1442 ASSERT_NE(nullptr, option);
1443 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1444 ASSERT_NE(nullptr, window);
1445
1446 window->state_ = WindowState::STATE_SHOWN;
1447 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1448 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1449 ASSERT_NE(nullptr, session);
1450 ASSERT_NE(nullptr, window->property_);
1451 window->property_->SetPersistentId(1);
1452 window->hostSession_ = session;
1453
1454 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetGrayScale(0.5));
1455
1456 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1457
1458 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
1459 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
1460 WindowType::SYSTEM_WINDOW_BASE };
1461 for (WindowType type : types) {
1462 window->SetWindowType(type);
1463 float grayScale = 1.0f / 3.0f;
1464 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
1465 }
1466 }
1467
1468 /**
1469 * @tc.name: Maximize02
1470 * @tc.desc: test errorCode
1471 * @tc.type: FUNC
1472 */
HWTEST_F(WindowSceneSessionImplTest2, Maximize02, Function | SmallTest | Level2)1473 HWTEST_F(WindowSceneSessionImplTest2, Maximize02, Function | SmallTest | Level2)
1474 {
1475 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1476 option->SetWindowName("Maximize02");
1477 option->SetDisplayId(0);
1478
1479 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1480 ASSERT_NE(nullptr, window);
1481
1482 window->property_->SetWindowName("Maximize02");
1483 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1484 window->property_->SetPersistentId(2);
1485
1486 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1487 sptr session = new (std::nothrow) SessionMocker(sessionInfo);
1488 ASSERT_NE(nullptr, session);
1489 window->hostSession_ = session;
1490
1491 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
1492 // not support subWinodw call
1493 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->Maximize(presentation));
1494
1495 // window not support fullscreen
1496 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1497 window->property_->SetModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_PIP);
1498 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Maximize(presentation));
1499 }
1500
1501 /**
1502 * @tc.name: Maximize03
1503 * @tc.desc: test presentation
1504 * @tc.type: FUNC
1505 */
HWTEST_F(WindowSceneSessionImplTest2, Maximize03, Function | SmallTest | Level2)1506 HWTEST_F(WindowSceneSessionImplTest2, Maximize03, Function | SmallTest | Level2)
1507 {
1508 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1509 option->SetWindowName("Maximize03");
1510 option->SetDisplayId(0);
1511
1512 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1513 ASSERT_NE(nullptr, window);
1514
1515 window->property_->SetWindowName("Maximize03");
1516 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1517 window->property_->SetPersistentId(2);
1518
1519 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1520 sptr session = new (std::nothrow) SessionMocker(sessionInfo);
1521 ASSERT_NE(nullptr, session);
1522 window->hostSession_ = session;
1523
1524 ASSERT_NE(nullptr, window);
1525 // case1: only set maximize()
1526 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
1527 auto ret = window->Maximize(presentation);
1528 ASSERT_EQ(WMError::WM_OK, ret);
1529 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
1530
1531 // case2: maximize(EXIT_IMMERSIVE) and the immersive value will be set ad false
1532 presentation = MaximizePresentation::EXIT_IMMERSIVE;
1533 ret = window->Maximize(presentation);
1534 ASSERT_EQ(WMError::WM_OK, ret);
1535 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
1536
1537 // case3: maximize(FOLLOW_APP_IMMERSIVE_SETTING) and the immersive value will be set as client set
1538 presentation = MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING;
1539 ret = window->Maximize(presentation);
1540 ASSERT_EQ(WMError::WM_OK, ret);
1541 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
1542
1543 // case4: maximize(ENTER_IMMERSIVE) and the immersive value will be set as true
1544 presentation = MaximizePresentation::ENTER_IMMERSIVE;
1545 ret = window->Maximize(presentation);
1546 ASSERT_EQ(WMError::WM_OK, ret);
1547 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
1548 }
1549
1550 /**
1551 * @tc.name: Test01
1552 * @tc.desc: Test01
1553 * @tc.type: FUNC
1554 */
HWTEST_F(WindowSceneSessionImplTest2, Test01, Function | SmallTest | Level3)1555 HWTEST_F(WindowSceneSessionImplTest2, Test01, Function | SmallTest | Level3)
1556 {
1557 WindowLimits windowLimits = {3, 3, 3, 3, 2.0, 2.0};
1558 ASSERT_EQ(windowLimits.IsEmpty(), false);
1559 Rect rect = {2, 2, 2, 2};
1560 Rect rect1 = {2, 2, 2, 2};
1561 ASSERT_EQ(rect.IsInsideOf(rect1), true);
1562 TitleButtonRect titleButtonRect = {3, 3, 3, 3};
1563 TitleButtonRect titleButtonRect1 = {3, 3, 3, 3};
1564 ASSERT_EQ(titleButtonRect.IsUninitializedRect(), false);
1565 ASSERT_EQ(titleButtonRect.IsInsideOf(titleButtonRect1), true);
1566 AvoidArea avoidArea;
1567 AvoidArea avoidArea1;
1568 ASSERT_EQ((avoidArea != avoidArea1), false);
1569 }
1570
1571 /**
1572 * @tc.name: RegisterSessionRecoverListenerInputMethodFloat
1573 * @tc.desc: Register session recover listener
1574 * @tc.type: FUNC
1575 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerInputMethodFloat, Function | SmallTest | Level2)1576 HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerInputMethodFloat, Function | SmallTest | Level2)
1577 {
1578 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1579 ASSERT_NE(nullptr, option);
1580 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1581 ASSERT_NE(nullptr, window);
1582 ASSERT_NE(nullptr, window->property_);
1583 window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1584 window->RegisterSessionRecoverListener(false);
1585 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
1586 }
1587
1588 /**
1589 * @tc.name: RegisterSessionRecoverListenerNonDefaultCollaboratorType01
1590 * @tc.desc: Register session recover listener
1591 * @tc.type: FUNC
1592 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerNonDefaultCollaboratorType01, Function | SmallTest | Level2)1593 HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerNonDefaultCollaboratorType01,
1594 Function | SmallTest | Level2)
1595 {
1596 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1597 ASSERT_NE(nullptr, option);
1598 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1599 ASSERT_NE(nullptr, window);
1600 ASSERT_NE(nullptr, window->property_);
1601 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1602 window->property_->SetCollaboratorType(CollaboratorType::OTHERS_TYPE);
1603 window->RegisterSessionRecoverListener(false); // false is main window
1604 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
1605 }
1606
1607 /**
1608 * @tc.name: RegisterSessionRecoverListenerNonDefaultCollaboratorType02
1609 * @tc.desc: Register session recover listener
1610 * @tc.type: FUNC
1611 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerNonDefaultCollaboratorType02, Function | SmallTest | Level2)1612 HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerNonDefaultCollaboratorType02,
1613 Function | SmallTest | Level2)
1614 {
1615 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1616 ASSERT_NE(nullptr, option);
1617 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1618 ASSERT_NE(nullptr, window);
1619 ASSERT_NE(nullptr, window->property_);
1620 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1621 window->property_->SetCollaboratorType(CollaboratorType::OTHERS_TYPE);
1622 window->RegisterSessionRecoverListener(true); // true is sub window
1623 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
1624 }
1625
1626 /**
1627 * @tc.name: RegisterSessionRecoverListenerSuccess01
1628 * @tc.desc: Register session recover listener
1629 * @tc.type: FUNC
1630 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerSuccess01, Function | SmallTest | Level2)1631 HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerSuccess01, Function | SmallTest | Level2)
1632 {
1633 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1634 ASSERT_NE(nullptr, option);
1635 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1636 ASSERT_NE(nullptr, window);
1637 ASSERT_NE(nullptr, window->property_);
1638 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1639 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
1640 window->RegisterSessionRecoverListener(false); // false is main window
1641 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 1);
1642 SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.clear();
1643 }
1644
1645 /**
1646 * @tc.name: RegisterSessionRecoverListenerSuccess02
1647 * @tc.desc: Register session recover listener
1648 * @tc.type: FUNC
1649 */
HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerSuccess02, Function | SmallTest | Level2)1650 HWTEST_F(WindowSceneSessionImplTest2, RegisterSessionRecoverListenerSuccess02, Function | SmallTest | Level2)
1651 {
1652 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1653 ASSERT_NE(nullptr, option);
1654 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1655 ASSERT_NE(nullptr, window);
1656 ASSERT_NE(nullptr, window->property_);
1657 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1658 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
1659 window->RegisterSessionRecoverListener(true); // true is sub window
1660 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 1);
1661 SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.clear();
1662 }
1663
1664 /**
1665 * @tc.name: GetTitleButtonVisible01
1666 * @tc.desc: GetTitleButtonVisible
1667 * @tc.type: FUNC
1668 */
HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible01, Function | SmallTest | Level2)1669 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible01, Function | SmallTest | Level2)
1670 {
1671 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1672 option->SetWindowName("GetTitleButtonVisible01");
1673 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1674 ASSERT_NE(nullptr, window);
1675 uint32_t modeSupportInfo = 1 | (1 << 1) | (1 << 2);
1676 window->property_->SetModeSupportInfo(modeSupportInfo);
1677 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1678 // show Maximize, Minimize, Split buttons.
1679 window->windowTitleVisibleFlags_ = { false, false, false, false};
1680 bool hideMaximizeButton = false;
1681 bool hideMinimizeButton = false;
1682 bool hideSplitButton = false;
1683 bool hideCloseButton = false;
1684 window->GetTitleButtonVisible(true, hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
1685 ASSERT_EQ(hideMaximizeButton, true);
1686 ASSERT_EQ(hideMinimizeButton, true);
1687 ASSERT_EQ(hideSplitButton, true);
1688 ASSERT_EQ(hideCloseButton, true);
1689 }
1690
1691 /**
1692 * @tc.name: GetTitleButtonVisible02
1693 * @tc.desc: GetTitleButtonVisible
1694 * @tc.type: FUNC
1695 */
HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible02, Function | SmallTest | Level2)1696 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible02, Function | SmallTest | Level2)
1697 {
1698 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1699 option->SetWindowName("GetTitleButtonVisible02");
1700 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1701 ASSERT_NE(nullptr, window);
1702 // only not support WINDOW_MODE_SUPPORT_SPLIT
1703 uint32_t modeSupportInfo = 1 | (1 << 1);
1704 window->property_->SetModeSupportInfo(modeSupportInfo);
1705 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1706 // show Maximize, Minimize, Split buttons.
1707 window->windowTitleVisibleFlags_ = { true, true, true, true};
1708 bool hideMaximizeButton = false;
1709 bool hideMinimizeButton = false;
1710 bool hideSplitButton = false;
1711 bool hideCloseButton = false;
1712 window->GetTitleButtonVisible(true, hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
1713 ASSERT_EQ(hideMaximizeButton, false);
1714 ASSERT_EQ(hideMinimizeButton, false);
1715 ASSERT_EQ(hideSplitButton, false);
1716 ASSERT_EQ(hideCloseButton, false);
1717 }
1718
1719 /**
1720 * @tc.name: GetTitleButtonVisible03
1721 * @tc.desc: GetTitleButtonVisible
1722 * @tc.type: FUNC
1723 */
HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible03, Function | SmallTest | Level2)1724 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible03, Function | SmallTest | Level2)
1725 {
1726 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1727 option->SetWindowName("GetTitleButtonVisible03");
1728 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1729 ASSERT_NE(nullptr, window);
1730 // only not support WINDOW_MODE_SUPPORT_SPLIT
1731 uint32_t modeSupportInfo = 1 | (1 << 1) | (1 << 2);
1732 window->property_->SetModeSupportInfo(modeSupportInfo);
1733 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1734 // show Maximize, Minimize, Split buttons.
1735 window->windowTitleVisibleFlags_ = { false, false, false, false};
1736 bool hideMaximizeButton = true;
1737 bool hideMinimizeButton = true;
1738 bool hideSplitButton = true;
1739 bool hideCloseButton = true;
1740 window->GetTitleButtonVisible(false, hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
1741 ASSERT_EQ(hideMaximizeButton, true);
1742 ASSERT_EQ(hideMinimizeButton, true);
1743 ASSERT_EQ(hideSplitButton, true);
1744 ASSERT_EQ(hideCloseButton, true);
1745 }
1746
1747 /**
1748 * @tc.name: SetTitleButtonVisible01
1749 * @tc.desc: SetTitleButtonVisible
1750 * @tc.type: FUNC
1751 */
HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible01, Function | SmallTest | Level2)1752 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible01, Function | SmallTest | Level2)
1753 {
1754 sptr<WindowOption> option = new WindowOption();
1755 ASSERT_NE(option, nullptr);
1756 option->SetWindowName("SetTitleButtonVisible");
1757 sptr<WindowSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1758 ASSERT_NE(window, nullptr);
1759 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1760 window->SetTitleButtonVisible(false, false, false, true);
1761 }
1762
1763 /**
1764 * @tc.name: SetTitleButtonVisible02
1765 * @tc.desc: SetTitleButtonVisible
1766 * @tc.type: FUNC
1767 */
HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible02, Function | SmallTest | Level2)1768 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible02, Function | SmallTest | Level2)
1769 {
1770 sptr<WindowOption> option = new WindowOption();
1771 ASSERT_NE(option, nullptr);
1772 option->SetWindowName("SetTitleButtonVisible");
1773 sptr<WindowSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1774 ASSERT_NE(window, nullptr);
1775 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1776 WMError res = window->SetTitleButtonVisible(false, false, false, true);
1777 ASSERT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
1778 }
1779
1780 /**
1781 * @tc.name: SetTitleButtonVisible03
1782 * @tc.desc: SetTitleButtonVisible
1783 * @tc.type: FUNC
1784 */
HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible03, Function | SmallTest | Level2)1785 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible03, Function | SmallTest | Level2)
1786 {
1787 sptr option = new WindowOption();
1788 ASSERT_NE(option, nullptr);
1789 option->SetWindowName("SetTitleButtonVisible");
1790 sptr window = new (std::nothrow) WindowSceneSessionImpl(option);
1791 ASSERT_NE(window, nullptr);
1792 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1793 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1794 ASSERT_NE(nullptr, session);
1795 window->hostSession_ = session;
1796 window->property_->SetPersistentId(1);
1797 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1798 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1799 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1800 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1801 window->windowSystemConfig_.isSystemDecorEnable_ = true;
1802 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1803 WMError res = window->SetTitleButtonVisible(false, false, false, true);
1804 ASSERT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1805 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1806 res = window->SetTitleButtonVisible(false, false, false, true);
1807 ASSERT_EQ(res, WMError::WM_OK);
1808 }
1809
1810 }
1811 } // namespace Rosen
1812 } // namespace OHOS