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 #include "wm_common.h"
27 #include "window_manager_hilog.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 namespace {
35 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)36 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
37 const char *msg)
38 {
39 g_errLog = msg;
40 }
41 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
42 uint32_t MaxWith = 32;
43
44 class WindowSceneSessionImplTest2 : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp() override;
49 void TearDown() override;
50
51 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
52 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
53
54 private:
55 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
56 sptr<WindowSceneSessionImpl> InitialWindowState();
57 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
58 };
59
SetUpTestCase()60 void WindowSceneSessionImplTest2::SetUpTestCase() {}
61
TearDownTestCase()62 void WindowSceneSessionImplTest2::TearDownTestCase() {}
63
SetUp()64 void WindowSceneSessionImplTest2::SetUp()
65 {
66 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
67 }
68
TearDown()69 void WindowSceneSessionImplTest2::TearDown()
70 {
71 usleep(WAIT_SYNC_IN_NS);
72 abilityContext_ = nullptr;
73 }
74
CreateRSSurfaceNode()75 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest2::CreateRSSurfaceNode()
76 {
77 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
78 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
79 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
80 return surfaceNode;
81 }
82
InitialWindowState()83 sptr<WindowSceneSessionImpl> WindowSceneSessionImplTest2::InitialWindowState()
84 {
85 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
86 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
87 windowSceneSession->property_->SetPersistentId(1);
88 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
89 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
90 windowSceneSession->hostSession_ = session;
91 windowSceneSession->state_ = WindowState::STATE_SHOWN;
92 return windowSceneSession;
93 }
94
95 namespace {
96 /**
97 * @tc.name: SetBackdropBlur
98 * @tc.desc: SetBackdropBlur test
99 * @tc.type: FUNC
100 */
101 HWTEST_F(WindowSceneSessionImplTest2, SetBackdropBlur, Function | SmallTest | Level3)
102 {
103 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
104 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
105 window->property_->SetWindowName("SetBackdropBlur");
106 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
107
108 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlur(-1.0));
109 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(1.0));
110 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlur(0.0));
111 window->surfaceNode_ = nullptr;
112 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlur(1.0));
113 }
114
115 /**
116 * @tc.name: SetShadowColor
117 * @tc.desc: SetShadowColor test
118 * @tc.type: FUNC
119 */
120 HWTEST_F(WindowSceneSessionImplTest2, SetShadowColor, Function | SmallTest | Level3)
121 {
122 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
123 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
124 window->property_->SetWindowName("SetShadowColor");
125 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
126
127 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowColor("111ff22ee44"));
128 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#ff22ee44"));
129 ASSERT_EQ(WMError::WM_OK, window->SetShadowColor("#000999"));
130 window->surfaceNode_ = nullptr;
131 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowColor("#ff22ee44"));
132 }
133
134 /**
135 * @tc.name: SetCornerRadius
136 * @tc.desc: SetCornerRadius test
137 * @tc.type: FUNC
138 */
139 HWTEST_F(WindowSceneSessionImplTest2, SetCornerRadius, Function | SmallTest | Level3)
140 {
141 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
142 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
143 window->property_->SetWindowName("SetCornerRadius");
144 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
145
146 ASSERT_EQ(WMError::WM_OK, window->SetCornerRadius(1.0));
147 window->surfaceNode_ = nullptr;
148 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetCornerRadius(1.0));
149 }
150
151 /**
152 * @tc.name: SetShadowRadius
153 * @tc.desc: SetShadowRadius test
154 * @tc.type: FUNC
155 */
156 HWTEST_F(WindowSceneSessionImplTest2, SetShadowRadius, Function | SmallTest | Level3)
157 {
158 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
159 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
160 window->property_->SetWindowName("SetShadowRadius");
161 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
162
163 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetShadowRadius(-1.0));
164 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(0.0));
165 ASSERT_EQ(WMError::WM_OK, window->SetShadowRadius(1.0));
166 window->surfaceNode_ = nullptr;
167 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowRadius(1.0));
168 }
169
170 /**
171 * @tc.name: SetTransform01
172 * @tc.desc: set transform
173 * @tc.type: FUNC
174 * @tc.require:issueI7IJVV
175 */
176 HWTEST_F(WindowSceneSessionImplTest2, SetTransform01, Function | SmallTest | Level3)
177 {
178 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
179 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
180 option->SetWindowName("SetTransform01");
181 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
182 window->property_->SetPersistentId(1);
183 Transform trans_;
184 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransform(trans_));
185 }
186
187 /**
188 * @tc.name: SetTransform01
189 * @tc.desc: set transform
190 * @tc.type: FUNC
191 */
192 HWTEST_F(WindowSceneSessionImplTest2, SetTransform02, Function | SmallTest | Level3)
193 {
194 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
195 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
196 option->SetWindowName("SetTransform01");
197 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
198
199 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
200 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
201 window->hostSession_ = session;
202 window->property_->SetPersistentId(1);
203 window->state_ = WindowState::STATE_CREATED;
204 Transform trans_;
205 ASSERT_EQ(WMError::WM_OK, window->SetTransform(trans_));
206 ASSERT_EQ(trans_, window->GetTransform());
207 }
208
209 /**
210 * @tc.name: RegisterAnimationTransitionController01
211 * @tc.desc: RegisterAnimationTransitionController
212 * @tc.type: FUNC
213 */
214 HWTEST_F(WindowSceneSessionImplTest2, RegisterAnimationTransitionController01, TestSize.Level1)
215 {
216 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
217 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
218 option->SetWindowName("RegisterAnimationTransitionController01");
219 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
220 window->property_->SetPersistentId(1);
221 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->RegisterAnimationTransitionController(nullptr));
222 }
223
224 /**
225 * @tc.name: SetNeedDefaultAnimation01
226 * @tc.desc: SetNeedDefaultAnimation
227 * @tc.type: FUNC
228 * @tc.require:issueI7IJVV
229 */
230 HWTEST_F(WindowSceneSessionImplTest2, SetNeedDefaultAnimation01, TestSize.Level1)
231 {
232 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
233 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
234 option->SetWindowName("SetNeedDefaultAnimation01");
235 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
236 auto ret = true;
237 window->property_->SetPersistentId(1);
238
239 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
240 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
241 window->hostSession_ = session;
242 window->SetNeedDefaultAnimation(false);
243 ASSERT_TRUE(ret);
244 }
245
246 /**
247 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation01
248 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation
249 * @tc.type: FUNC
250 * @tc.require:issueI7IJVV
251 */
252 HWTEST_F(WindowSceneSessionImplTest2, UpdateSurfaceNodeAfterCustomAnimation, TestSize.Level1)
253 {
254 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
255 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
256 option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
257 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
258 window->property_->SetPersistentId(1);
259
260 window->UpdateSurfaceNodeAfterCustomAnimation(false);
261 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->UpdateSurfaceNodeAfterCustomAnimation(false));
262 window->property_->SetPersistentId(1);
263 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
264 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
265 window->hostSession_ = session;
266 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
267 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->UpdateSurfaceNodeAfterCustomAnimation(false));
268 }
269
270 /**
271 * @tc.name: SetAlpha01
272 * @tc.desc: SetAlpha
273 * @tc.type: FUNC
274 */
275 HWTEST_F(WindowSceneSessionImplTest2, SetAlpha01, Function | SmallTest | Level2)
276 {
277 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
278 option->SetWindowName("SetAlpha01");
279 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
280 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
281 windowSceneSession->property_->SetPersistentId(11);
282 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
283 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->SetAlpha(1.0));
284 }
285
286 /**
287 * @tc.name: SetAlpha02
288 * @tc.desc: SetAlpha
289 * @tc.type: FUNC
290 */
291 HWTEST_F(WindowSceneSessionImplTest2, SetAlpha02, Function | SmallTest | Level2)
292 {
293 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
294 option->SetWindowName("SetAlpha02");
295 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
296 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
297
298 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestMode", "CreateTestAbility"};
299 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
300 windowSceneSession->hostSession_ = session;
301 windowSceneSession->property_->SetPersistentId(1);
302 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
303 ASSERT_EQ(WMError::WM_OK, windowSceneSession->SetAlpha(1.0));
304 }
305
306 /**
307 * @tc.name: DestroySubWindow01
308 * @tc.desc: DestroySubWindow
309 * @tc.type: FUNC
310 */
311 HWTEST_F(WindowSceneSessionImplTest2, DestroySubWindow01, TestSize.Level1)
312 {
313 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
314 option->SetWindowName("DestroySubWindow01");
315 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
316 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
317 windowSceneSession->DestroySubWindow();
318 ASSERT_EQ(INVALID_SESSION_ID, windowSceneSession->property_->GetParentPersistentId());
319 }
320
321 /**
322 * @tc.name: UpdateFloatingWindowSizeBySizeLimits01
323 * @tc.desc: UpdateFloatingWindowSizeBySizeLimits
324 * @tc.type: FUNC
325 */
326 HWTEST_F(WindowSceneSessionImplTest2, UpdateFloatingWindowSizeBySizeLimits01, TestSize.Level1)
327 {
328 g_errLog.clear();
329 LOG_SetCallback(MyLogCallback);
330 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
331 option->SetWindowName("UpdateFloatingWindowSizeBySizeLimits01");
332 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
333 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
334 windowSceneSession->UpdateFloatingWindowSizeBySizeLimits(MaxWith, MaxWith);
335 EXPECT_FALSE(g_errLog.find("float camera type window") != std::string::npos);
336 LOG_SetCallback(nullptr);
337 }
338
339 /**
340 * @tc.name: UpdateAnimationFlagProperty01
341 * @tc.desc: UpdateAnimationFlagProperty
342 * @tc.type: FUNC
343 */
344 HWTEST_F(WindowSceneSessionImplTest2, UpdateAnimationFlagProperty01, TestSize.Level1)
345 {
346 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
347 option->SetWindowName("UpdateAnimationFlagProperty01");
348 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
349 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
350 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->UpdateAnimationFlagProperty(false));
351 }
352
353 /**
354 * @tc.name: UpdateAnimationFlagProperty02
355 * @tc.desc: UpdateAnimationFlagProperty
356 * @tc.type: FUNC
357 */
358 HWTEST_F(WindowSceneSessionImplTest2, UpdateAnimationFlagProperty02, TestSize.Level1)
359 {
360 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
361 option->SetWindowName("UpdateAnimationFlagProperty01");
362 option->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
363
364 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
365 ASSERT_EQ(WMError::WM_OK, windowSceneSession->UpdateAnimationFlagProperty(false));
366 }
367
368 /**
369 * @tc.name: UpdateWindowModeImmediately01
370 * @tc.desc: UpdateWindowModeImmediately
371 * @tc.type: FUNC
372 */
373 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowModeImmediately01, TestSize.Level1)
374 {
375 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
376 option->SetWindowName("UpdateWindowModeImmediately01");
377 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
378
379 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
380 ASSERT_EQ(WMError::WM_OK, windowSceneSession->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_UNDEFINED));
381 windowSceneSession->state_ = WindowState::STATE_CREATED;
382 ASSERT_EQ(WMError::WM_OK, windowSceneSession->UpdateWindowModeImmediately(WindowMode::WINDOW_MODE_UNDEFINED));
383 }
384
385 /**
386 * @tc.name: UpdateWindowMode01
387 * @tc.desc: UpdateWindowMode
388 * @tc.type: FUNC
389 */
390 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode01, TestSize.Level1)
391 {
392 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
393 option->SetWindowName("UpdateWindowMode01");
394 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
395
396 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
397 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
398 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
399 windowSceneSession->state_ = WindowState::STATE_CREATED;
400 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
401 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
402
403 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
404 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
405 windowSceneSession->hostSession_ = session;
406 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
407 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
408 windowSceneSession->property_->SetPersistentId(1);
409 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW_MODE_OR_SIZE,
410 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_UNDEFINED));
411 }
412
413 /**
414 * @tc.name: UpdateWindowMode02
415 * @tc.desc: UpdateWindowMode
416 * @tc.type: FUNC
417 */
418 HWTEST_F(WindowSceneSessionImplTest2, UpdateWindowMode02, TestSize.Level1)
419 {
420 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
421 option->SetWindowName("UpdateWindowMode02");
422 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
423
424 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
425 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
426 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
427 windowSceneSession->state_ = WindowState::STATE_CREATED;
428 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
429 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
430
431 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
432 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
433 windowSceneSession->hostSession_ = session;
434 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW,
435 windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
436 windowSceneSession->property_->SetPersistentId(1);
437 ASSERT_EQ(WSError::WS_OK, windowSceneSession->UpdateWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
438 }
439
440 /**
441 * @tc.name: GetTopNavDestinationName01
442 * @tc.desc: test GetTopNavDestinationName whether get the top nav destination name.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(WindowSceneSessionImplTest2, GetTopNavDestinationName01, TestSize.Level1)
446 {
447 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
448 option->SetWindowName("GetTopNavDestinationName01");
449 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
450 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
451 windowSceneSession->uiContent_ = nullptr;
452 std::string topNavDestName;
453 windowSceneSession->GetTopNavDestinationName(topNavDestName);
454 EXPECT_EQ(topNavDestName, "");
455
456 windowSceneSession->uiContent_ = std::make_shared<Ace::UIContentMocker>();
457 windowSceneSession->GetTopNavDestinationName(topNavDestName);
458 EXPECT_EQ(topNavDestName, "");
459
460 Ace::UIContentMocker* uiContent = reinterpret_cast<Ace::UIContentMocker*>(windowSceneSession->uiContent_.get());
461 EXPECT_CALL(*uiContent, GetTopNavDestinationInfo(_, _)).WillOnce(Return("{"));
462 windowSceneSession->GetTopNavDestinationName(topNavDestName);
463 EXPECT_EQ(topNavDestName, "");
464
465 EXPECT_CALL(*uiContent, GetTopNavDestinationInfo(_, _)).WillOnce(Return("{\"name\":\"test\"}"));
466 windowSceneSession->GetTopNavDestinationName(topNavDestName);
467 EXPECT_EQ(topNavDestName, "test");
468 }
469
470 /**
471 * @tc.name: UpdateDefaultStatusBarColor01
472 * @tc.desc: test UpdateDefaultStatusBarColor
473 * @tc.type: FUNC
474 */
475 HWTEST_F(WindowSceneSessionImplTest2, UpdateDefaultStatusBarColor01, TestSize.Level1)
476 {
477 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
478 option->SetWindowName("UpdateDefaultStatusBarColor01");
479 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
480 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
481 ASSERT_NE(windowSceneSession, nullptr);
482 windowSceneSession->UpdateDefaultStatusBarColor();
483 windowSceneSession->specifiedColorMode_ = "light";
484 windowSceneSession->UpdateDefaultStatusBarColor();
485 }
486
487 /**
488 * @tc.name: RemoveWindowFlag01
489 * @tc.desc: RemoveWindowFlag
490 * @tc.type: FUNC
491 */
492 HWTEST_F(WindowSceneSessionImplTest2, RemoveWindowFlag01, TestSize.Level1)
493 {
494 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
495 option->SetWindowName("RemoveWindowFlag01");
496 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
497
498 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
499 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
500 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
501 windowSceneSession->state_ = WindowState::STATE_CREATED;
502 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
503 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
504
505 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
506 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
507 windowSceneSession->hostSession_ = session;
508 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
509 windowSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID));
510 }
511
512 /**
513 * @tc.name: GetConfigurationFromAbilityInfo01
514 * @tc.desc: GetConfigurationFromAbilityInfo
515 * @tc.type: FUNC
516 */
517 HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo01, TestSize.Level1)
518 {
519 g_errLog.clear();
520 LOG_SetCallback(MyLogCallback);
521 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
522 option->SetWindowName("GetConfigurationFromAbilityInfo01");
523 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
524 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
525 windowSceneSession->GetConfigurationFromAbilityInfo();
526 EXPECT_TRUE(g_errLog.find("abilityContext is nullptr") != std::string::npos);
527 LOG_SetCallback(nullptr);
528 }
529
530 /**
531 * @tc.name: ExtractSupportWindowModeFromMetaData
532 * @tc.desc: ExtractSupportWindowModeFromMetaData
533 * @tc.type: FUNC
534 */
535 HWTEST_F(WindowSceneSessionImplTest2, ExtractSupportWindowModeFromMetaData, Function | SmallTest | Level2)
536 {
537 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
538 option->SetWindowName("ExtractSupportWindowModeFromMetaData");
539 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
540 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
541
542 windowSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
543 AppExecFwk::AbilityInfo abilityInfo;
544 int ret = 0;
545 std::vector<AppExecFwk::SupportWindowMode> updateWindowModes =
546 windowSceneSession->ExtractSupportWindowModeFromMetaData(
547 std::make_shared<OHOS::AppExecFwk::AbilityInfo>(abilityInfo));
548 ASSERT_EQ(ret, 0);
549
550 windowSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
551 windowSceneSession->windowSystemConfig_.freeMultiWindowEnable_ = false;
552 updateWindowModes =
553 windowSceneSession->ExtractSupportWindowModeFromMetaData(
554 std::make_shared<OHOS::AppExecFwk::AbilityInfo>(abilityInfo));
555 ASSERT_EQ(ret, 0);
556 }
557
558 /**
559 * @tc.name: ParseWindowModeFromMetaData
560 * @tc.desc: ParseWindowModeFromMetaData
561 * @tc.type: FUNC
562 */
563 HWTEST_F(WindowSceneSessionImplTest2, ParseWindowModeFromMetaData, Function | SmallTest | Level2)
564 {
565 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
566 option->SetWindowName("ParseWindowModeFromMetaData");
567 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
568 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
569
570 std::vector<AppExecFwk::SupportWindowMode> updateWindowModes =
571 {AppExecFwk::SupportWindowMode::FULLSCREEN, AppExecFwk::SupportWindowMode::SPLIT,
572 AppExecFwk::SupportWindowMode::FLOATING};
573 ASSERT_EQ(updateWindowModes, windowSceneSession->ParseWindowModeFromMetaData("fullscreen,split,floating"));
574 }
575
576 /**
577 * @tc.name: SetDefaultProperty01
578 * @tc.desc: SetDefaultProperty
579 * @tc.type: FUNC
580 */
581 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultProperty01, TestSize.Level1)
582 {
583 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
584 option->SetWindowName("SetDefaultProperty01");
585 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
586 option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
587 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
588 windowSceneSession->SetDefaultProperty();
589 ASSERT_NE(WindowMode::WINDOW_MODE_FLOATING, windowSceneSession->GetWindowMode());
590 }
591
592 /**
593 * @tc.name: UpdateConfiguration01
594 * @tc.desc: UpdateConfiguration
595 * @tc.type: FUNC
596 */
597 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfiguration01, TestSize.Level1)
598 {
599 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
600 option->SetWindowName("UpdateConfiguration01");
601 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
602 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
603 std::shared_ptr<AppExecFwk::Configuration> configuration;
604 windowSceneSession->UpdateConfiguration(configuration);
605 windowSceneSession->uiContent_ = std::make_shared<Ace::UIContentMocker>();
606 ASSERT_NE(windowSceneSession->uiContent_, nullptr);
607 windowSceneSession->UpdateConfiguration(configuration);
608 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
609 option2->SetWindowName("subWindow");
610 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
611 sptr<WindowSceneSessionImpl> subSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
612 ASSERT_NE(subSession, nullptr);
613 subSession->property_->SetPersistentId(8);
614 windowSceneSession->subWindowSessionMap_.clear();
615 windowSceneSession->subWindowSessionMap_[windowSceneSession->GetPersistentId()].push_back(subSession);
616 windowSceneSession->UpdateConfiguration(configuration);
617 windowSceneSession->subWindowSessionMap_.clear();
618 }
619
620 /**
621 * @tc.name: UpdateConfigurationSync
622 * @tc.desc: Test UpdateConfigurationSync can update new configuration of window
623 * @tc.type: FUNC
624 */
625 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfigurationSync, TestSize.Level1)
626 {
627 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
628 option->SetWindowName("UpdateConfigurationSync01");
629 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
630 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
631 std::shared_ptr<AppExecFwk::Configuration> configuration;
632 windowSceneSession->UpdateConfigurationSync(configuration);
633 windowSceneSession->uiContent_ = std::make_shared<Ace::UIContentMocker>();
634 windowSceneSession->UpdateConfigurationSync(configuration);
635 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
636 option2->SetWindowName("subWindow");
637 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
638 sptr<WindowSceneSessionImpl> subSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
639 ASSERT_NE(subSession, nullptr);
640 subSession->property_->SetPersistentId(8);
641 windowSceneSession->subWindowSessionMap_.clear();
642 windowSceneSession->subWindowSessionMap_[windowSceneSession->GetPersistentId()].push_back(subSession);
643 windowSceneSession->UpdateConfigurationSync(configuration);
644 windowSceneSession->subWindowSessionMap_.clear();
645 }
646
647 /**
648 * @tc.name: UpdateConfigurationForSpecified
649 * @tc.desc: UpdateConfigurationForSpecified
650 * @tc.type: FUNC
651 */
652 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfigurationForSpecified, TestSize.Level1)
653 {
654 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
655 option->SetWindowName("UpdateConfiguration01");
656 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
657 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
658 std::shared_ptr<AppExecFwk::Configuration> configuration;
659 std::shared_ptr<Global::Resource::ResourceManager> resourceManager;
660 windowSceneSession->uiContent_ = nullptr;
661 windowSceneSession->UpdateConfigurationForSpecified(configuration, resourceManager);
662 windowSceneSession->uiContent_ = std::make_shared<Ace::UIContentMocker>();
663 windowSceneSession->UpdateConfigurationForSpecified(configuration, resourceManager);
664 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
665 option2->SetWindowName("subWindow");
666 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
667 sptr<WindowSceneSessionImpl> subSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
668 ASSERT_NE(subSession, nullptr);
669 subSession->property_->SetPersistentId(8);
670 windowSceneSession->subWindowSessionMap_.clear();
671 windowSceneSession->subWindowSessionMap_[windowSceneSession->GetPersistentId()].push_back(subSession);
672 windowSceneSession->UpdateConfigurationForSpecified(configuration, resourceManager);
673 windowSceneSession->subWindowSessionMap_.clear();
674 windowSceneSession->UpdateConfigurationForAll(configuration);
675 EXPECT_FALSE(g_errLog.find("scene map size: %{public}u") != std::string::npos);
676 }
677
678 /**
679 * @tc.name: UpdateConfigurationForAll02
680 * @tc.desc: UpdateConfigurationForAll02 Test
681 * @tc.type: FUNC
682 */
683 HWTEST_F(WindowSceneSessionImplTest2, UpdateConfigurationForAll02, TestSize.Level1)
684 {
685 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
686 option->SetWindowName("UpdateConfigurationForAll02");
687 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
688 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
689 auto abilityContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
690 ASSERT_NE(nullptr, abilityContext);
691 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
692 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
693 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext, session));
694 std::shared_ptr<AppExecFwk::Configuration> configuration;
695 std::vector<std::shared_ptr<AbilityRuntime::Context>> ignoreWindowContexts;
696 ignoreWindowContexts.push_back(abilityContext);
697 window->UpdateConfigurationForAll(configuration, ignoreWindowContexts);
698 }
699
700 /**
701 * @tc.name: GetTopWindowWithContext01
702 * @tc.desc: GetTopWindowWithContext
703 * @tc.type: FUNC
704 */
705 HWTEST_F(WindowSceneSessionImplTest2, GetTopWindowWithContext01, TestSize.Level1)
706 {
707 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
708 option->SetWindowName("GetTopWindowWithContext01");
709 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
710 std::shared_ptr<AbilityRuntime::Context> context;
711 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
712 if (windowSceneSession->GetTopWindowWithContext(context) == nullptr) {
713 ASSERT_EQ(nullptr, windowSceneSession->GetTopWindowWithContext(context));
714 }
715 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
716 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
717 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
718 windowSceneSession->GetTopWindowWithContext(context);
719 windowSceneSession->Destroy(true);
720 }
721
722 /**
723 * @tc.name: GetMainWindowWithContext01
724 * @tc.desc: GetMainWindowWithContext
725 * @tc.type: FUNC
726 */
727 HWTEST_F(WindowSceneSessionImplTest2, GetMainWindowWithContext01, TestSize.Level1)
728 {
729 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
730 option->SetWindowName("GetMainWindowWithContext01");
731 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
732 std::shared_ptr<AbilityRuntime::Context> context;
733 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
734 if (windowSceneSession->GetMainWindowWithContext(context) == nullptr) {
735 ASSERT_EQ(nullptr, windowSceneSession->GetMainWindowWithContext(context));
736 }
737 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
738 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
739 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
740 windowSceneSession->GetMainWindowWithContext(context);
741 windowSceneSession->Destroy(true);
742 }
743
744 /**
745 * @tc.name: NotifyMemoryLevel01
746 * @tc.desc: NotifyMemoryLevel
747 * @tc.type: FUNC
748 */
749 HWTEST_F(WindowSceneSessionImplTest2, NotifyMemoryLevel01, TestSize.Level1)
750 {
751 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
752 option->SetWindowName("NotifyMemoryLevel01");
753 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
754 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
755 std::shared_ptr<AppExecFwk::Configuration> configuration;
756 windowSceneSession->NotifyMemoryLevel(2);
757 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->NotifyMemoryLevel(2));
758 windowSceneSession->uiContent_ = std::make_unique<Ace::UIContentMocker>();
759 ASSERT_EQ(WMError::WM_OK, windowSceneSession->NotifyMemoryLevel(2));
760 }
761
762 /**
763 * @tc.name: GetSystemSizeLimits01
764 * @tc.desc: GetSystemSizeLimits
765 * @tc.type: FUNC
766 */
767 HWTEST_F(WindowSceneSessionImplTest2, GetSystemSizeLimits01, TestSize.Level1)
768 {
769 constexpr uint32_t minMainWidth = 10;
770 constexpr uint32_t minMainHeight = 20;
771 constexpr uint32_t minSubWidth = 30;
772 constexpr uint32_t minSubHeight = 40;
773 constexpr uint32_t displayWidth = 100;
774 constexpr uint32_t displayHeight = 100;
775 constexpr float displayVpr = 1;
776 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
777 option->SetWindowName("GetSystemSizeLimits01");
778 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
779 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
780 windowSceneSession->windowSystemConfig_.miniWidthOfMainWindow_ = minMainWidth;
781 windowSceneSession->windowSystemConfig_.miniHeightOfMainWindow_ = minMainHeight;
782 windowSceneSession->windowSystemConfig_.miniWidthOfSubWindow_ = minSubWidth;
783 windowSceneSession->windowSystemConfig_.miniHeightOfSubWindow_ = minSubHeight;
784
785 WindowLimits limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
786 ASSERT_EQ(limits.minWidth_, minMainWidth);
787 ASSERT_EQ(limits.minHeight_, minMainHeight);
788
789 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
790 limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
791 ASSERT_EQ(limits.minWidth_, minMainWidth);
792 ASSERT_EQ(limits.minHeight_, minMainHeight);
793
794 windowSceneSession->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
795 limits = windowSceneSession->GetSystemSizeLimits(displayWidth, displayHeight, displayVpr);
796 ASSERT_EQ(limits.minWidth_, minMainWidth);
797 ASSERT_EQ(limits.minHeight_, minMainHeight);
798 }
799
800 /**
801 * @tc.name: DumpSessionElementInfo
802 * @tc.desc: DumpSessionElementInfo 1: params num
803 * @tc.type: FUNC
804 */
805 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo1, TestSize.Level1)
806 {
807 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
808 option->SetWindowName("DumpSessionElementInfo1");
809 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
810 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
811 std::vector<std::string> params;
812 params.push_back("-h");
813 window->DumpSessionElementInfo(params);
814 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
815 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
816 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
817 }
818
819 /**
820 * @tc.name: DumpSessionElementInfo
821 * @tc.desc: DumpSessionElementInfo2
822 * @tc.type: FUNC
823 */
824 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo2, TestSize.Level1)
825 {
826 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
827 option->SetWindowName("DumpSessionElementInfo2");
828 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
829 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
830 std::vector<std::string> params;
831 params.push_back("-h");
832 window->DumpSessionElementInfo(params);
833 params.push_back("-s");
834 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
835 window->DumpSessionElementInfo(params);
836 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
837 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
838 }
839
840 /**
841 * @tc.name: DumpSessionElementInfo
842 * @tc.desc: DumpSessionElementInfo3
843 * @tc.type: FUNC
844 */
845 HWTEST_F(WindowSceneSessionImplTest2, DumpSessionElementInfo3, TestSize.Level1)
846 {
847 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
848 option->SetWindowName("DumpSessionElementInfo3");
849 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
850 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
851 std::vector<std::string> params;
852 params.push_back("-s");
853 window->DumpSessionElementInfo(params);
854 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
855 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(2));
856 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
857 }
858
859 /**
860 * @tc.name: DisableAppWindowDecor02
861 * @tc.desc: DisableAppWindowDecor
862 * @tc.type: FUNC
863 */
864 HWTEST_F(WindowSceneSessionImplTest2, DisableAppWindowDecor02, TestSize.Level1)
865 {
866 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
867 option->SetWindowName("DisableAppWindowDecor02");
868 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
869 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
870 windowSceneSession->DisableAppWindowDecor();
871 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->DisableAppWindowDecor());
872 }
873
874 /**
875 * @tc.name: RaiseAboveTarget01
876 * @tc.desc: RaiseAboveTarget
877 * @tc.type: FUNC
878 */
879 HWTEST_F(WindowSceneSessionImplTest2, RaiseAboveTarget01, TestSize.Level1)
880 {
881 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
882 option->SetWindowName("RaiseAboveTarget01");
883 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
884 windowSceneSessionImpl->property_->SetPersistentId(6);
885 windowSceneSessionImpl->property_->SetParentPersistentId(0);
886 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
887 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
888 windowSceneSessionImpl->hostSession_ = session;
889 auto ret = windowSceneSessionImpl->RaiseAboveTarget(1);
890 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, ret);
891
892 windowSceneSessionImpl->property_->SetParentPersistentId(1);
893 ret = windowSceneSessionImpl->RaiseAboveTarget(1);
894 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
895
896 sptr<WindowSessionImpl> winSession = sptr<WindowSessionImpl>::MakeSptr(option);
897 WindowSessionImpl::subWindowSessionMap_.insert(
898 std::make_pair<int32_t, std::vector<sptr<WindowSessionImpl>>>(1, { winSession }));
899 winSession->property_->SetPersistentId(6);
900 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
901 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
902 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
903
904 winSession->state_ = WindowState::STATE_CREATED;
905 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
906 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
907 EXPECT_EQ(WMError::WM_DO_NOTHING, ret);
908
909 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
910 winSession->state_ = WindowState::STATE_SHOWN;
911 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
912 EXPECT_EQ(WMError::WM_OK, ret);
913
914 windowSceneSessionImpl->property_->SetPersistentId(3);
915 ret = windowSceneSessionImpl->RaiseAboveTarget(6);
916 EXPECT_EQ(WMError::WM_OK, ret);
917
918 WindowSessionImpl::subWindowSessionMap_.erase(1);
919 }
920
921 /**
922 * @tc.name: RaiseMainWindowAboveTarget_DeviceTypeTest
923 * @tc.desc: Test raising main window above target on different devices
924 * @tc.type: FUNC
925 */
926 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_DeviceTypeTest, TestSize.Level1)
927 {
928 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
929 option1->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest_SourceWindow");
930 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
931 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
932
933 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
934 sourceSceneSession->property_->SetDisplayId(0);
935 sourceSceneSession->property_->SetPersistentId(101);
936 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
937
938 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
939 option2->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest_TargetWindow");
940 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
941 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
942
943 targetSceneSession->state_ = WindowState::STATE_SHOWN;
944 targetSceneSession->property_->SetDisplayId(0);
945 targetSceneSession->property_->SetPersistentId(102);
946 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
947
948 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(102);
949 EXPECT_NE(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
950
951 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
952 sourceSceneSession->windowSystemConfig_.freeMultiWindowEnable_ = false;
953 sourceSceneSession->windowSystemConfig_.freeMultiWindowSupport_ = false;
954 ret = sourceSceneSession->RaiseMainWindowAboveTarget(102);
955 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
956
957 sourceSceneSession->windowSystemConfig_.freeMultiWindowEnable_ = false;
958 sourceSceneSession->windowSystemConfig_.freeMultiWindowSupport_ = false;
959 ret = sourceSceneSession->RaiseMainWindowAboveTarget(102);
960 EXPECT_NE(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
961
962 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
963 sourceSceneSession->windowSystemConfig_.freeMultiWindowEnable_ = false;
964 sourceSceneSession->windowSystemConfig_.freeMultiWindowSupport_ = false;
965 ret = sourceSceneSession->RaiseMainWindowAboveTarget(102);
966 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
967 }
968
969 /**
970 * @tc.name: SetSubWindowZLevel
971 * @tc.desc: SetSubWindowZLevel
972 * @tc.type: FUNC
973 */
974 HWTEST_F(WindowSceneSessionImplTest2, SetSubWindowZLevel, TestSize.Level1)
975 {
976 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
977 option->SetWindowName("SetSubWindowZLevel01");
978 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
979 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
980 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
981 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
982
983 windowSceneSessionImpl->property_->SetPersistentId(2);
984 auto ret = windowSceneSessionImpl->SetSubWindowZLevel(10001);
985 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
986 windowSceneSessionImpl->hostSession_ = session;
987
988 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
989 ret = windowSceneSessionImpl->SetSubWindowZLevel(10001);
990 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
991 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
992
993 windowSceneSessionImpl->property_->SetParentPersistentId(INVALID_SESSION_ID);
994 ret = windowSceneSessionImpl->SetSubWindowZLevel(10001);
995 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARENT, ret);
996 windowSceneSessionImpl->property_->SetParentPersistentId(3);
997
998 ret = windowSceneSessionImpl->SetSubWindowZLevel(10001);
999 EXPECT_EQ(WMError::WM_ERROR_INVALID_PARAM, ret);
1000
1001 windowSceneSessionImpl->property_->zLevel_ = 1;
1002 ret = windowSceneSessionImpl->SetSubWindowZLevel(1);
1003 EXPECT_EQ(WMError::WM_OK, ret);
1004
1005 ret = windowSceneSessionImpl->SetSubWindowZLevel(2);
1006 EXPECT_EQ(WMError::WM_OK, ret);
1007 }
1008
1009 /**
1010 * @tc.name: GetSubWindowZLevel
1011 * @tc.desc: GetSubWindowZLevel
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(WindowSceneSessionImplTest2, GetSubWindowZLevel, TestSize.Level1)
1015 {
1016 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1017 option->SetWindowName("GetSubWindowZLevel01");
1018 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1019 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1020 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1021 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
1022 windowSceneSessionImpl->hostSession_ = session;
1023 windowSceneSessionImpl->property_->zLevel_ = 1;
1024 int32_t zLevel = 0;
1025
1026 windowSceneSessionImpl->property_->SetPersistentId(INVALID_SESSION_ID);
1027 auto ret = windowSceneSessionImpl->GetSubWindowZLevel(zLevel);
1028 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1029 windowSceneSessionImpl->property_->SetPersistentId(2);
1030
1031 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1032 ret = windowSceneSessionImpl->GetSubWindowZLevel(zLevel);
1033 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1034 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1035 ret = windowSceneSessionImpl->GetSubWindowZLevel(zLevel);
1036 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1037
1038 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1039 ret = windowSceneSessionImpl->GetSubWindowZLevel(zLevel);
1040 EXPECT_EQ(WMError::WM_OK, ret);
1041 EXPECT_EQ(1, zLevel);
1042
1043 windowSceneSessionImpl->property_->zLevel_ = 2;
1044 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1045 ret = windowSceneSessionImpl->GetSubWindowZLevel(zLevel);
1046 EXPECT_EQ(WMError::WM_OK, ret);
1047 EXPECT_EQ(2, zLevel);
1048 }
1049
1050 /**
1051 * @tc.name: RaiseMainWindowAboveTarget_WindowStateTest01
1052 * @tc.desc: Test raising main window above target while window state invalid
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_WindowStateTest01, TestSize.Level1)
1056 {
1057 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1058 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1059
1060 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1061 option1->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest01_SourceWindow");
1062 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1063 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1064
1065 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1066 sourceSceneSession->property_->SetDisplayId(0);
1067 sourceSceneSession->property_->SetPersistentId(103);
1068 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1069 sourceSceneSession->hostSession_ = session;
1070
1071 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1072 option2->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest01_TargetWindow");
1073 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1074 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1075
1076 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1077 targetSceneSession->property_->SetDisplayId(0);
1078 targetSceneSession->property_->SetPersistentId(104);
1079 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1080 targetSceneSession->hostSession_ = session;
1081
1082 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1083 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1084
1085 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(104);
1086 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1087
1088 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1089 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), targetSceneSession)));
1090
1091 ret = sourceSceneSession->RaiseMainWindowAboveTarget(104);
1092 EXPECT_NE(WMError::WM_ERROR_INVALID_WINDOW, ret);
1093
1094 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1095 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1096 }
1097
1098 /**
1099 * @tc.name: RaiseMainWindowAboveTarget_WindowStateTest02
1100 * @tc.desc: Test raising main window above target while window state invalid
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_WindowStateTest02, TestSize.Level1)
1104 {
1105 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1106 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1107
1108 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1109 option1->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest02_SourceWindow");
1110 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1111 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1112
1113 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1114 sourceSceneSession->property_->SetDisplayId(0);
1115 sourceSceneSession->property_->SetPersistentId(INVALID_WINDOW_ID);
1116 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1117 sourceSceneSession->hostSession_ = session;
1118
1119 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1120 option2->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest02_TargetWindow");
1121 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1122 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1123
1124 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1125 targetSceneSession->property_->SetDisplayId(0);
1126 targetSceneSession->property_->SetPersistentId(106);
1127 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1128 targetSceneSession->hostSession_ = session;
1129
1130 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1131 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1132 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1133 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), targetSceneSession)));
1134
1135 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(106);
1136 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1137
1138 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1139 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1140 }
1141
1142 /**
1143 * @tc.name: RaiseMainWindowAboveTarget_WindowStateTest03
1144 * @tc.desc: Test raising main window above target while window state invalid
1145 * @tc.type: FUNC
1146 */
1147 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_WindowStateTest03, TestSize.Level1)
1148 {
1149 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1150 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1151
1152 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1153 option1->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest03_SourceWindow");
1154 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1155 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1156
1157 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1158 sourceSceneSession->property_->SetDisplayId(0);
1159 sourceSceneSession->property_->SetPersistentId(107);
1160 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1161 sourceSceneSession->hostSession_ = session;
1162
1163 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1164 option2->SetWindowName("RaiseMainWindowAboveTarget_DeviceTypeTest03_TargetWindow");
1165 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1166 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1167
1168 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1169 targetSceneSession->property_->SetDisplayId(0);
1170 targetSceneSession->property_->SetPersistentId(108);
1171 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1172 targetSceneSession->hostSession_ = session;
1173
1174 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1175 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1176 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1177 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), nullptr)));
1178
1179 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(108);
1180 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1181
1182 WindowSceneSessionImpl::windowSessionMap_["RaiseMainWindowAboveTarget_DeviceTypeTest03_TargetWindow"] =
1183 std::make_pair(targetSceneSession->GetWindowId(), targetSceneSession);
1184 ret = sourceSceneSession->RaiseMainWindowAboveTarget(108);
1185 EXPECT_NE(WMError::WM_ERROR_INVALID_WINDOW, ret);
1186
1187 targetSceneSession->hostSession_ = nullptr;
1188 ret = sourceSceneSession->RaiseMainWindowAboveTarget(108);
1189 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1190
1191 targetSceneSession->hostSession_ = session;
1192 targetSceneSession->state_ = WindowState::STATE_DESTROYED;
1193 ret = sourceSceneSession->RaiseMainWindowAboveTarget(108);
1194 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1195
1196 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1197 sourceSceneSession->state_ = WindowState::STATE_HIDDEN;
1198 ret = sourceSceneSession->RaiseMainWindowAboveTarget(108);
1199 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
1200
1201 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1202 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1203 }
1204
1205 /**
1206 * @tc.name: RaiseMainWindowAboveTarget_WindowTypeTest
1207 * @tc.desc: Test raising main window above target while window type invalid
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_WindowTypeTest, TestSize.Level1)
1211 {
1212 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1213 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1214
1215 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1216 option1->SetWindowName("RaiseMainWindowAboveTarget_WindowTypeTest_SourceWindow");
1217 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1218 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1219
1220 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1221 sourceSceneSession->property_->SetDisplayId(0);
1222 sourceSceneSession->property_->SetPersistentId(109);
1223 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1224 sourceSceneSession->hostSession_ = session;
1225
1226 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1227 option2->SetWindowName("RaiseMainWindowAboveTarget_WindowTypeTest_TargetWindow");
1228 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1229 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1230
1231 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1232 targetSceneSession->property_->SetDisplayId(0);
1233 targetSceneSession->property_->SetPersistentId(110);
1234 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1235 targetSceneSession->hostSession_ = session;
1236
1237 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1238 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1239 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1240 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), targetSceneSession)));
1241
1242 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(110);
1243 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1244
1245 ret = targetSceneSession->RaiseMainWindowAboveTarget(110);
1246 EXPECT_NE(WMError::WM_ERROR_INVALID_CALLING, ret);
1247
1248 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1249 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1250 }
1251
1252 /**
1253 * @tc.name: RaiseMainWindowAboveTarget_SpecialHierarchyTest01
1254 * @tc.desc: Test raising main window above target while window is modal or topmost, etc.
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_SpecialHierarchyTest01, TestSize.Level1)
1258 {
1259 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1260 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1261
1262 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1263 option1->SetWindowName("RaiseMainWindowAboveTarget_SpecialHierarchyTest01_SourceWindow");
1264 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1265 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1266
1267 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1268 sourceSceneSession->property_->SetDisplayId(0);
1269 sourceSceneSession->property_->SetPersistentId(111);
1270 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1271 sourceSceneSession->hostSession_ = session;
1272
1273 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1274 option2->SetWindowName("RaiseMainWindowAboveTarget_SpecialHierarchyTest01_TargetWindow");
1275 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1276 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1277
1278 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1279 targetSceneSession->property_->SetDisplayId(0);
1280 targetSceneSession->property_->SetPersistentId(112);
1281 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1282 targetSceneSession->hostSession_ = session;
1283 targetSceneSession->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1284
1285 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1286 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1287 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1288 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), targetSceneSession)));
1289
1290 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(112);
1291 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1292
1293 targetSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1294 sourceSceneSession->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1295 ret = sourceSceneSession->RaiseMainWindowAboveTarget(112);
1296 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1297
1298 sourceSceneSession->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1299 ret = sourceSceneSession->RaiseMainWindowAboveTarget(112);
1300 EXPECT_NE(WMError::WM_ERROR_INVALID_CALLING, ret);
1301
1302 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1303 subOption->SetWindowName("RaiseMainWindowAboveTarget_SpecialHierarchyTest01_ModalitySubWindow");
1304 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1305 sptr<WindowSceneSessionImpl> modalitySubWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1306
1307 modalitySubWindow->property_->SetParentPersistentId(sourceSceneSession->GetPersistentId());
1308 modalitySubWindow->state_ = WindowState::STATE_SHOWN;
1309 modalitySubWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1310 modalitySubWindow->property_->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_APPLICATION_MODAL);
1311 sourceSceneSession->subWindowSessionMap_[sourceSceneSession->GetPersistentId()].push_back(modalitySubWindow);
1312
1313 ret = sourceSceneSession->RaiseMainWindowAboveTarget(112);
1314 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1315
1316 sourceSceneSession->subWindowSessionMap_[sourceSceneSession->GetPersistentId()].pop_back();
1317 ret = sourceSceneSession->RaiseMainWindowAboveTarget(112);
1318 EXPECT_EQ(WMError::WM_OK, ret);
1319
1320 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1321 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1322 sourceSceneSession->subWindowSessionMap_.erase(sourceSceneSession->GetPersistentId());
1323 }
1324
1325 /**
1326 * @tc.name: RaiseMainWindowAboveTarget_SpecialHierarchyTest02
1327 * @tc.desc: Test raising main window above target while window is modal or topmost, etc.
1328 * @tc.type: FUNC
1329 */
1330 HWTEST_F(WindowSceneSessionImplTest2, RaiseMainWindowAboveTarget_SpecialHierarchyTest02, TestSize.Level1)
1331 {
1332 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1333 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1334
1335 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1336 option1->SetWindowName("RaiseMainWindowAboveTarget_SpecialHierarchyTest02_SourceWindow");
1337 option1->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1338 sptr<WindowSceneSessionImpl> sourceSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option1);
1339
1340 sourceSceneSession->state_ = WindowState::STATE_SHOWN;
1341 sourceSceneSession->property_->SetDisplayId(0);
1342 sourceSceneSession->property_->SetPersistentId(113);
1343 sourceSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1344 sourceSceneSession->hostSession_ = session;
1345 sourceSceneSession->property_->topmost_ = true;
1346
1347 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1348 option2->SetWindowName("RaiseMainWindowAboveTarget_SpecialHierarchyTest02_TargetWindow");
1349 option2->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1350 sptr<WindowSceneSessionImpl> targetSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
1351
1352 targetSceneSession->state_ = WindowState::STATE_SHOWN;
1353 targetSceneSession->property_->SetDisplayId(0);
1354 targetSceneSession->property_->SetPersistentId(114);
1355 targetSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1356 targetSceneSession->hostSession_ = session;
1357
1358 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(sourceSceneSession->GetWindowName(),
1359 std::pair<uint64_t, sptr<WindowSessionImpl>>(sourceSceneSession->GetWindowId(), sourceSceneSession)));
1360 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(targetSceneSession->GetWindowName(),
1361 std::pair<uint64_t, sptr<WindowSessionImpl>>(targetSceneSession->GetWindowId(), targetSceneSession)));
1362
1363 WMError ret = sourceSceneSession->RaiseMainWindowAboveTarget(114);
1364 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1365
1366 sourceSceneSession->property_->topmost_ = false;
1367 targetSceneSession->property_->topmost_ = true;
1368 ret = sourceSceneSession->RaiseMainWindowAboveTarget(114);
1369 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1370
1371 targetSceneSession->property_->topmost_ = false;
1372 sourceSceneSession->property_->mainWindowTopmost_ = true;
1373 ret = sourceSceneSession->RaiseMainWindowAboveTarget(114);
1374 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1375
1376 sourceSceneSession->property_->mainWindowTopmost_ = false;
1377 targetSceneSession->property_->mainWindowTopmost_ = true;
1378 ret = sourceSceneSession->RaiseMainWindowAboveTarget(114);
1379 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
1380
1381 targetSceneSession->property_->mainWindowTopmost_ = false;
1382 ret = sourceSceneSession->RaiseMainWindowAboveTarget(114);
1383 EXPECT_NE(WMError::WM_ERROR_INVALID_CALLING, ret);
1384
1385 WindowSceneSessionImpl::windowSessionMap_.erase(sourceSceneSession->GetWindowName());
1386 WindowSceneSessionImpl::windowSessionMap_.erase(targetSceneSession->GetWindowName());
1387 }
1388
1389 /**
1390 * @tc.name: FindParentSessionByParentId02
1391 * @tc.desc: FindParentSessionByParentId
1392 * @tc.type: FUNC
1393 */
1394 HWTEST_F(WindowSceneSessionImplTest2, FindParentSessionByParentId02, TestSize.Level1)
1395 {
1396 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1397 option->SetWindowTag(WindowTag::MAIN_WINDOW);
1398 option->SetWindowName("FindParentSessionByParentId02");
1399 sptr<WindowSceneSessionImpl> parentSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1400 ASSERT_EQ(nullptr, parentSceneSession->FindParentSessionByParentId(-1));
1401 }
1402
1403 /**
1404 * @tc.name: GetConfigurationFromAbilityInfo02
1405 * @tc.desc: GetConfigurationFromAbilityInfo
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(WindowSceneSessionImplTest2, GetConfigurationFromAbilityInfo02, TestSize.Level1)
1409 {
1410 g_errLog.clear();
1411 LOG_SetCallback(MyLogCallback);
1412 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1413 option->SetWindowName("GetConfigurationFromAbilityInfo02");
1414 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1415 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1416 windowSceneSession->GetConfigurationFromAbilityInfo();
1417 EXPECT_TRUE(g_errLog.find("abilityContext is nullptr") != std::string::npos);
1418 LOG_SetCallback(nullptr);
1419 }
1420
1421 /**
1422 * @tc.name: NotifyWindowSessionProperty01
1423 * @tc.desc: NotifyWindowSessionProperty
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(WindowSceneSessionImplTest2, NotifyWindowSessionProperty01, TestSize.Level1)
1427 {
1428 g_errLog.clear();
1429 LOG_SetCallback(MyLogCallback);
1430 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1431 option->SetWindowName("NotifyWindowSessionProperty01");
1432 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1433 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1434 windowSceneSession->NotifyWindowSessionProperty();
1435 EXPECT_TRUE(g_errLog.find("session is invalid") != std::string::npos);
1436 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->NotifyWindowSessionProperty());
1437 LOG_SetCallback(nullptr);
1438 }
1439
1440 HWTEST_F(WindowSceneSessionImplTest2, IsTransparent01, TestSize.Level1)
1441 {
1442 g_errLog.clear();
1443 LOG_SetCallback(MyLogCallback);
1444 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1445 option->SetWindowName("IsTransparent01");
1446 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1447 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1448 windowSceneSession->IsTransparent();
1449 EXPECT_FALSE(g_errLog.find("color: %{public}u, alpha: %{public}u") != std::string::npos);
1450 LOG_SetCallback(nullptr);
1451 }
1452
1453 /**
1454 * @tc.name: SetTransparent02
1455 * @tc.desc: SetTransparent
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(WindowSceneSessionImplTest2, SetTransparent02, TestSize.Level1)
1459 {
1460 g_errLog.clear();
1461 LOG_SetCallback(MyLogCallback);
1462 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1463 option->SetWindowName("SetTransparent02");
1464 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1465 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1466 bool isTransparent = false;
1467 windowSceneSession->SetTransparent(isTransparent);
1468 EXPECT_TRUE(g_errLog.find("session is invalid") != std::string::npos);
1469 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->SetTransparent(isTransparent));
1470 LOG_SetCallback(nullptr);
1471 }
1472
1473 /**
1474 * @tc.name: Snapshot01
1475 * @tc.desc: Snapshot
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(WindowSceneSessionImplTest2, Snapshot01, TestSize.Level1)
1479 {
1480 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1481 option->SetWindowName("Snapshot01");
1482 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1483 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1484 windowSceneSession->Snapshot();
1485 ASSERT_EQ(nullptr, windowSceneSession->Snapshot());
1486 }
1487
1488 /**
1489 * @tc.name: SnapshotSync01
1490 * @tc.desc: Test WMError::WM_ERROR_INVALID_WINDOW
1491 * @tc.type: FUNC
1492 */
1493 HWTEST_F(WindowSceneSessionImplTest2, SnapshotSync01, TestSize.Level1)
1494 {
1495 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1496 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1497 ASSERT_NE(nullptr, windowSceneSession);
1498 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
1499 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->Snapshot(pixelMap));
1500
1501 windowSceneSession->property_->SetPersistentId(1);
1502 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1503 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1504 windowSceneSession->hostSession_ = session;
1505 windowSceneSession->state_ = WindowState::STATE_CREATED;
1506 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->Snapshot(pixelMap));
1507 }
1508
1509 /**
1510 * @tc.name: SnapshotSync02
1511 * @tc.desc: Test WMError::WM_ERROR_INVALID_OPERATION
1512 * @tc.type: FUNC
1513 */
1514 HWTEST_F(WindowSceneSessionImplTest2, SnapshotSync02, TestSize.Level1)
1515 {
1516 auto windowSceneSession = InitialWindowState();
1517 ASSERT_NE(nullptr, windowSceneSession);
1518 windowSceneSession->surfaceNode_ = nullptr;
1519 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
1520 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, windowSceneSession->Snapshot(pixelMap));
1521 }
1522
1523 /**
1524 * @tc.name: SnapshotSync03
1525 * @tc.desc: Test WMError::WM_ERROR_TIMEOUT
1526 * @tc.type: FUNC
1527 */
1528 HWTEST_F(WindowSceneSessionImplTest2, SnapshotSync03, TestSize.Level1)
1529 {
1530 auto windowSceneSession = InitialWindowState();
1531 ASSERT_NE(nullptr, windowSceneSession);
1532 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
1533 auto surfaceNode_mocker = CreateRSSurfaceNode();
1534 ASSERT_NE(nullptr, surfaceNode_mocker);
1535 windowSceneSession->surfaceNode_ = surfaceNode_mocker;
1536 EXPECT_EQ(WMError::WM_ERROR_TIMEOUT, windowSceneSession->Snapshot(pixelMap));
1537 }
1538
1539 /**
1540 * @tc.name: SnapshotIgnorePrivacy
1541 * @tc.desc: SnapshotIgnorePrivacy
1542 * @tc.type: FUNC
1543 */
1544 HWTEST_F(WindowSceneSessionImplTest2, SnapshotIgnorePrivacy, TestSize.Level1)
1545 {
1546 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1547 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1548 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
1549 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->SnapshotIgnorePrivacy(pixelMap));
1550
1551 windowSceneSession->property_->SetPersistentId(1);
1552 SessionInfo sessionInfo = {"CreateTestBundle", "CreatTestModule", "CreateTestAbility"};
1553 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1554 windowSceneSession->hostSession_ = session;
1555 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->SnapshotIgnorePrivacy(pixelMap));
1556
1557 windowSceneSession->surfaceNode_ = nullptr;
1558 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, windowSceneSession->SnapshotIgnorePrivacy(pixelMap));
1559 }
1560
1561 /**
1562 * @tc.name: BindDialogTarget01
1563 * @tc.desc: BindDialogTarget
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F(WindowSceneSessionImplTest2, BindDialogTarget01, TestSize.Level1)
1567 {
1568 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1569 option->SetWindowName("BindDialogTarget01");
1570 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1571 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1572 sptr<IRemoteObject> targetToken;
1573 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->BindDialogTarget(targetToken));
1574 }
1575
1576 /**
1577 * @tc.name: BindDialogTarget02
1578 * @tc.desc: BindDialogTarget
1579 * @tc.type: FUNC
1580 */
1581 HWTEST_F(WindowSceneSessionImplTest2, BindDialogTarget02, TestSize.Level1)
1582 {
1583 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1584 option->SetWindowName("BindDialogTarget01");
1585 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1586 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1587
1588 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestMode", "CreateTestAbility" };
1589 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1590 windowSceneSession->property_->SetPersistentId(1);
1591 windowSceneSession->hostSession_ = session;
1592 sptr<IRemoteObject> targetToken;
1593 WMError ret = windowSceneSession->BindDialogTarget(targetToken);
1594 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1595 }
1596
1597 /**
1598 * @tc.name: SetDialogBackGestureEnabled01
1599 * @tc.desc: SetDialogBackGestureEnabled
1600 * @tc.type: FUNC
1601 */
1602 HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled01, TestSize.Level1)
1603 {
1604 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1605 option->SetWindowName("SetDialogBackGestureEnabled01");
1606 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1607 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1608 WMError ret = windowSceneSession->SetDialogBackGestureEnabled(true);
1609 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
1610 }
1611
1612 /**
1613 * @tc.name: SetDialogBackGestureEnabled02
1614 * @tc.desc: SetDialogBackGestureEnabled
1615 * @tc.type: FUNC
1616 */
1617 HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled02, TestSize.Level1)
1618 {
1619 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1620 option->SetWindowName("SetDialogBackGestureEnabled02");
1621 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1622 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1623 WMError ret = windowSceneSession->SetDialogBackGestureEnabled(true);
1624 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
1625 }
1626
1627 /**
1628 * @tc.name: SetDialogBackGestureEnabled03
1629 * @tc.desc: SetDialogBackGestureEnabled
1630 * @tc.type: FUNC
1631 */
1632 HWTEST_F(WindowSceneSessionImplTest2, SetDialogBackGestureEnabled03, TestSize.Level1)
1633 {
1634 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1635 option->SetWindowName("SetDialogBackGestureEnabled02");
1636 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1637 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1638
1639 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1640 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1641 windowSceneSession->hostSession_ = session;
1642 windowSceneSession->property_->SetPersistentId(1);
1643 WMError ret = windowSceneSession->SetDialogBackGestureEnabled(true);
1644 ASSERT_EQ(ret, WMError::WM_OK);
1645 }
1646
1647 /**
1648 * @tc.name: NotifySessionForeground
1649 * @tc.desc: NotifySessionForeground
1650 * @tc.type: FUNC
1651 */
1652 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionForeground, TestSize.Level1)
1653 {
1654 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1655 option->SetWindowName("NotifySessionForeground");
1656 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1657 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1658 ASSERT_NE(nullptr, windowSceneSession);
1659
1660 uint32_t reason = 1;
1661 bool withAnimation = true;
1662 windowSceneSession->NotifySessionForeground(reason, withAnimation);
1663 ASSERT_EQ(false, windowSceneSession->GetDefaultDensityEnabled());
1664 }
1665
1666 /**
1667 * @tc.name: NotifySessionBackground
1668 * @tc.desc: NotifySessionBackground
1669 * @tc.type: FUNC
1670 */
1671 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionBackground, TestSize.Level1)
1672 {
1673 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1674 option->SetWindowName("NotifySessionBackground");
1675 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1676 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1677 ASSERT_NE(nullptr, windowSceneSession);
1678
1679 uint32_t reason = 1;
1680 bool withAnimation = true;
1681 bool isFromInnerkits = true;
1682 windowSceneSession->NotifySessionBackground(reason, withAnimation, isFromInnerkits);
1683 ASSERT_EQ(false, windowSceneSession->GetDefaultDensityEnabled());
1684 }
1685
1686 /**
1687 * @tc.name: NotifySessionFullScreen
1688 * @tc.desc: NotifySessionFullScreen
1689 * @tc.type: FUNC
1690 */
1691 HWTEST_F(WindowSceneSessionImplTest2, NotifySessionFullScreen, TestSize.Level1)
1692 {
1693 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1694 option->SetWindowName("NotifySessionFullScreen");
1695 option->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1696 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1697 ASSERT_NE(nullptr, windowSceneSession);
1698
1699 bool fullScreen = true;
1700 windowSceneSession->NotifySessionFullScreen(fullScreen);
1701 }
1702
1703 /**
1704 * @tc.name: NotifyPrepareClosePiPWindow01
1705 * @tc.desc: NotifyPrepareClosePiPWindow
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(WindowSceneSessionImplTest2, NotifyPrepareClosePiPWindow01, TestSize.Level1)
1709 {
1710 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1711 option->SetWindowName("NotifyPrepareClosePiPWindow01");
1712 option->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1713 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1714 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1715 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1716 windowSceneSession->hostSession_ = session;
1717 ASSERT_EQ(WMError::WM_OK, windowSceneSession->NotifyPrepareClosePiPWindow());
1718 }
1719
1720 /**
1721 * @tc.name: SetDefaultDensityEnabled01
1722 * @tc.desc: normal test
1723 * @tc.type: FUNC
1724 */
1725 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled01, TestSize.Level1)
1726 {
1727 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1728 option->SetWindowName("SetDefaultDensityEnabled01");
1729 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1730 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1731
1732 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1733 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1734 window->property_->SetPersistentId(1);
1735 window->hostSession_ = session;
1736 window->state_ = WindowState::STATE_SHOWN;
1737 window->property_->SetDisplayId(0);
1738
1739 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
1740 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1741 ASSERT_EQ(WMError::WM_OK, window->SetDefaultDensityEnabled(true));
1742 ASSERT_EQ(true, window->GetDefaultDensityEnabled());
1743 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1744 }
1745
1746 /**
1747 * @tc.name: SetDefaultDensityEnabled02
1748 * @tc.desc: window session is invalid
1749 * @tc.type: FUNC
1750 */
1751 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled02, TestSize.Level1)
1752 {
1753 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1754 option->SetWindowName("SetDefaultDensityEnabled02");
1755 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1756 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1757 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1758 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1759 window->property_->SetPersistentId(1);
1760 window->state_ = WindowState::STATE_SHOWN;
1761 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetDefaultDensityEnabled(true));
1762 }
1763
1764 /**
1765 * @tc.name: SetDefaultDensityEnabled03
1766 * @tc.desc: not app main window
1767 * @tc.type: FUNC
1768 */
1769 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled03, TestSize.Level1)
1770 {
1771 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1772 option->SetWindowName("SetDefaultDensityEnabled03");
1773 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1774 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1775 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1776 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1777 window->property_->SetPersistentId(1);
1778 window->hostSession_ = session;
1779 window->state_ = WindowState::STATE_SHOWN;
1780 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetDefaultDensityEnabled(true));
1781 }
1782
1783 /**
1784 * @tc.name: SetDefaultDensityEnabled04
1785 * @tc.desc: isDefaultDensityEnabled_ not change
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabled04, TestSize.Level1)
1789 {
1790 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1791 option->SetWindowName("SetDefaultDensityEnabled04");
1792 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1793 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1794 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1795 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1796 window->property_->SetPersistentId(1);
1797 window->hostSession_ = session;
1798 window->state_ = WindowState::STATE_SHOWN;
1799 ASSERT_EQ(WMError::WM_OK, window->SetDefaultDensityEnabled(true));
1800 ASSERT_EQ(WMError::WM_OK, window->SetDefaultDensityEnabled(true));
1801 }
1802
1803 /**
1804 * @tc.name: GetDefaultDensityEnabled01
1805 * @tc.desc: normal test
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled01, TestSize.Level1)
1809 {
1810 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1811 option->SetWindowName("GetDefaultDensityEnabled01");
1812 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1813 window->isDefaultDensityEnabled_ = true;
1814 ASSERT_EQ(true, window->GetDefaultDensityEnabled());
1815 }
1816
1817 /**
1818 * @tc.name: GetDefaultDensityEnabled02
1819 * @tc.desc: test default value
1820 * @tc.type: FUNC
1821 */
1822 HWTEST_F(WindowSceneSessionImplTest2, GetDefaultDensityEnabled02, TestSize.Level1)
1823 {
1824 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1825 option->SetWindowName("GetDefaultDensityEnabled02");
1826 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1827 ASSERT_EQ(true, window->GetDefaultDensityEnabled());
1828 }
1829
1830 /**
1831 * @tc.name: SetWindowDefaultDensityEnabled01
1832 * @tc.desc: SetWindowDefaultDensityEnabled
1833 * @tc.type: FUNC
1834 */
1835 HWTEST_F(WindowSceneSessionImplTest2, SetWindowDefaultDensityEnabled01, TestSize.Level1)
1836 {
1837 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1838 option->SetWindowName("SetWindowDefaultDensityEnabled");
1839 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1840 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1841
1842 auto res = window->SetWindowDefaultDensityEnabled(true);
1843 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, res);
1844
1845 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1846 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1847 window->property_->SetPersistentId(1);
1848 window->hostSession_ = session;
1849 window->state_ = WindowState::STATE_SHOWN;
1850 res = window->SetWindowDefaultDensityEnabled(true);
1851 EXPECT_EQ(WMError::WM_OK, res);
1852 }
1853
1854 /**
1855 * @tc.name: SetDefaultDensityEnabledValue01
1856 * @tc.desc: SetDefaultDensityEnabledValue
1857 * @tc.type: FUNC
1858 */
1859 HWTEST_F(WindowSceneSessionImplTest2, SetDefaultDensityEnabledValue01, TestSize.Level1)
1860 {
1861 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1862 option->SetWindowName("SetDefaultDensityEnabledValue");
1863 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1864 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1865
1866 window->SetDefaultDensityEnabledValue(true);
1867 EXPECT_EQ(true, window->GetDefaultDensityEnabled());
1868
1869 window->SetDefaultDensityEnabledValue(false);
1870 EXPECT_EQ(false, window->GetDefaultDensityEnabled());
1871 }
1872
1873 /**
1874 * @tc.name: GetVirtualPixelRatio01
1875 * @tc.desc: main window isDefaultDensityEnabled_ true
1876 * @tc.type: FUNC
1877 */
1878 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio01, TestSize.Level1)
1879 {
1880 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1881 option->SetWindowName("GetVirtualPixelRatio01");
1882 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1883 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1884
1885 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1886 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1887 window->property_->SetPersistentId(1);
1888 window->hostSession_ = session;
1889 window->state_ = WindowState::STATE_SHOWN;
1890 window->property_->SetDisplayId(0);
1891
1892 window->isDefaultDensityEnabled_ = true;
1893 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1894 auto defautDensity = 1.0f;
1895 auto density = 2.0f;
1896 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1897 displayInfo->SetVirtualPixelRatio(density);
1898 ASSERT_EQ(defautDensity, window->GetVirtualPixelRatio(displayInfo));
1899 }
1900
1901 /**
1902 * @tc.name: GetVirtualPixelRatio02
1903 * @tc.desc: main window isDefaultDensityEnabled_ false
1904 * @tc.type: FUNC
1905 */
1906 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio02, TestSize.Level1)
1907 {
1908 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1909 option->SetWindowName("GetVirtualPixelRatio02");
1910 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1911 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1912
1913 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1914 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1915 window->property_->SetPersistentId(1);
1916 window->hostSession_ = session;
1917 window->state_ = WindowState::STATE_SHOWN;
1918 window->property_->SetDisplayId(0);
1919
1920 window->isDefaultDensityEnabled_ = false;
1921 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1922 auto defautDensity = 1.0f;
1923 auto density = 2.0f;
1924 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1925 displayInfo->SetVirtualPixelRatio(density);
1926 ASSERT_EQ(density, window->GetVirtualPixelRatio(displayInfo));
1927
1928 window->useUniqueDensity_ = true;
1929 ASSERT_EQ(window->virtualPixelRatio_, window->GetVirtualPixelRatio(displayInfo));
1930 }
1931
1932 /**
1933 * @tc.name: GetVirtualPixelRatio03
1934 * @tc.desc: sub window isDefaultDensityEnabled_ true
1935 * @tc.type: FUNC
1936 */
1937 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio03, TestSize.Level1)
1938 {
1939 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1940 option->SetWindowName("GetVirtualPixelRatio03");
1941 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1942 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1943
1944 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1945 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1946 window->property_->SetPersistentId(1);
1947 window->hostSession_ = session;
1948 window->state_ = WindowState::STATE_SHOWN;
1949 window->property_->SetDisplayId(0);
1950
1951 window->isDefaultDensityEnabled_ = true;
1952 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1953 auto defautDensity = 1.0f;
1954 auto density = 2.0f;
1955 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1956 displayInfo->SetVirtualPixelRatio(density);
1957
1958 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1959 subOption->SetWindowName("GetVirtualPixelRatio03SubWindow");
1960 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1961 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
1962 subWindow->property_->SetParentPersistentId(window->GetWindowId());
1963
1964 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
1965 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
1966 ASSERT_EQ(defautDensity, subWindow->GetVirtualPixelRatio(displayInfo));
1967 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
1968 }
1969
1970 /**
1971 * @tc.name: GetVirtualPixelRatio04
1972 * @tc.desc: sub window isDefaultDensityEnabled_ false
1973 * @tc.type: FUNC
1974 */
1975 HWTEST_F(WindowSceneSessionImplTest2, GetVirtualPixelRatio04, TestSize.Level1)
1976 {
1977 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1978 option->SetWindowName("GetVirtualPixelRatio04");
1979 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1980 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1981
1982 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1983 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1984 window->property_->SetPersistentId(1);
1985 window->hostSession_ = session;
1986 window->state_ = WindowState::STATE_SHOWN;
1987 window->property_->SetDisplayId(0);
1988
1989 window->isDefaultDensityEnabled_ = false;
1990 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
1991 auto defautDensity = 1.0f;
1992 auto density = 2.0f;
1993 displayInfo->SetDefaultVirtualPixelRatio(defautDensity);
1994 displayInfo->SetVirtualPixelRatio(density);
1995
1996 sptr<WindowOption> subOption = sptr<WindowOption>::MakeSptr();
1997 subOption->SetWindowName("GetVirtualPixelRatio04SubWindow");
1998 subOption->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1999 sptr<WindowSceneSessionImpl> subWindow = sptr<WindowSceneSessionImpl>::MakeSptr(subOption);
2000 subWindow->property_->SetParentPersistentId(window->GetWindowId());
2001
2002 WindowSceneSessionImpl::windowSessionMap_.insert(std::make_pair(
2003 window->GetWindowName(), std::pair<uint64_t, sptr<WindowSessionImpl>>(window->GetWindowId(), window)));
2004 ASSERT_EQ(defautDensity, subWindow->GetVirtualPixelRatio(displayInfo));
2005 WindowSceneSessionImpl::windowSessionMap_.erase(window->GetWindowName());
2006 }
2007
2008 /**
2009 * @tc.name: GetWindowLimits01
2010 * @tc.desc: GetWindowLimits
2011 * @tc.type: FUNC
2012 */
2013 HWTEST_F(WindowSceneSessionImplTest2, GetWindowLimits01, TestSize.Level1)
2014 {
2015 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2016 option->SetWindowName("GetWindowLimits01");
2017 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2018 WindowLimits windowLimits = { 1000, 1000, 1000, 1000, 0.0f, 0.0f };
2019 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2020 window->property_->SetWindowLimits(windowLimits);
2021 window->property_->SetPersistentId(1);
2022 window->state_ = WindowState::STATE_HIDDEN;
2023 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2024 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2025 window->hostSession_ = session;
2026
2027 WindowLimits windowSizeLimits;
2028 ASSERT_EQ(WMError::WM_OK, window->GetWindowLimits(windowSizeLimits));
2029 ASSERT_EQ(windowSizeLimits.maxWidth_, 1000);
2030 ASSERT_EQ(windowSizeLimits.maxHeight_, 1000);
2031 ASSERT_EQ(windowSizeLimits.minWidth_, 1000);
2032 ASSERT_EQ(windowSizeLimits.minHeight_, 1000);
2033 }
2034
2035 /**
2036 * @tc.name: AdjustKeyboardLayout01
2037 * @tc.desc: adjust keyboard layout
2038 * @tc.type: FUNC
2039 */
2040 HWTEST_F(WindowSceneSessionImplTest2, AdjustKeyboardLayout01, TestSize.Level1)
2041 {
2042 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2043 option->SetWindowName("AdjustKeyboardLayout01");
2044 option->SetDisplayId(0);
2045 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2046 window->property_->SetPersistentId(123);
2047 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2048 window->state_ = WindowState::STATE_FROZEN;
2049 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2050 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2051 window->hostSession_ = session;
2052
2053 KeyboardLayoutParams params;
2054 params.gravity_ = WindowGravity::WINDOW_GRAVITY_FLOAT;
2055 params.LandscapeKeyboardRect_ = { 1, 2, 3, 4 };
2056 params.PortraitKeyboardRect_ = { 1, 2, 3, 4 };
2057 params.LandscapePanelRect_ = { 1, 2, 3, 4 };
2058 params.PortraitPanelRect_ = { 1, 2, 3, 4 };
2059 ASSERT_EQ(WMError::WM_OK, window->AdjustKeyboardLayout(params));
2060 }
2061
2062 /**
2063 * @tc.name: HideNonSecureWindows01
2064 * @tc.desc: HideNonSecureWindows
2065 * @tc.type: FUNC
2066 */
2067 HWTEST_F(WindowSceneSessionImplTest2, HideNonSecureWindows01, TestSize.Level1)
2068 {
2069 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2070 option->SetWindowName("HideNonSecureWindows01");
2071 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2072 ASSERT_EQ(WMError::WM_OK, window->HideNonSecureWindows(true));
2073 }
2074
2075 /**
2076 * @tc.name: SetGrayScale01
2077 * @tc.desc: SetGrayScale
2078 * @tc.type: FUNC
2079 */
2080 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale01, TestSize.Level1)
2081 {
2082 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2083 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
2084 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2085 constexpr float grayScale = 0.5f;
2086 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGrayScale(grayScale));
2087 }
2088
2089 /**
2090 * @tc.name: SetGrayScale02
2091 * @tc.desc: SetGrayScale
2092 * @tc.type: FUNC
2093 */
2094 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale02, TestSize.Level1)
2095 {
2096 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2097 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2098
2099 window->state_ = WindowState::STATE_SHOWN;
2100 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2101 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2102 window->property_->SetPersistentId(1);
2103 window->hostSession_ = session;
2104 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2105
2106 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
2107 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
2108 WindowType::SYSTEM_WINDOW_BASE };
2109 for (WindowType type : types) {
2110 window->SetWindowType(type);
2111 float grayScale = -0.001f;
2112 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGrayScale(grayScale));
2113 grayScale = 1.001f;
2114 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGrayScale(grayScale));
2115 }
2116 }
2117
2118 /**
2119 * @tc.name: SetGrayScale03
2120 * @tc.desc: SetGrayScale
2121 * @tc.type: FUNC
2122 */
2123 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale03, TestSize.Level1)
2124 {
2125 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2126 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2127 window->state_ = WindowState::STATE_SHOWN;
2128 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2129 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2130 window->property_->SetPersistentId(1);
2131 window->hostSession_ = session;
2132 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetGrayScale(0.5));
2133 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2134 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
2135 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
2136 WindowType::SYSTEM_WINDOW_BASE };
2137 for (WindowType type : types) {
2138 window->SetWindowType(type);
2139 float grayScale = 0.0f;
2140 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
2141 grayScale = 1.0f;
2142 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
2143 grayScale = 0.5f;
2144 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
2145 }
2146 }
2147
2148 /**
2149 * @tc.name: SetGrayScale04
2150 * @tc.desc: Infinite non-circulating decimals
2151 * @tc.type: FUNC
2152 */
2153 HWTEST_F(WindowSceneSessionImplTest2, SetGrayScale04, TestSize.Level1)
2154 {
2155 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2156 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2157 window->state_ = WindowState::STATE_SHOWN;
2158 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2159 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2160 window->property_->SetPersistentId(1);
2161 window->hostSession_ = session;
2162 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetGrayScale(0.5));
2163 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2164 std::vector<WindowType> types = { WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
2165 WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
2166 WindowType::SYSTEM_WINDOW_BASE };
2167 for (WindowType type : types) {
2168 window->SetWindowType(type);
2169 float grayScale = 1.0f / 3.0f;
2170 ASSERT_EQ(WMError::WM_OK, window->SetGrayScale(grayScale));
2171 }
2172 }
2173
2174 /**
2175 * @tc.name: Maximize02
2176 * @tc.desc: test errorCode
2177 * @tc.type: FUNC
2178 */
2179 HWTEST_F(WindowSceneSessionImplTest2, Maximize02, TestSize.Level1)
2180 {
2181 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2182 option->SetWindowName("Maximize02");
2183 option->SetDisplayId(0);
2184
2185 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2186 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
2187 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Maximize(presentation));
2188
2189 window->property_->SetWindowName("Maximize02");
2190 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
2191 window->property_->SetPersistentId(2);
2192
2193 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2194 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2195 window->hostSession_ = session;
2196 // not support subWinodw call
2197 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->Maximize(presentation));
2198
2199 // window not support fullscreen
2200 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2201 window->property_->SetWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_PIP);
2202 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Maximize(presentation));
2203 }
2204
2205 /**
2206 * @tc.name: Maximize03
2207 * @tc.desc: test presentation
2208 * @tc.type: FUNC
2209 */
2210 HWTEST_F(WindowSceneSessionImplTest2, Maximize03, TestSize.Level1)
2211 {
2212 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2213 option->SetWindowName("Maximize03");
2214 option->SetDisplayId(0);
2215
2216 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2217 window->property_->SetWindowName("Maximize03");
2218 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2219 window->property_->SetPersistentId(2);
2220
2221 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2222 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2223 window->hostSession_ = session;
2224
2225 // case1: only set maximize()
2226 MaximizePresentation presentation = MaximizePresentation::ENTER_IMMERSIVE;
2227 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2228 auto ret = window->Maximize(presentation);
2229 ASSERT_EQ(WMError::WM_OK, ret);
2230 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2231 ret = window->Maximize(presentation);
2232 ASSERT_EQ(WMError::WM_OK, ret);
2233 ASSERT_EQ(window->GetImmersiveModeEnabledState(), true);
2234
2235 // case2: maximize(EXIT_IMMERSIVE) and the immersive value will be set ad false
2236 presentation = MaximizePresentation::EXIT_IMMERSIVE;
2237 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2238 ret = window->Maximize(presentation);
2239 ASSERT_EQ(WMError::WM_OK, ret);
2240 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2241 ret = window->Maximize(presentation);
2242 ASSERT_EQ(WMError::WM_OK, ret);
2243 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
2244
2245 // case3: maximize(FOLLOW_APP_IMMERSIVE_SETTING) and the immersive value will be set as client set
2246 presentation = MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING;
2247 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2248 ret = window->Maximize(presentation);
2249 ASSERT_EQ(WMError::WM_OK, ret);
2250 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2251 ret = window->Maximize(presentation);
2252 ASSERT_EQ(WMError::WM_OK, ret);
2253 ASSERT_EQ(window->GetImmersiveModeEnabledState(), false);
2254
2255 // case4: maximize(ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER) and the immersive value will be set as true
2256 presentation = MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER;
2257 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2258 ret = window->Maximize(presentation);
2259 ASSERT_EQ(WMError::WM_OK, ret);
2260 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2261 ret = window->Maximize(presentation);
2262 ASSERT_EQ(WMError::WM_OK, ret);
2263 ASSERT_EQ(window->GetImmersiveModeEnabledState(), true);
2264 }
2265
2266 /**
2267 * @tc.name: Test01
2268 * @tc.desc: Test01
2269 * @tc.type: FUNC
2270 */
2271 HWTEST_F(WindowSceneSessionImplTest2, Test01, TestSize.Level1)
2272 {
2273 WindowLimits windowLimits = { 3, 3, 3, 3, 2.0, 2.0 };
2274 ASSERT_EQ(windowLimits.IsEmpty(), false);
2275 Rect rect = { 2, 2, 2, 2 };
2276 Rect rect1 = { 2, 2, 2, 2 };
2277 ASSERT_EQ(rect.IsInsideOf(rect1), true);
2278 TitleButtonRect titleButtonRect = { 3, 3, 3, 3 };
2279 TitleButtonRect titleButtonRect1 = { 3, 3, 3, 3 };
2280 ASSERT_EQ(titleButtonRect.IsUninitializedRect(), false);
2281 ASSERT_EQ(titleButtonRect.IsInsideOf(titleButtonRect1), true);
2282 AvoidArea avoidArea;
2283 AvoidArea avoidArea1;
2284 ASSERT_EQ((avoidArea != avoidArea1), false);
2285 }
2286
2287 /**
2288 * @tc.name: GetTitleButtonVisible01
2289 * @tc.desc: GetTitleButtonVisible
2290 * @tc.type: FUNC
2291 */
2292 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible01, TestSize.Level1)
2293 {
2294 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2295 option->SetWindowName("GetTitleButtonVisible01");
2296 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2297 uint32_t windowModeSupportType = 1 | (1 << 1) | (1 << 2);
2298 window->property_->SetWindowModeSupportType(windowModeSupportType);
2299 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2300 // show Maximize, Minimize, Split buttons.
2301 window->windowTitleVisibleFlags_ = { false, false, false, false };
2302 bool hideMaximizeButton = false;
2303 bool hideMinimizeButton = false;
2304 bool hideSplitButton = false;
2305 bool hideCloseButton = false;
2306 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2307 window->GetTitleButtonVisible(hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
2308 ASSERT_EQ(hideMaximizeButton, true);
2309 ASSERT_EQ(hideMinimizeButton, true);
2310 ASSERT_EQ(hideSplitButton, true);
2311 ASSERT_EQ(hideCloseButton, true);
2312 }
2313
2314 /**
2315 * @tc.name: GetTitleButtonVisible02
2316 * @tc.desc: GetTitleButtonVisible
2317 * @tc.type: FUNC
2318 */
2319 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible02, TestSize.Level1)
2320 {
2321 g_errLog.clear();
2322 LOG_SetCallback(MyLogCallback);
2323 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2324 option->SetWindowName("GetTitleButtonVisible02");
2325 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2326 // only not support WINDOW_MODE_SUPPORT_SPLIT
2327 uint32_t windowModeSupportType = 1 | (1 << 1);
2328 window->property_->SetWindowModeSupportType(windowModeSupportType);
2329 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2330 // show Maximize, Minimize, Split buttons.
2331 window->windowTitleVisibleFlags_ = { true, true, true, true };
2332 bool hideMaximizeButton = false;
2333 bool hideMinimizeButton = false;
2334 bool hideSplitButton = false;
2335 bool hideCloseButton = false;
2336 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2337 window->GetTitleButtonVisible(hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
2338 EXPECT_FALSE(g_errLog.find("device not support") != std::string::npos);
2339 LOG_SetCallback(nullptr);
2340 }
2341
2342 /**
2343 * @tc.name: GetTitleButtonVisible03
2344 * @tc.desc: GetTitleButtonVisible
2345 * @tc.type: FUNC
2346 */
2347 HWTEST_F(WindowSceneSessionImplTest2, GetTitleButtonVisible03, TestSize.Level1)
2348 {
2349 g_errLog.clear();
2350 LOG_SetCallback(MyLogCallback);
2351 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2352 option->SetWindowName("GetTitleButtonVisible03");
2353 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2354 // only not support WINDOW_MODE_SUPPORT_SPLIT
2355 uint32_t windowModeSupportType = 1 | (1 << 1) | (1 << 2);
2356 window->property_->SetWindowModeSupportType(windowModeSupportType);
2357 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2358 // show Maximize, Minimize, Split buttons.
2359 window->windowTitleVisibleFlags_ = { false, false, false, false };
2360 bool hideMaximizeButton = true;
2361 bool hideMinimizeButton = true;
2362 bool hideSplitButton = true;
2363 bool hideCloseButton = true;
2364 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2365 window->GetTitleButtonVisible(hideMaximizeButton, hideMinimizeButton, hideSplitButton, hideCloseButton);
2366 EXPECT_TRUE(g_errLog.find("device not support") != std::string::npos);
2367 LOG_SetCallback(nullptr);
2368 }
2369
2370 /**
2371 * @tc.name: SetTitleButtonVisible01
2372 * @tc.desc: SetTitleButtonVisible
2373 * @tc.type: FUNC
2374 */
2375 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible01, TestSize.Level1)
2376 {
2377 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2378 option->SetWindowName("SetTitleButtonVisible");
2379 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2380 ASSERT_NE(window, nullptr);
2381 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
2382 window->SetTitleButtonVisible(false, false, false, true);
2383 }
2384
2385 /**
2386 * @tc.name: SetTitleButtonVisible02
2387 * @tc.desc: SetTitleButtonVisible
2388 * @tc.type: FUNC
2389 */
2390 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible02, TestSize.Level1)
2391 {
2392 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2393 option->SetWindowName("SetTitleButtonVisible");
2394 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2395 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
2396 WMError res = window->SetTitleButtonVisible(false, false, false, true);
2397 ASSERT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2398 }
2399
2400 /**
2401 * @tc.name: SetTitleButtonVisible03
2402 * @tc.desc: SetTitleButtonVisible
2403 * @tc.type: FUNC
2404 */
2405 HWTEST_F(WindowSceneSessionImplTest2, SetTitleButtonVisible03, TestSize.Level1)
2406 {
2407 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2408 option->SetWindowName("SetTitleButtonVisible");
2409 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2410 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2411 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2412 window->hostSession_ = session;
2413 window->property_->SetPersistentId(1);
2414 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
2415 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2416 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2417 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
2418 window->windowSystemConfig_.isSystemDecorEnable_ = false;
2419 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2420 WMError res = window->SetTitleButtonVisible(false, false, false, true);
2421 ASSERT_EQ(res, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
2422 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2423 res = window->SetTitleButtonVisible(false, false, false, true);
2424 ASSERT_EQ(res, WMError::WM_ERROR_INVALID_WINDOW);
2425 window->windowSystemConfig_.isSystemDecorEnable_ = true;
2426 res = window->SetTitleButtonVisible(false, false, false, true);
2427 ASSERT_EQ(res, WMError::WM_OK);
2428 }
2429
2430 /**
2431 * @tc.name: IsWindowRectAutoSave
2432 * @tc.desc: IsWindowRectAutoSave
2433 * @tc.type: FUNC
2434 */
2435 HWTEST_F(WindowSceneSessionImplTest2, IsWindowRectAutoSave, TestSize.Level1)
2436 {
2437 GTEST_LOG_(INFO) << "WindowSceneSessionImplTest2: IsWindowRectAutoSave start";
2438 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2439 option->SetWindowName("IsWindowRectAutoSave");
2440 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2441 bool enabled = false;
2442 auto ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2443 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
2444 enabled = true;
2445 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2446 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
2447 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2448 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2449 windowSceneSessionImpl->property_->SetPersistentId(1);
2450 windowSceneSessionImpl->hostSession_ = session;
2451 windowSceneSessionImpl->context_ = abilityContext_;
2452 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2453 EXPECT_CALL(m->Mock(), IsWindowRectAutoSave(_, _, _)).WillRepeatedly(Return(WMError::WM_OK));
2454 enabled = false;
2455 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2456 EXPECT_EQ(WMError::WM_OK, ret);
2457 enabled = true;
2458 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2459 EXPECT_EQ(WMError::WM_OK, ret);
2460 windowSceneSessionImpl->context_ = nullptr;
2461 enabled = false;
2462 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2463 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2464 enabled = true;
2465 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2466 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
2467 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
2468 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2469 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
2470 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
2471 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2472 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
2473 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2474 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2475 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, ret);
2476 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
2477 windowSceneSessionImpl->property_->SetPcAppInpadCompatibleMode(true);
2478 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2479 EXPECT_EQ(WMError::WM_OK, ret);
2480 GTEST_LOG_(INFO) << "WindowSceneSessionImplTest2: IsWindowRectAutoSave end";
2481 }
2482
2483 /**
2484 * @tc.name: IsWindowRectAutoSave
2485 * @tc.desc: IsWindowRectAutoSave
2486 * @tc.type: FUNC
2487 */
2488 HWTEST_F(WindowSceneSessionImplTest2, IsWindowRectAutoSave002, TestSize.Level1)
2489 {
2490 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2491 option->SetWindowName("IsWindowRectAutoSave002");
2492 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2493 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2494 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2495 windowSceneSessionImpl->property_->SetPersistentId(1);
2496 windowSceneSessionImpl->hostSession_ = session;
2497 windowSceneSessionImpl->context_ = abilityContext_;
2498 windowSceneSessionImpl->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2499 bool enabled = false;
2500 auto ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2501 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
2502
2503 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
2504 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2505 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
2506
2507 option->SetWindowName("IsWindowRectAutoSave002");
2508 windowSceneSessionImpl->state_ = WindowState::STATE_INITIAL;
2509 windowSceneSessionImpl->property_->SetPersistentId(1);
2510 ret = windowSceneSessionImpl->IsWindowRectAutoSave(enabled);
2511 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
2512 }
2513 }
2514 } // namespace
2515 } // namespace Rosen
2516 } // namespace OHOS