1 /*
2 * Copyright (c) 2023 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
19 #include "ability_context_impl.h"
20 #include "display_info.h"
21 #include "mock_session.h"
22 #include "mock_uicontent.h"
23 #include "mock_window_adapter.h"
24 #include "scene_board_judgement.h"
25 #include "session/host/include/scene_session.h"
26 #include "singleton_mocker.h"
27 #include "window_scene_session_impl.h"
28 #include "window_session_impl.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
36
37 class MockWindowChangeListener : public IWindowChangeListener {
38 public:
39 MOCK_METHOD3(OnSizeChange,
40 void(Rect rect, WindowSizeChangeReason reason, const std::shared_ptr<RSTransaction>& rsTransaction));
41 };
42
43 class MockWindowLifeCycleListener : public IWindowLifeCycle {
44 public:
45 MOCK_METHOD0(AfterForeground, void(void));
46 MOCK_METHOD0(AfterBackground, void(void));
47 MOCK_METHOD0(AfterFocused, void(void));
48 MOCK_METHOD0(AfterUnfocused, void(void));
49 MOCK_METHOD1(ForegroundFailed, void(int32_t));
50 MOCK_METHOD0(AfterActive, void(void));
51 MOCK_METHOD0(AfterInactive, void(void));
52 MOCK_METHOD0(AfterResumed, void(void));
53 MOCK_METHOD0(AfterPaused, void(void));
54 };
55
56 class WindowSceneSessionImplTest : public testing::Test {
57 public:
58 static void SetUpTestCase();
59 static void TearDownTestCase();
60 void SetUp() override;
61 void TearDown() override;
62
63 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
64 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
65
66 private:
67 RSSurfaceNode::SharedPtr CreateRSSurfaceNode();
68 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
69 };
70
SetUpTestCase()71 void WindowSceneSessionImplTest::SetUpTestCase() {}
72
TearDownTestCase()73 void WindowSceneSessionImplTest::TearDownTestCase() {}
74
SetUp()75 void WindowSceneSessionImplTest::SetUp()
76 {
77 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
78 }
79
TearDown()80 void WindowSceneSessionImplTest::TearDown()
81 {
82 usleep(WAIT_SYNC_IN_NS);
83 abilityContext_ = nullptr;
84 }
85
CreateRSSurfaceNode()86 RSSurfaceNode::SharedPtr WindowSceneSessionImplTest::CreateRSSurfaceNode()
87 {
88 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
89 rsSurfaceNodeConfig.SurfaceNodeName = "startingWindowTestSurfaceNode";
90 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
91 return surfaceNode;
92 }
93
CreateWindow(std::string windowName,WindowType type,int32_t id)94 static sptr<WindowSceneSessionImpl> CreateWindow(std::string windowName, WindowType type, int32_t id)
95 {
96 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
97 option->SetWindowName(windowName);
98 option->SetWindowType(type);
99 auto window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
100 window->property_->SetPersistentId(id);
101 return window;
102 }
103
104 namespace {
105 /**
106 * @tc.name: CreateWindowAndDestroy01
107 * @tc.desc: Create window and destroy window
108 * @tc.type: FUNC
109 */
110 HWTEST_F(WindowSceneSessionImplTest, CreateWindowAndDestroy01, Function | SmallTest | Level2)
111 {
112 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
113 option->SetWindowName("CreateWindowAndDestroy01");
114 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
115 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
116 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
117
118 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
119 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
120 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window->Create(abilityContext_, session));
121 window->property_->SetPersistentId(1);
122 ASSERT_EQ(WMError::WM_OK, window->Destroy(false));
123 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->Create(abilityContext_, session));
124 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(true));
125 }
126
127 /**
128 * @tc.name: CreateWindowAndDestroy02
129 * @tc.desc: Create window and destroy window
130 * @tc.type: FUNC
131 */
132 HWTEST_F(WindowSceneSessionImplTest, CreateWindowAndDestroy02, Function | SmallTest | Level2)
133 {
134 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
135 option->SetWindowName("CreateWindowAndDestroy02");
136 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
137 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
138 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
139 std::string identityToken = "testToken";
140 window->Create(abilityContext_, session);
141 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window->Create(abilityContext_, session, identityToken));
142 window->property_->SetPersistentId(1);
143 window->Destroy(false);
144 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->Create(abilityContext_, session, identityToken));
145 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
146 }
147
148 /**
149 * @tc.name: CreateAndConnectSpecificSession01
150 * @tc.desc: CreateAndConnectSpecificSession
151 * @tc.type: FUNC
152 */
153 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession01, Function | SmallTest | Level2)
154 {
155 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
156 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
157 }
158 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
159 option->SetWindowName("CreateAndConnectSpecificSession01");
160 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
161
162 windowSceneSession->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
163 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
164 windowSceneSession->property_->SetPersistentId(102);
165 windowSceneSession->property_->SetParentPersistentId(100);
166 windowSceneSession->property_->SetParentId(100);
167 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
168 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
169
170 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
171 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
172 }
173
174 /**
175 * @tc.name: CreateAndConnectSpecificSession02
176 * @tc.desc: CreateAndConnectSpecificSession
177 * @tc.type: FUNC
178 */
179 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession02, Function | SmallTest | Level2)
180 {
181 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
182 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
183 }
184 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
185 option->SetWindowTag(WindowTag::SUB_WINDOW);
186 option->SetWindowName("CreateAndConnectSpecificSession02");
187 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
188
189 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
190 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
191 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
192 windowSceneSession->property_->SetPersistentId(103);
193 windowSceneSession->property_->SetParentPersistentId(102);
194 windowSceneSession->property_->SetParentId(102);
195 windowSceneSession->hostSession_ = session;
196
197 windowSceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
198 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
199 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
200 }
201
202 /**
203 * @tc.name: CreateAndConnectSpecificSession03
204 * @tc.desc: CreateAndConnectSpecificSession
205 * @tc.type: FUNC
206 */
207 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession03, Function | SmallTest | Level2)
208 {
209 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
210 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
211 }
212 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
213 option->SetWindowTag(WindowTag::SUB_WINDOW);
214 option->SetWindowName("CreateAndConnectSpecificSession03");
215 option->SetIsUIExtFirstSubWindow(true);
216 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
217
218 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
219 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
220 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
221
222 windowSceneSession->property_->SetParentPersistentId(102);
223 windowSceneSession->property_->SetParentId(102);
224 windowSceneSession->hostSession_ = session;
225
226 windowSceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
227 ASSERT_EQ(WMError::WM_OK, windowSceneSession->CreateAndConnectSpecificSession());
228 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
229 }
230
231 /**
232 * @tc.name: CreateAndConnectSpecificSession04
233 * @tc.desc: CreateAndConnectSpecificSession
234 * @tc.type: FUNC
235 */
236 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession04, Function | SmallTest | Level2)
237 {
238 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
239 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
240 }
241 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
242 option->SetWindowTag(WindowTag::SUB_WINDOW);
243 option->SetWindowName("CreateAndConnectSpecificSession04");
244 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
245
246 SessionInfo sessionInfo = { "CreateTestBundle4", "CreateTestModule4", "CreateTestAbility4" };
247 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
248 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
249
250 windowSceneSession->property_->SetPersistentId(104);
251 windowSceneSession->property_->SetParentPersistentId(103);
252 windowSceneSession->property_->SetParentId(103);
253 windowSceneSession->property_->type_ = WindowType::APP_MAIN_WINDOW_BASE;
254 windowSceneSession->hostSession_ = session;
255
256 windowSceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
257 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
258 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
259 }
260
261 /**
262 * @tc.name: CreateAndConnectSpecificSession05
263 * @tc.desc: CreateAndConnectSpecificSession
264 * @tc.type: FUNC
265 */
266 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession05, Function | SmallTest | Level2)
267 {
268 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
269 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
270 }
271 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
272 option->SetWindowTag(WindowTag::SUB_WINDOW);
273 option->SetWindowName("CreateAndConnectSpecificSession05");
274 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
275
276 SessionInfo sessionInfo = { "CreateTestBundle5", "CreateTestModule5", "CreateTestAbility5" };
277 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
278 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
279
280 windowSceneSession->property_->SetParentPersistentId(104);
281 windowSceneSession->property_->SetParentId(104);
282 windowSceneSession->hostSession_ = session;
283
284 windowSceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
285 ASSERT_NE(WMError::WM_ERROR_INVALID_TYPE, windowSceneSession->CreateAndConnectSpecificSession());
286 ASSERT_NE(WMError::WM_OK, windowSceneSession->Destroy(true));
287 }
288
289 /**
290 * @tc.name: CreateAndConnectSpecificSession06
291 * @tc.desc: CreateAndConnectSpecificSession
292 * @tc.type: FUNC
293 */
294 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession06, Function | SmallTest | Level2)
295 {
296 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
297 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
298 }
299 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
300 option->SetWindowTag(WindowTag::SYSTEM_WINDOW);
301 option->SetWindowName("CreateAndConnectSpecificSession06");
302 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
303
304 SessionInfo sessionInfo = { "CreateTestBundle6", "CreateTestModule6", "CreateTestAbility6" };
305 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
306 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
307
308 windowSceneSession->property_->SetPersistentId(105);
309 windowSceneSession->property_->SetParentPersistentId(102);
310 windowSceneSession->property_->SetParentId(102);
311 windowSceneSession->hostSession_ = session;
312
313 windowSceneSession->property_->type_ = WindowType::SYSTEM_WINDOW_BASE;
314 ASSERT_EQ(WMError::WM_OK, windowSceneSession->CreateAndConnectSpecificSession());
315 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
316 }
317
318 /**
319 * @tc.name: CreateAndConnectSpecificSession07
320 * @tc.desc: CreateAndConnectSpecificSession
321 * @tc.type: FUNC
322 */
323 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession07, Function | SmallTest | Level2)
324 {
325 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
326 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
327 }
328 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
329 option->SetWindowTag(WindowTag::SYSTEM_WINDOW);
330 option->SetWindowName("CreateAndConnectSpecificSession07");
331 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
332
333 SessionInfo sessionInfo = { "CreateTestBundle7", "CreateTestModule7", "CreateTestAbility7" };
334 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
335 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
336
337 windowSceneSession->property_->SetPersistentId(106);
338 windowSceneSession->property_->SetParentPersistentId(105);
339 windowSceneSession->property_->SetParentId(105);
340 windowSceneSession->hostSession_ = session;
341
342 windowSceneSession->property_->type_ = WindowType::SYSTEM_SUB_WINDOW_BASE;
343 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
344 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
345 }
346
347 /**
348 * @tc.name: CreateAndConnectSpecificSession08
349 * @tc.desc: CreateAndConnectSpecificSession
350 * @tc.type: FUNC
351 */
352 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession08, Function | SmallTest | Level2)
353 {
354 constexpr int parentId = 10000;
355 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
356 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
357 option->SetWindowName("CreateAndConnectSpecificSession08");
358 option->SetParentId(parentId);
359
360 // scene session manager processing
361 option->SetIsUIExtFirstSubWindow(true);
362 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
363 windowSceneSession->Create(abilityContext_, nullptr);
364 ASSERT_EQ(windowSceneSession->property_->GetParentPersistentId(), option->GetParentId());
365 // scene session manager processing
366 option->SetIsUIExtFirstSubWindow(false);
367 option->SetIsUIExtAnySubWindow(true);
368 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
369 windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
370 ASSERT_NE(nullptr, windowSceneSession);
371 windowSceneSession->Create(abilityContext_, nullptr);
372 ASSERT_EQ(windowSceneSession->property_->GetParentPersistentId(), option->GetParentId());
373
374 sptr<WindowSceneSessionImpl> mainWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
375 windowSceneSession->property_->SetPersistentId(parentId);
376 // window processing
377 option->SetIsUIExtFirstSubWindow(false);
378 option->SetIsUIExtAnySubWindow(true);
379 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_IS_TOAST);
380 windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
381 windowSceneSession->windowSessionMap_["mainWindow"] = { parentId, mainWindow };
382 windowSceneSession->Create(abilityContext_, nullptr);
383 ASSERT_EQ(windowSceneSession->property_->GetDisplayId(), mainWindow->property_->GetDisplayId());
384 // window processing
385 option->SetIsUIExtAnySubWindow(false);
386 windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
387 windowSceneSession->windowSessionMap_["mainWindow"] = { parentId, mainWindow };
388 windowSceneSession->Create(abilityContext_, nullptr);
389 ASSERT_EQ(windowSceneSession->property_->GetDisplayId(), mainWindow->property_->GetDisplayId());
390 }
391
392 /**
393 * @tc.name: CreateAndConnectSpecificSession09
394 * @tc.desc: CreateAndConnectSpecificSession
395 * @tc.type: FUNC
396 */
397 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession09, Function | SmallTest | Level2)
398 {
399 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
400 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
401 }
402 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
403 option->SetWindowName("CreateAndConnectSpecificSession09");
404 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
405
406 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_WALLET_SWIPE_CARD);
407 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
408 windowSceneSession->property_->SetPersistentId(102);
409 windowSceneSession->property_->SetParentPersistentId(100);
410 windowSceneSession->property_->SetParentId(100);
411 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
412 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
413
414 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
415 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
416 }
417
418 /**
419 * @tc.name: CreateAndConnectSpecificSession10
420 * @tc.desc: CreateAndConnectSpecificSession
421 * @tc.type: FUNC
422 */
423 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession10, Function | SmallTest | Level2)
424 {
425 constexpr int parentId = 1000;
426 constexpr int displayId = 100;
427 sptr<WindowOption> parentOption = sptr<WindowOption>::MakeSptr();
428 parentOption->SetWindowTag(WindowTag::MAIN_WINDOW);
429 parentOption->SetWindowName("MainWindow");
430 parentOption->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
431 parentOption->SetDisplayId(displayId);
432 sptr<WindowSceneSessionImpl> parentWindow = sptr<WindowSceneSessionImpl>::MakeSptr(parentOption);
433 ASSERT_NE(nullptr, parentWindow);
434
435 parentWindow->property_->SetPersistentId(parentId);
436 SessionInfo sessionInfo = {"TextMenuTestBundle", "TextMenuTestModule", "TextMenuTestAbility"};
437 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
438 WMError error = parentWindow->Create(abilityContext_, session);
439 ASSERT_EQ(error, WMError::WM_OK);
440
441 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
442 ASSERT_NE(nullptr, option);
443 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
444 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_TEXT_MENU);
445 option->SetWindowName("TextMenu");
446 option->SetParentId(parentId);
447 sptr<WindowSceneSessionImpl> textMenuWindow = sptr<WindowSceneSessionImpl>::MakeSptr(option);
448 ASSERT_NE(nullptr, textMenuWindow);
449 error = textMenuWindow->Create(abilityContext_, nullptr);
450 ASSERT_EQ(error, WMError::WM_OK);
451 ASSERT_EQ(WMError::WM_OK, textMenuWindow->Destroy(true));
452 ASSERT_EQ(WMError::WM_OK, parentWindow->Destroy(true));
453 }
454
455 /**
456 * @tc.name: CreateAndConnectSpecificSession11
457 * @tc.desc: CreateAndConnectSpecificSession
458 * @tc.type: FUNC
459 */
460 HWTEST_F(WindowSceneSessionImplTest, CreateAndConnectSpecificSession11, Function | SmallTest | Level2)
461 {
462 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
463 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
464 }
465 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
466 option->SetWindowName("CreateAndConnectSpecificSession10");
467 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
468
469 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_NAVIGATION);
470 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->CreateAndConnectSpecificSession());
471 windowSceneSession->property_->SetPersistentId(102);
472 windowSceneSession->property_->SetParentPersistentId(100);
473 windowSceneSession->property_->SetParentId(100);
474 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
475 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
476
477 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
478 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Destroy(true));
479 }
480
481 /**
482 * @tc.name: RecoverAndReconnectSceneSession
483 * @tc.desc: RecoverAndReconnectSceneSession
484 * @tc.type: FUNC
485 */
486 HWTEST_F(WindowSceneSessionImplTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
487 {
488 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
489 option->SetWindowName("RecoverAndReconnectSceneSession");
490 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
491 ASSERT_NE(nullptr, windowSceneSession);
492 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->RecoverAndReconnectSceneSession());
493 }
494
495 /**
496 * @tc.name: IsValidSystemWindowType01
497 * @tc.desc: IsValidSystemWindowType
498 * @tc.type: FUNC
499 */
500 HWTEST_F(WindowSceneSessionImplTest, IsValidSystemWindowType01, Function | SmallTest | Level2)
501 {
502 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
503 option->SetWindowName("IsValidSystemWindowType01");
504 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
505 ASSERT_NE(nullptr, windowSceneSession);
506 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_SYSTEM_ALARM_WINDOW));
507 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT));
508 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA));
509 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_DIALOG));
510 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_FLOAT));
511 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_SCREENSHOT));
512 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH));
513 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_VOICE_INTERACTION));
514 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_POINTER));
515 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_TOAST));
516 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE));
517 ASSERT_TRUE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_APP_LAUNCHING));
518 }
519
520 /**
521 * @tc.name: InvalidWindow
522 * @tc.desc: InvalidWindow test
523 * @tc.type: FUNC
524 */
525 HWTEST_F(WindowSceneSessionImplTest, InvalidWindow, Function | SmallTest | Level3)
526 {
527 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
528 option->SetWindowName("InvalidWindow");
529 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
530 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveTo(0, 0));
531 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->Resize(0, 0));
532 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBackgroundColor(std::string("???")));
533 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(false));
534 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Show(2, false));
535 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(2, 2));
536 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Minimize());
537 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Maximize());
538 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MaximizeFloating());
539 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Recover());
540 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MaximizeFloating());
541 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGlobalMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR));
542 }
543
544 /**
545 * @tc.name: FindParentSessionByParentId01
546 * @tc.desc: FindParentSessionByParentId
547 * @tc.type: FUNC
548 */
549 HWTEST_F(WindowSceneSessionImplTest, FindParentSessionByParentId01, Function | SmallTest | Level2)
550 {
551 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
552 option->SetWindowTag(WindowTag::MAIN_WINDOW);
553 option->SetWindowName("FindParentSessionByParentId01");
554 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
555 ASSERT_NE(nullptr, windowSceneSession);
556
557 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
558 ASSERT_TRUE(windowSceneSession->FindMainWindowWithContext() == nullptr);
559 windowSceneSession->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_END);
560 ASSERT_TRUE(windowSceneSession->FindMainWindowWithContext() == nullptr);
561
562 windowSceneSession->property_->SetPersistentId(1112);
563 windowSceneSession->property_->SetParentId(1000);
564 windowSceneSession->property_->SetParentPersistentId(1000);
565 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
566 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
567 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
568 ASSERT_NE(nullptr, session);
569
570 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
571 windowSceneSession->hostSession_ = session;
572 ASSERT_TRUE(nullptr != windowSceneSession->FindParentSessionByParentId(1112));
573 windowSceneSession->Destroy(true);
574 }
575
576 /**
577 * @tc.name: DisableAppWindowDecor01
578 * @tc.desc: DisableAppWindowDecor
579 * @tc.type: FUNC
580 */
581 HWTEST_F(WindowSceneSessionImplTest, DisableAppWindowDecor01, Function | SmallTest | Level3)
582 {
583 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
584 option->SetWindowName("DisableAppWindowDecor01");
585 sptr<WindowSceneSessionImpl> windowSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
586 ASSERT_NE(nullptr, windowSession);
587
588 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
589 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
590
591 std::shared_ptr<AbilityRuntime::Context> context;
592 ASSERT_EQ(WMError::WM_OK, windowSession->Create(context, session));
593 windowSession->property_->SetPersistentId(1);
594
595 windowSession->UpdateDecorEnable(false);
596 windowSession->windowSystemConfig_.isSystemDecorEnable_ = false;
597
598 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
599 windowSession->DisableAppWindowDecor();
600 ASSERT_FALSE(windowSession->IsDecorEnable());
601 windowSession->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
602 windowSession->DisableAppWindowDecor();
603 windowSession->Destroy(true);
604 }
605
606 /**
607 * @tc.name: DisableAppWindowDecor02
608 * @tc.desc: DisableAppWindowDecor
609 * @tc.type: FUNC
610 */
611 HWTEST_F(WindowSceneSessionImplTest, DisableAppWindowDecor02, Function | SmallTest | Level3)
612 {
613 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
614 option->SetWindowName("DisableAppWindowDecor02");
615 sptr<WindowSceneSessionImpl> windowSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
616
617 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
618 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
619
620 std::shared_ptr<AbilityRuntime::Context> context;
621 ASSERT_EQ(WMError::WM_OK, windowSession->Create(context, session));
622 windowSession->property_->SetPersistentId(0);
623
624 windowSession->UpdateDecorEnable(false);
625 windowSession->windowSystemConfig_.isSystemDecorEnable_ = true;
626
627 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
628 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSession->DisableAppWindowDecor());
629 windowSession->Destroy(true);
630 }
631
632 /**
633 * @tc.name: DisableAppWindowDecor03
634 * @tc.desc: DisableAppWindowDecor
635 * @tc.type: FUNC
636 */
637 HWTEST_F(WindowSceneSessionImplTest, DisableAppWindowDecor03, Function | SmallTest | Level3)
638 {
639 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
640 option->SetWindowName("DisableAppWindowDecor03");
641 sptr<WindowSceneSessionImpl> windowSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
642
643 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
644 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
645
646 std::shared_ptr<AbilityRuntime::Context> context;
647 ASSERT_EQ(WMError::WM_OK, windowSession->Create(context, session));
648 windowSession->property_->SetPersistentId(1);
649
650 windowSession->UpdateDecorEnable(false);
651 windowSession->windowSystemConfig_.isSystemDecorEnable_ = true;
652
653 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
654 EXPECT_EQ(WMError::WM_ERROR_INVALID_OPERATION, windowSession->DisableAppWindowDecor());
655 windowSession->Destroy(true);
656 }
657
658 /**
659 * @tc.name: RaiseToAppTop01
660 * @tc.desc: RaiseToAppTop
661 * @tc.type: FUNC
662 */
663 HWTEST_F(WindowSceneSessionImplTest, RaiseToAppTop01, Function | SmallTest | Level2)
664 {
665 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
666 option->SetWindowName("RaiseToAppTop01");
667 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
668 ASSERT_NE(nullptr, windowSceneSession);
669
670 windowSceneSession->property_->SetPersistentId(6);
671 windowSceneSession->property_->SetParentPersistentId(6);
672 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
673 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->RaiseToAppTop());
674
675 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
676 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
677 windowSceneSession->hostSession_ = session;
678 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSession->RaiseToAppTop());
679
680 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
681 windowSceneSession->state_ = WindowState::STATE_HIDDEN;
682 ASSERT_EQ(WMError::WM_DO_NOTHING, windowSceneSession->RaiseToAppTop());
683
684 windowSceneSession->state_ = WindowState::STATE_SHOWN;
685 ASSERT_EQ(WMError::WM_OK, windowSceneSession->RaiseToAppTop());
686 }
687
688 /**
689 * @tc.name: GetGlobalScaledRect
690 * @tc.desc: GetGlobalScaledRect
691 * @tc.type: FUNC
692 */
693 HWTEST_F(WindowSceneSessionImplTest, GetGlobalScaledRect, Function | SmallTest | Level2)
694 {
695 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
696 option->SetWindowName("GetGlobalScaledRect");
697 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
698 Rect globalScaledRect;
699 windowSceneSession->property_->SetPersistentId(6);
700 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->GetGlobalScaledRect(globalScaledRect));
701
702 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
703 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
704 windowSceneSession->hostSession_ = session;
705 ASSERT_EQ(WMError::WM_OK, windowSceneSession->GetGlobalScaledRect(globalScaledRect));
706 }
707
708 /**
709 * @tc.name: Minimize01
710 * @tc.desc: Minimize
711 * @tc.type: FUNC
712 */
713 HWTEST_F(WindowSceneSessionImplTest, Minimize01, Function | SmallTest | Level2)
714 {
715 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
716 option->SetWindowName("Minimize01");
717 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
718
719 windowSceneSession->property_->SetPersistentId(1);
720 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
721 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
722 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
723
724 windowSceneSession->hostSession_ = session;
725 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Minimize());
726 }
727
728 /**
729 * @tc.name: Minimize02
730 * @tc.desc: Minimize
731 * @tc.type: FUNC
732 */
733 HWTEST_F(WindowSceneSessionImplTest, Minimize02, Function | SmallTest | Level2)
734 {
735 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
736 option->SetWindowName("Minimize02");
737 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
738 windowSceneSession->property_->SetPersistentId(0);
739 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->Minimize());
740 }
741
742 /**
743 * @tc.name: Minimize03
744 * @tc.desc: Minimize
745 * @tc.type: FUNC
746 */
747 HWTEST_F(WindowSceneSessionImplTest, Minimize03, Function | SmallTest | Level2)
748 {
749 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
750 option->SetWindowName("Minimize03");
751 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
752
753 windowSceneSession->property_->SetPersistentId(1);
754 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
755 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
756 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
757
758 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->Minimize());
759 }
760
761 /**
762 * @tc.name: Minimize04
763 * @tc.desc: Minimize
764 * @tc.type: FUNC
765 */
766 HWTEST_F(WindowSceneSessionImplTest, Minimize04, Function | SmallTest | Level2)
767 {
768 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
769 option->SetWindowName("Minimize04");
770 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
771
772 windowSceneSession->property_->SetPersistentId(1);
773 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
774 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
775 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
776 windowSceneSession->hostSession_ = session;
777 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
778 ASSERT_EQ(WMError::WM_DO_NOTHING, windowSceneSession->Minimize());
779 }
780
781 /**
782 * @tc.name: StartMove01
783 * @tc.desc: StartMove
784 * @tc.type: FUNC
785 */
786 HWTEST_F(WindowSceneSessionImplTest, StartMove01, Function | SmallTest | Level2)
787 {
788 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
789 option->SetWindowName("StartMove01");
790 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
791 windowSceneSession->property_->SetPersistentId(1);
792 // show with null session
793
794 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
795 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
796 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
797 windowSceneSession->hostSession_ = session;
798 windowSceneSession->StartMove();
799 ASSERT_NE(nullptr, session);
800 }
801
802 /**
803 * @tc.name: StartMoveWindow_IsDeviceSupportOrNot
804 * @tc.desc: StartMoveWindow Test, is device support or not
805 * @tc.type: FUNC
806 */
807 HWTEST_F(WindowSceneSessionImplTest, StartMoveWindow_IsDeviceSupportOrNot, Function | SmallTest | Level2)
808 {
809 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
810 option->SetWindowName("StartMoveWindow_IsDeviceSupportOrNot");
811 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
812 window->property_->SetPersistentId(1);
813 window->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
814 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
815 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
816 window->hostSession_ = session;
817
818 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
819 ASSERT_EQ(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
820
821 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
822 ASSERT_NE(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
823
824 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
825 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
826 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
827 ASSERT_NE(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
828
829 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
830 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
831 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
832 window->property_->SetIsPcAppInPad(true);
833 ASSERT_NE(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
834 }
835
836 /**
837 * @tc.name: Close01
838 * @tc.desc: Close
839 * @tc.type: FUNC
840 */
841 HWTEST_F(WindowSceneSessionImplTest, Close01, Function | SmallTest | Level2)
842 {
843 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
844 option->SetWindowName("Close01");
845 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
846 windowSceneSession->property_->SetPersistentId(1);
847 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
848 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
849 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
850 windowSceneSession->hostSession_ = session;
851
852 sptr<IWindowWillCloseListener> listener = sptr<IWindowWillCloseListener>::MakeSptr();
853 windowSceneSession->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
854 auto res = windowSceneSession->RegisterWindowWillCloseListeners(listener);
855 ASSERT_EQ(WMError::WM_OK, res);
856 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Close());
857 res = windowSceneSession->UnRegisterWindowWillCloseListeners(listener);
858 ASSERT_EQ(WMError::WM_OK, res);
859 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Close());
860 }
861
862 /**
863 * @tc.name: CloseDirectly
864 * @tc.desc: CloseDirectly
865 * @tc.type: FUNC
866 */
867 HWTEST_F(WindowSceneSessionImplTest, CloseDirectly, Function | SmallTest | Level2)
868 {
869 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
870 option->SetWindowName("CloseDirectly");
871 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
872 auto res = window->CloseDirectly();
873 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, res);
874
875 window->property_->SetPersistentId(1);
876 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
877 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
878 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
879 window->hostSession_ = session;
880 res = window->CloseDirectly();
881 ASSERT_EQ(WMError::WM_OK, res);
882
883 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
884 res = window->CloseDirectly();
885 ASSERT_EQ(WMError::WM_OK, res);
886 }
887
888 /**
889 * @tc.name: SetActive01
890 * @tc.desc: SetActive
891 * @tc.type: FUNC
892 */
893 HWTEST_F(WindowSceneSessionImplTest, SetActive01, Function | SmallTest | Level2)
894 {
895 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
896 option->SetWindowName("SetActive01");
897 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
898
899 windowSceneSession->property_->SetPersistentId(1);
900 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
901 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
902 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
903
904 windowSceneSession->hostSession_ = session;
905 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(false));
906 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(true));
907 }
908
909 /**
910 * @tc.name: Recover01
911 * @tc.desc: Recover
912 * @tc.type: FUNC
913 */
914 HWTEST_F(WindowSceneSessionImplTest, Recover01, Function | SmallTest | Level2)
915 {
916 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
917 option->SetWindowName("Recover01");
918 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
919
920 windowSceneSession->property_->SetPersistentId(1);
921 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
922 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
923 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
924
925 windowSceneSession->hostSession_ = session;
926 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Recover());
927 }
928
929 /**
930 * @tc.name: Maximize01
931 * @tc.desc: Maximize
932 * @tc.type: FUNC
933 */
934 HWTEST_F(WindowSceneSessionImplTest, Maximize01, Function | SmallTest | Level2)
935 {
936 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
937 option->SetWindowName("Maximize01");
938 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
939 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
940
941 windowSceneSession->property_->SetPersistentId(1);
942 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
943 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
944
945 windowSceneSession->hostSession_ = session;
946 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Maximize());
947 }
948
949 /**
950 * @tc.name: Hide01
951 * @tc.desc: Hide session
952 * @tc.type: FUNC
953 */
954 HWTEST_F(WindowSceneSessionImplTest, Hide01, Function | SmallTest | Level2)
955 {
956 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
957 option->SetWindowName("Hide01");
958 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
959
960 window->property_->SetPersistentId(1);
961 // show with null session
962 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Hide(2, false, false));
963
964 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
965 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
966
967 window->hostSession_ = session;
968 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
969 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
970
971 window->state_ = WindowState::STATE_CREATED;
972 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
973 window->state_ = WindowState::STATE_SHOWN;
974 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
975 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
976
977 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
978 ASSERT_EQ(WMError::WM_OK, window->Destroy(false));
979 }
980
981 /**
982 * @tc.name: Show01
983 * @tc.desc: Show session
984 * @tc.type: FUNC
985 */
986 HWTEST_F(WindowSceneSessionImplTest, Show01, Function | SmallTest | Level2)
987 {
988 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
989 option->SetWindowName("Show01");
990 option->SetDisplayId(0);
991 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
992 window->property_->SetPersistentId(1);
993
994 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
995 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
996
997 window->hostSession_ = session;
998 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
999
1000 window->state_ = WindowState::STATE_CREATED;
1001 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
1002 ASSERT_EQ(WMError::WM_OK, window->Destroy(false));
1003 }
1004
1005 /**
1006 * @tc.name: NotifyDrawingCompleted
1007 * @tc.desc: NotifyDrawingCompleted session
1008 * @tc.type: FUNC
1009 */
1010 HWTEST_F(WindowSceneSessionImplTest, NotifyDrawingCompleted, Function | SmallTest | Level2)
1011 {
1012 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1013 ASSERT_NE(nullptr, option);
1014 option->SetWindowName("NotifyDrawingCompleted");
1015 option->SetDisplayId(0);
1016 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1017 ASSERT_NE(nullptr, window->property_);
1018 window->property_->SetPersistentId(1);
1019
1020 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1021 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1022
1023 window->hostSession_ = session;
1024 auto ret = window->NotifyDrawingCompleted();
1025 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PERMISSION);
1026 }
1027
1028 /**
1029 * @tc.name: NotifyRemoveStartingWindow
1030 * @tc.desc: NotifyRemoveStartingWindow session
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(WindowSceneSessionImplTest, NotifyRemoveStartingWindow, Function | SmallTest | Level2)
1034 {
1035 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1036 option->SetWindowName("NotifyRemoveStartingWindow");
1037 option->SetDisplayId(0);
1038 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1039 window->property_->SetPersistentId(1);
1040
1041 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1042 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1043 window->hostSession_ = session;
1044 auto ret = window->NotifyDrawingCompleted();
1045 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PERMISSION);
1046 }
1047
1048 /**
1049 * @tc.name: SetTransparent
1050 * @tc.desc: SetTransparent test
1051 * @tc.type: FUNC
1052 */
1053 HWTEST_F(WindowSceneSessionImplTest, SetTransparent, Function | SmallTest | Level3)
1054 {
1055 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1056 option->SetWindowName("SetTransparent");
1057 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1058 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
1059 window->property_->SetPersistentId(1);
1060 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1061 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1062 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1063 ASSERT_NE(nullptr, session);
1064 window->hostSession_ = session;
1065 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1066 window->SetBackgroundColor(333);
1067
1068 auto ret = window->SetTransparent(true);
1069 ASSERT_EQ(ret, WMError::WM_OK);
1070 }
1071
1072 /**
1073 * @tc.name: GetTopwindowWithId
1074 * @tc.desc: GetTopwindowWithId test
1075 * @tc.type: FUNC
1076 */
1077 HWTEST_F(WindowSceneSessionImplTest, GetTopwindowWithId, Function | SmallTest | Level3)
1078 {
1079 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1080 option->SetWindowName("GetTopwindowWithId");
1081 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1082 sptr<WindowSessionImpl> session = sptr<WindowSessionImpl>::MakeSptr(option);
1083 uint32_t windowId = 1;
1084 string winName = "test";
1085 WindowSessionImpl::windowSessionMap_.insert(
1086 std::make_pair(winName, std::pair<int32_t, sptr<WindowSessionImpl>>(windowId, session)));
1087 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1088 uint32_t mainWinId = 1;
1089 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId));
1090
1091 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _))
1092 .Times(1)
1093 .WillOnce(DoAll(SetArgReferee<1>(windowId), Return(WMError::WM_OK)));
1094 ASSERT_NE(nullptr, window->GetTopWindowWithId(mainWinId));
1095
1096 int32_t tempWinId = 3;
1097 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _))
1098 .Times(1)
1099 .WillOnce(DoAll(SetArgReferee<1>(tempWinId), Return(WMError::WM_OK)));
1100 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId));
1101
1102 WindowSessionImpl::windowSessionMap_.erase(winName);
1103 }
1104
1105 /**
1106 * @tc.name: GetAvoidAreaByType
1107 * @tc.desc: GetAvoidAreaByType test
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(WindowSceneSessionImplTest, GetAvoidAreaByType, Function | SmallTest | Level3)
1111 {
1112 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1113 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1114 option->SetWindowName("GetAvoidAreaByType");
1115 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1116
1117 window->property_->SetPersistentId(1);
1118 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1119 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1120 AvoidArea avoidarea;
1121 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
1122 window->hostSession_ = session;
1123 ASSERT_EQ(WMError::WM_OK, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
1124 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1125 Rect rect;
1126 ASSERT_EQ(WMError::WM_OK, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea, rect, 15));
1127 ASSERT_EQ(WMError::WM_OK, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea, rect, 16));
1128 }
1129
1130 /**
1131 * @tc.name: Immersive
1132 * @tc.desc: Immersive01 test
1133 * @tc.type: FUNC
1134 */
1135 HWTEST_F(WindowSceneSessionImplTest, Immersive, Function | SmallTest | Level3)
1136 {
1137 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1138 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1139 option->SetWindowName("Immersive");
1140 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1141
1142 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1143 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1144 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1145 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1146 window->hostSession_ = session;
1147
1148 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1149 ASSERT_EQ(false, window->IsLayoutFullScreen());
1150 ASSERT_EQ(false, window->IsFullScreen());
1151 }
1152
1153 /**
1154 * @tc.name: SystemBarProperty
1155 * @tc.desc: SystemBarProperty01 test
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty, Function | SmallTest | Level3)
1159 {
1160 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1161 option->SetWindowName("SystemBarProperty");
1162 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1163 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1164
1165 SystemBarProperty property = SystemBarProperty();
1166 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1167 window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1168 }
1169
1170 /**
1171 * @tc.name: SystemBarProperty02
1172 * @tc.desc: SystemBarProperty02 test
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty02, Function | SmallTest | Level3)
1176 {
1177 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1178 option->SetWindowName("SystemBarProperty02");
1179 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1180
1181 window->state_ = WindowState::STATE_SHOWN;
1182 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1183 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1184 window->property_->SetPersistentId(1);
1185 window->hostSession_ = session;
1186
1187 SystemBarProperty property;
1188 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1189 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1190
1191 property.enableAnimation_ = false;
1192 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1193 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1194 }
1195
1196 /**
1197 * @tc.name: SystemBarProperty03
1198 * @tc.desc: SystemBarProperty03 test
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty03, Function | SmallTest | Level3)
1202 {
1203 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1204 option->SetWindowName("SystemBarProperty03");
1205 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1206
1207 window->state_ = WindowState::STATE_SHOWN;
1208 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1209 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1210 window->property_->SetPersistentId(1);
1211 window->hostSession_ = session;
1212
1213 SystemBarProperty property;
1214 property.enableAnimation_ = true;
1215 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1216 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1217 }
1218
1219 /**
1220 * @tc.name: SystemBarProperty04
1221 * @tc.desc: SystemBarProperty04 test
1222 * @tc.type: FUNC
1223 */
1224 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty04, Function | SmallTest | Level3)
1225 {
1226 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1227 option->SetWindowName("SystemBarProperty04");
1228 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1229 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1230
1231 SystemBarProperty property;
1232 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1233 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1234 }
1235
1236 /**
1237 * @tc.name: SystemBarProperty05
1238 * @tc.desc: SystemBarProperty05 test
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty05, Function | SmallTest | Level3)
1242 {
1243 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1244 option->SetWindowName("SystemBarProperty05");
1245 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1246
1247 window->state_ = WindowState::STATE_SHOWN;
1248 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1249 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1250 window->property_->SetPersistentId(1);
1251 window->hostSession_ = session;
1252
1253 SystemBarProperty property;
1254 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1255 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1256
1257 property.enableAnimation_ = false;
1258 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1259 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1260 }
1261
1262 /**
1263 * @tc.name: SystemBarProperty06
1264 * @tc.desc: SystemBarProperty06 test
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty06, Function | SmallTest | Level3)
1268 {
1269 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1270 option->SetWindowName("SystemBarProperty06");
1271 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1272
1273 window->state_ = WindowState::STATE_SHOWN;
1274 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1275 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1276 window->property_->SetPersistentId(1);
1277 window->hostSession_ = session;
1278
1279 SystemBarProperty property;
1280 property.enableAnimation_ = true;
1281 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1282 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1283 }
1284
1285 /**
1286 * @tc.name: SystemBarProperty07
1287 * @tc.desc: SystemBarProperty07 test
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty07, Function | SmallTest | Level3)
1291 {
1292 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1293 option->SetWindowName("SystemBarProperty07");
1294 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1295
1296 window->state_ = WindowState::STATE_SHOWN;
1297 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1298 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1299 window->property_->SetPersistentId(1);
1300 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
1301 window->hostSession_ = session;
1302
1303 SystemBarProperty property;
1304 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1305 ASSERT_EQ(SystemBarSettingFlag::DEFAULT_SETTING,
1306 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1307
1308 property.enable_ = false;
1309 property.settingFlag_ = SystemBarSettingFlag::ENABLE_SETTING;
1310 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1311 ASSERT_EQ(SystemBarSettingFlag::ENABLE_SETTING,
1312 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1313
1314 property.backgroundColor_ = 0xB3000000;
1315 property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
1316 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1317 ASSERT_EQ(SystemBarSettingFlag::COLOR_SETTING,
1318 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1319
1320 property.enable_ = true;
1321 property.backgroundColor_ = 0x4C000000;
1322 property.settingFlag_ = SystemBarSettingFlag::ALL_SETTING;
1323 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1324 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1325 }
1326
1327 /**
1328 * @tc.name: SetSystemBarProperties
1329 * @tc.desc: SetSystemBarProperties test
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(WindowSceneSessionImplTest, SetSystemBarProperties, Function | SmallTest | Level3)
1333 {
1334 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1335 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1336 option->SetWindowName("SetSystemBarProperties");
1337 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1338 window->state_ = WindowState::STATE_SHOWN;
1339 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1340 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1341 window->property_->SetPersistentId(1);
1342 window->hostSession_ = session;
1343 std::map<WindowType, SystemBarProperty> properties;
1344 std::map<WindowType, SystemBarPropertyFlag> propertyFlags;
1345 SystemBarProperty current = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
1346 SystemBarProperty property;
1347 properties[WindowType::WINDOW_TYPE_STATUS_BAR] = property;
1348 SystemBarPropertyFlag propertyFlag;
1349 propertyFlag.contentColorFlag = true;
1350 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR] = propertyFlag;
1351 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperties(properties, propertyFlags));
1352 if (property.contentColor_ != current.contentColor_) {
1353 std::map<WindowType, SystemBarProperty> currProperties;
1354 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(currProperties));
1355 ASSERT_EQ(currProperties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_, property.contentColor_);
1356 }
1357 }
1358
1359 /**
1360 * @tc.name: GetSystemBarProperties
1361 * @tc.desc: GetSystemBarProperties test
1362 * @tc.type: FUNC
1363 */
1364 HWTEST_F(WindowSceneSessionImplTest, GetSystemBarProperties, Function | SmallTest | Level3)
1365 {
1366 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1367 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1368 option->SetWindowName("GetSystemBarProperties");
1369 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1370 std::map<WindowType, SystemBarProperty> properties;
1371 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(properties));
1372 }
1373
1374 /**
1375 * @tc.name: SpecificBarProperty
1376 * @tc.desc: SpecificBarProperty01 test
1377 * @tc.type: FUNC
1378 */
1379 HWTEST_F(WindowSceneSessionImplTest, SpecificBarProperty, Function | SmallTest | Level3)
1380 {
1381 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1382 option->SetWindowName("SpecificBarProperty");
1383 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1384 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1385
1386 SystemBarProperty property = SystemBarProperty();
1387 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1388 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1389 }
1390
1391 /**
1392 * @tc.name: NotifySpecificWindowSessionProperty
1393 * @tc.desc: NotifySpecificWindowSessionProperty01 test
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(WindowSceneSessionImplTest, NotifySpecificWindowSessionProperty, Function | SmallTest | Level3)
1397 {
1398 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1399 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1400 option->SetWindowName("NotifySpecificWindowSessionProperty");
1401 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1402
1403 SystemBarProperty property = SystemBarProperty();
1404 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1405 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1406 window->property_->SetPersistentId(190);
1407 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1408 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1409 ASSERT_NE(nullptr, session);
1410 window->hostSession_ = session;
1411 window->state_ = WindowState::STATE_HIDDEN;
1412 ASSERT_EQ(WMError::WM_OK,
1413 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_NAVIGATION_BAR, property));
1414 window->state_ = WindowState::STATE_SHOWN;
1415 ASSERT_EQ(WMError::WM_OK,
1416 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR, property));
1417 }
1418
1419 /**
1420 * @tc.name: LimitCameraFloatWindowMininumSize
1421 * @tc.desc: LimitCameraFloatWindowMininumSize01 test
1422 * @tc.type: FUNC
1423 */
1424 HWTEST_F(WindowSceneSessionImplTest, LimitCameraFloatWindowMininumSize, Function | SmallTest | Level3)
1425 {
1426 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1427 ASSERT_NE(option, nullptr);
1428 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1429 option->SetWindowName("LimitCameraFloatWindowMininumSize");
1430 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1431 ASSERT_NE(window, nullptr);
1432 uint32_t width = 33;
1433 uint32_t height = 31;
1434 float vpr = 0.0f;
1435 window->LimitCameraFloatWindowMininumSize(width, height, vpr);
1436 }
1437
1438 /**
1439 * @tc.name: NotifyWindowNeedAvoid
1440 * @tc.desc: NotifyWindowNeedAvoid test
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(WindowSceneSessionImplTest, NotifyWindowNeedAvoid, Function | SmallTest | Level3)
1444 {
1445 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1446 option->SetWindowName("NotifyWindowNeedAvoid");
1447 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1448 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->NotifyWindowNeedAvoid(false));
1449
1450 window->state_ = WindowState::STATE_SHOWN;
1451 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1452 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1453 window->property_->SetPersistentId(190);
1454 window->hostSession_ = session;
1455 ASSERT_EQ(WMError::WM_OK, window->NotifyWindowNeedAvoid(false));
1456 }
1457
1458 /**
1459 * @tc.name: SetLayoutFullScreenByApiVersion
1460 * @tc.desc: SetLayoutFullScreenByApiVersion test
1461 * @tc.type: FUNC
1462 */
1463 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreenByApiVersion, Function | SmallTest | Level3)
1464 {
1465 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1466 option->SetWindowName("SetLayoutFullScreenByApiVersion");
1467 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1468 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreenByApiVersion(false));
1469 window->state_ = WindowState::STATE_SHOWN;
1470 window->property_->SetPersistentId(190);
1471 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1472 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1473 window->hostSession_ = session;
1474 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreenByApiVersion(false));
1475 ASSERT_EQ(false, window->property_->IsLayoutFullScreen());
1476 }
1477
1478 /**
1479 * @tc.name: SetGlobalMaximizeMode
1480 * @tc.desc: SetGlobalMaximizeMode test
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(WindowSceneSessionImplTest, SetGlobalMaximizeMode, Function | SmallTest | Level3)
1484 {
1485 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1486 option->SetWindowName("SetGlobalMaximizeMode");
1487 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1488 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1489
1490 window->state_ = WindowState::STATE_SHOWN;
1491 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1492 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1493 window->property_->SetPersistentId(190);
1494 window->hostSession_ = session;
1495 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1496 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1497
1498 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1499 ASSERT_EQ(WMError::WM_OK, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1500 }
1501
1502 /**
1503 * @tc.name: CheckParmAndPermission
1504 * @tc.desc: CheckParmAndPermission test
1505 * @tc.type: FUNC
1506 */
1507 HWTEST_F(WindowSceneSessionImplTest, CheckParmAndPermission, Function | SmallTest | Level3)
1508 {
1509 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1510 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1511 window->property_->SetWindowName("CheckParmAndPermission");
1512 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1513
1514 auto surfaceNode = window->GetSurfaceNode();
1515 if (surfaceNode == nullptr) {
1516 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1517 } else {
1518 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1519 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1520 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1521 }
1522 }
1523
1524 /**
1525 * @tc.name: SetBackdropBlurStyle
1526 * @tc.desc: SetBackdropBlurStyle test
1527 * @tc.type: FUNC
1528 */
1529 HWTEST_F(WindowSceneSessionImplTest, SetBackdropBlurStyle, Function | SmallTest | Level3)
1530 {
1531 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1532 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1533 window->property_->SetWindowName("SetBackdropBlurStyle");
1534 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1535 window->property_->SetDisplayId(3);
1536
1537 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1538 window->Destroy(true);
1539 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_THICK));
1540 window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1541 window->surfaceNode_ = nullptr;
1542 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1543 }
1544
1545 /**
1546 * @tc.name: SetTurnScreenOn
1547 * @tc.desc: SetTurnScreenOn test
1548 * @tc.type: FUNC
1549 */
1550 HWTEST_F(WindowSceneSessionImplTest, SetTurnScreenOn, Function | SmallTest | Level3)
1551 {
1552 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1553 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1554 window->property_->SetWindowName("SetTurnScreenOn");
1555 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1556 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(false));
1557
1558 window->property_->SetPersistentId(1);
1559 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1560 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1561 window->hostSession_ = session;
1562 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
1563 }
1564
1565 /**
1566 * @tc.name: SetBlur
1567 * @tc.desc: SetBlur test
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(WindowSceneSessionImplTest, SetBlur, Function | SmallTest | Level3)
1571 {
1572 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1573 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1574 window->property_->SetWindowName("SetBlur");
1575
1576 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBlur(-1.0));
1577 ASSERT_EQ(WMError::WM_OK, window->SetBlur(1.0));
1578 ASSERT_EQ(WMError::WM_OK, window->SetBlur(0.0));
1579 window->surfaceNode_ = nullptr;
1580 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBlur(1.0));
1581 }
1582
1583 /**
1584 * @tc.name: SetKeepScreenOn01
1585 * @tc.desc: Window is Invalid
1586 * @tc.type: FUNC
1587 */
1588 HWTEST_F(WindowSceneSessionImplTest, SetKeepScreenOn01, Function | SmallTest | Level3)
1589 {
1590 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1591 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1592
1593 window->property_->SetWindowName("SetKeepScreenOn");
1594 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1595 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(false));
1596 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(true));
1597 }
1598
1599 /**
1600 * @tc.name: SetKeepScreenOn02
1601 * @tc.desc: Window is Valid
1602 * @tc.type: FUNC
1603 */
1604 HWTEST_F(WindowSceneSessionImplTest, SetKeepScreenOn02, Function | SmallTest | Level3)
1605 {
1606 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1607 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1608
1609 window->property_->SetWindowName("SetKeepScreenOn");
1610 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1611 window->property_->SetPersistentId(1);
1612 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1613 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1614 window->hostSession_ = session;
1615 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
1616 ASSERT_TRUE(window->IsKeepScreenOn());
1617 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
1618 ASSERT_FALSE(window->IsKeepScreenOn());
1619 }
1620
1621 /**
1622 * @tc.name: SetViewKeepScreenOn01
1623 * @tc.desc: Window is Invalid
1624 * @tc.type: FUNC
1625 */
1626 HWTEST_F(WindowSceneSessionImplTest, SetViewKeepScreenOn01, TestSize.Level1)
1627 {
1628 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1629 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1630
1631 window->property_->SetWindowName("SetViewKeepScreenOn");
1632 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1633 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetViewKeepScreenOn(false));
1634 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetViewKeepScreenOn(true));
1635 }
1636
1637 /**
1638 * @tc.name: SetViewKeepScreenOn02
1639 * @tc.desc: Window is Valid
1640 * @tc.type: FUNC
1641 */
1642 HWTEST_F(WindowSceneSessionImplTest, SetViewKeepScreenOn02, TestSize.Level1)
1643 {
1644 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1645 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1646
1647 window->property_->SetWindowName("SetViewKeepScreenOn");
1648 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1649 window->property_->SetPersistentId(1);
1650 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1651 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1652 window->hostSession_ = session;
1653 ASSERT_EQ(WMError::WM_OK, window->SetViewKeepScreenOn(true));
1654 ASSERT_TRUE(window->IsViewKeepScreenOn());
1655 ASSERT_EQ(WMError::WM_OK, window->SetViewKeepScreenOn(false));
1656 ASSERT_FALSE(window->IsViewKeepScreenOn());
1657 }
1658
1659 /**
1660 * @tc.name: SetPrivacyMode01
1661 * @tc.desc: SetPrivacyMode as true
1662 * @tc.type: FUNC
1663 */
1664 HWTEST_F(WindowSceneSessionImplTest, SetPrivacyMode01, Function | SmallTest | Level3)
1665 {
1666 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1667 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1668
1669 window->property_->SetWindowName("SetPrivacyMode");
1670 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1671 window->property_->SetPersistentId(1);
1672 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1673 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1674 window->hostSession_ = session;
1675 ASSERT_EQ(WMError::WM_OK, window->SetPrivacyMode(true));
1676 ASSERT_EQ(true, window->IsPrivacyMode());
1677 }
1678
1679 /**
1680 * @tc.name: SetPrivacyMode02
1681 * @tc.desc: SetPrivacyMode as false
1682 * @tc.type: FUNC
1683 */
1684 HWTEST_F(WindowSceneSessionImplTest, SetPrivacyMode02, Function | SmallTest | Level3)
1685 {
1686 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1687 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1688
1689 window->property_->SetWindowName("SetPrivacyMode");
1690 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1691 window->property_->SetPersistentId(1);
1692 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1693 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1694 window->hostSession_ = session;
1695 ASSERT_EQ(WMError::WM_OK, window->SetPrivacyMode(false));
1696 ASSERT_EQ(false, window->IsPrivacyMode());
1697 }
1698
1699 /**
1700 * @tc.name: SetPrivacyMode03
1701 * @tc.desc: Window is invalid
1702 * @tc.type: FUNC
1703 */
1704 HWTEST_F(WindowSceneSessionImplTest, SetPrivacyMode03, Function | SmallTest | Level3)
1705 {
1706 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1707 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1708
1709 window->property_->SetWindowName("SetPrivacyMode");
1710 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1711 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetPrivacyMode(false));
1712 }
1713
1714 /**
1715 * @tc.name: IsPrivacyMode
1716 * @tc.desc: Set window privacy mode as true and false
1717 * @tc.type: FUNC
1718 */
1719 HWTEST_F(WindowSceneSessionImplTest, IsPrivacyModec, Function | SmallTest | Level3)
1720 {
1721 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1722 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1723
1724 window->property_->SetWindowName("IsPrivacyModec");
1725 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1726 window->property_->SetPersistentId(1);
1727 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1728 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1729 window->hostSession_ = session;
1730 window->SetPrivacyMode(true);
1731 ASSERT_EQ(true, window->IsPrivacyMode());
1732 window->SetPrivacyMode(false);
1733 ASSERT_EQ(false, window->IsPrivacyMode());
1734 }
1735
1736 /**
1737 * @tc.name: SetSystemPrivacyMode
1738 * @tc.desc: Set Ststemwindow privacy mode as true and false
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(WindowSceneSessionImplTest, SetSystemPrivacyMode, Function | SmallTest | Level3)
1742 {
1743 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1744 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1745
1746 window->property_->SetWindowName("SetSystemPrivacyMode");
1747 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1748 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1749 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1750 window->hostSession_ = session;
1751 window->SetSystemPrivacyMode(true);
1752 ASSERT_EQ(true, window->property_->GetSystemPrivacyMode());
1753 window->SetSystemPrivacyMode(false);
1754 ASSERT_EQ(false, window->property_->GetSystemPrivacyMode());
1755 }
1756
1757 /**
1758 * @tc.name: SetSnapshotSkip
1759 * @tc.desc: SetSnapshotSkip test
1760 * @tc.type: FUNC
1761 */
1762 HWTEST_F(WindowSceneSessionImplTest, SetSnapshotSkip, Function | SmallTest | Level3)
1763 {
1764 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1765 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1766 window->property_->SetWindowName("SetSnapshotSkip");
1767 window->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1768 window->property_->SetPersistentId(1);
1769 auto surfaceNode_mocker = CreateRSSurfaceNode();
1770 ASSERT_NE(nullptr, surfaceNode_mocker);
1771
1772 window->surfaceNode_ = surfaceNode_mocker;
1773 auto surfaceNode = window->GetSurfaceNode();
1774 window->property_->SetSnapshotSkip(true);
1775 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSnapshotSkip(false));
1776 ASSERT_EQ(true, window->property_->GetSnapshotSkip());
1777 }
1778
1779 /**
1780 * @tc.name: SetImmersiveModeEnabledState
1781 * @tc.desc: SetImmersiveModeEnabledState test
1782 * @tc.type: FUNC
1783 */
1784 HWTEST_F(WindowSceneSessionImplTest, SetImmersiveModeEnabledState, Function | SmallTest | Level3)
1785 {
1786 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1787 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1788 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1789
1790 window->property_->SetPersistentId(1);
1791 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1792 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1793 window->hostSession_ = session;
1794 window->property_->SetWindowName("SetImmersiveModeEnabledState");
1795 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1796 window->state_ = WindowState::STATE_CREATED;
1797 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1798
1799 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1800 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1801 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1802 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1803 ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
1804
1805 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1806 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1807 ASSERT_EQ(true, window->IsLayoutFullScreen());
1808 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1809 ASSERT_EQ(false, window->IsLayoutFullScreen());
1810 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1811 ASSERT_EQ(true, window->IsLayoutFullScreen());
1812 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1813 ASSERT_EQ(false, window->IsLayoutFullScreen());
1814
1815 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1816 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1817 ASSERT_EQ(true, window->IsLayoutFullScreen());
1818 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1819 ASSERT_EQ(WMError::WM_OK, window->MaximizeFloating());
1820 ASSERT_EQ(true, window->IsLayoutFullScreen());
1821 }
1822
1823 /**
1824 * @tc.name: SetLayoutFullScreen01
1825 * @tc.desc: SetLayoutFullScreen test
1826 * @tc.type: FUNC
1827 */
1828 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreen01, Function | SmallTest | Level3)
1829 {
1830 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1831 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1832 window->property_->SetWindowName("SetLayoutFullScreen01");
1833 window->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1834 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1835 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1836 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1837 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1838 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1839 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1840 window->property_->SetPersistentId(1);
1841 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1842 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1843 window->hostSession_ = session;
1844 WMError res = window->SetLayoutFullScreen(false);
1845 ASSERT_EQ(WMError::WM_OK, res);
1846 ASSERT_EQ(false, window->IsLayoutFullScreen());
1847 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1848 ASSERT_EQ(true, window->IsLayoutFullScreen());
1849 window->property_->SetWindowModeSupportType(0);
1850 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1851 }
1852
1853 /**
1854 * @tc.name: SetTitleAndDockHoverShown
1855 * @tc.desc: SetTitleAndDockHoverShown test
1856 * @tc.type: FUNC
1857 */
1858 HWTEST_F(WindowSceneSessionImplTest, SetTitleAndDockHoverShown, Function | SmallTest | Level3)
1859 {
1860 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1861 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1862 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTitleAndDockHoverShown(true, true));
1863
1864 window->property_->SetPersistentId(1);
1865 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1866 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1867 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1868 window->hostSession_ = session;
1869 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetTitleAndDockHoverShown(true, true));
1870
1871 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1872 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1873 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetTitleAndDockHoverShown(true, true));
1874
1875 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1876 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1877 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetTitleAndDockHoverShown(true, true));
1878 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1879 EXPECT_EQ(WMError::WM_OK, window->SetTitleAndDockHoverShown(true, true));
1880 }
1881
1882 /**
1883 * @tc.name: SetLayoutFullScreen02
1884 * @tc.desc: SetLayoutFullScreen test
1885 * @tc.type: FUNC
1886 */
1887 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreen02, Function | SmallTest | Level3)
1888 {
1889 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1890 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1891 window->property_->SetWindowName("SetLayoutFullScreen02");
1892 window->property_->SetWindowType(WindowType::WINDOW_TYPE_UI_EXTENSION);
1893
1894 window->hostSession_ = nullptr;
1895 window->property_->SetCompatibleModeInPc(true);
1896 WMError res = window->SetLayoutFullScreen(false);
1897 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, res);
1898 }
1899
1900 /**
1901 * @tc.name: SetLayoutFullScreen03
1902 * @tc.desc: SetLayoutFullScreen test
1903 * @tc.type: FUNC
1904 */
1905 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreen03, Function | SmallTest | Level3)
1906 {
1907 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1908 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1909 window->property_->SetWindowName("SetLayoutFullScreen03");
1910 window->property_->SetPersistentId(1);
1911 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1912 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1913 window->hostSession_ = session;
1914 WMError res = window->SetLayoutFullScreen(false);
1915 window->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1916 ASSERT_EQ(WMError::WM_OK, res);
1917 ASSERT_EQ(false, window->IsLayoutFullScreen());
1918 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1919 ASSERT_EQ(true, window->IsLayoutFullScreen());
1920 window->property_->SetWindowModeSupportType(0);
1921 window->property_->SetCompatibleModeInPc(true);
1922 sptr<WindowSessionImpl> mainWindow = CreateWindow("mainWindow", WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 100);
1923 mainWindow->SetFreeMultiWindowMode(true);
1924 ASSERT_EQ(WMError::WM_OK, mainWindow->SetLayoutFullScreen(true));
1925 }
1926
1927 /**
1928 * @tc.name: SetFullScreen
1929 * @tc.desc: SetFullScreen test
1930 * @tc.type: FUNC
1931 */
1932 HWTEST_F(WindowSceneSessionImplTest, SetFullScreen, Function | SmallTest | Level3)
1933 {
1934 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1935 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1936 window->property_->SetWindowName("SetLayoutFullScreen01");
1937 window->property_->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1938 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1939
1940 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1941 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1942 window->property_->SetWindowModeSupportType(0);
1943 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1944
1945 window->property_->SetWindowModeSupportType(1);
1946 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1947 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1948
1949 window->property_->SetPersistentId(1);
1950 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1951 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1952 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1953 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1954 window->state_ = WindowState::STATE_SHOWN;
1955 window->hostSession_ = session;
1956 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
1957 ASSERT_EQ(false, window->IsLayoutFullScreen());
1958 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
1959 ASSERT_EQ(true, window->IsLayoutFullScreen());
1960 }
1961
1962 /**
1963 * @tc.name: SetShadowOffsetX
1964 * @tc.desc: SetShadowOffsetX test
1965 * @tc.type: FUNC
1966 */
1967 HWTEST_F(WindowSceneSessionImplTest, SetShadowOffsetX, Function | SmallTest | Level3)
1968 {
1969 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1970 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1971 window->property_->SetWindowName("SetShadowOffsetX");
1972 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1973
1974 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetX(1.0));
1975 window->surfaceNode_ = nullptr;
1976 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowOffsetX(1.0));
1977 }
1978
1979 /**
1980 * @tc.name: SetShadowOffsetY
1981 * @tc.desc: SetShadowOffsetY test
1982 * @tc.type: FUNC
1983 */
1984 HWTEST_F(WindowSceneSessionImplTest, SetShadowOffsetY, Function | SmallTest | Level3)
1985 {
1986 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1987 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1988 window->property_->SetWindowName("SetShadowOffsetY");
1989 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1990
1991 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetY(1.0));
1992 window->surfaceNode_ = nullptr;
1993 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetShadowOffsetY(1.0));
1994 }
1995
1996 /**
1997 * @tc.name: SetGestureBackEnabled
1998 * @tc.desc: SetGestureBackEnabled test
1999 * @tc.type: FUNC
2000 */
2001 HWTEST_F(WindowSceneSessionImplTest, SetGestureBackEnabled, Function | SmallTest | Level3)
2002 {
2003 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2004 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2005 window->property_->SetPersistentId(1);
2006 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2007 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2008 window->hostSession_ = session;
2009 window->property_->SetWindowName("SetGestureBackEnabled");
2010 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2011 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetGestureBackEnabled(false));
2012 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
2013 window->state_ = WindowState::STATE_CREATED;
2014 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2015 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGestureBackEnabled(false));
2016 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2017 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
2018 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(false));
2019 bool enable;
2020 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
2021 ASSERT_EQ(false, enable);
2022 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(true));
2023 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
2024 ASSERT_EQ(true, enable);
2025 }
2026
2027 /**
2028 * @tc.name: CompatibleFullScreenRecover
2029 * @tc.desc: CompatibleFullScreenRecover test
2030 * @tc.type: FUNC
2031 */
2032 HWTEST_F(WindowSceneSessionImplTest, CompatibleFullScreenRecover, Function | SmallTest | Level2)
2033 {
2034 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2035 option->SetWindowName("CompatibleFullScreenRecover");
2036 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2037 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2038 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2039 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenRecover());
2040
2041 window->hostSession_ = session;
2042 window->property_->SetPersistentId(1);
2043 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenRecover());
2044
2045 window->property_->SetCompatibleModeInPc(true);
2046 ASSERT_EQ(WSError::WS_OK, window->CompatibleFullScreenRecover());
2047 }
2048
2049 /**
2050 * @tc.name: CompatibleFullScreenMinimize
2051 * @tc.desc: CompatibleFullScreenMinimize test
2052 * @tc.type: FUNC
2053 */
2054 HWTEST_F(WindowSceneSessionImplTest, CompatibleFullScreenMinimize, Function | SmallTest | Level2)
2055 {
2056 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2057 option->SetWindowName("CompatibleFullScreenMinimize");
2058 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2059 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2060 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2061 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenMinimize());
2062
2063 window->hostSession_ = session;
2064 window->property_->SetPersistentId(1);
2065 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenMinimize());
2066
2067 window->property_->SetCompatibleModeInPc(true);
2068 ASSERT_EQ(WSError::WS_OK, window->CompatibleFullScreenMinimize());
2069 }
2070
2071 /**
2072 * @tc.name: CompatibleFullScreenClose
2073 * @tc.desc: CompatibleFullScreenClose test
2074 * @tc.type: FUNC
2075 */
2076 HWTEST_F(WindowSceneSessionImplTest, CompatibleFullScreenClose, Function | SmallTest | Level2)
2077 {
2078 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2079 option->SetWindowName("CompatibleFullScreenClose");
2080 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2081 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2082 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2083 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenClose());
2084
2085 window->hostSession_ = session;
2086 window->property_->SetPersistentId(1);
2087 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->CompatibleFullScreenClose());
2088
2089 window->property_->SetCompatibleModeInPc(true);
2090 ASSERT_EQ(WSError::WS_OK, window->CompatibleFullScreenClose());
2091 }
2092
2093 /**
2094 * @tc.name: PcAppInPadNormalClose
2095 * @tc.desc: PcAppInPadNormalClose test
2096 * @tc.type: FUNC
2097 */
2098 HWTEST_F(WindowSceneSessionImplTest, PcAppInPadNormalClose, Function | SmallTest | Level2)
2099 {
2100 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2101 option->SetWindowName("PcAppInPadNormalClose");
2102 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2103 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
2104 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2105 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->PcAppInPadNormalClose());
2106
2107 window->hostSession_ = session;
2108 window->property_->SetPersistentId(1);
2109 ASSERT_EQ(WSError::WS_ERROR_INVALID_WINDOW, window->PcAppInPadNormalClose());
2110
2111 window->property_->SetIsPcAppInPad(true);
2112 ASSERT_EQ(WSError::WS_OK, window->PcAppInPadNormalClose());
2113 }
2114
2115 /**
2116 * @tc.name: SetPropertySessionInfo01
2117 * @tc.desc: SetPropertySessionInfo test
2118 * @tc.type: FUNC
2119 */
2120 HWTEST_F(WindowSceneSessionImplTest, SetPropertySessionInfo01, Function | SmallTest | Level2)
2121 {
2122 const std::string bundleName = "setPropertSessionInfoTest";
2123 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2124 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2125 windowSceneSession->property_->sessionInfo_.bundleName_ = bundleName;
2126
2127 windowSceneSession->context_ = nullptr;
2128 windowSceneSession->CreateAndConnectSpecificSession();
2129 ASSERT_EQ(windowSceneSession->property_->sessionInfo_.bundleName_, bundleName);
2130
2131 windowSceneSession->context_ = abilityContext_;
2132 windowSceneSession->property_->sessionInfo_.bundleName_ = bundleName;
2133 windowSceneSession->CreateAndConnectSpecificSession();
2134 ASSERT_EQ(windowSceneSession->property_->sessionInfo_.bundleName_, abilityContext_->GetBundleName());
2135 }
2136
2137 /**
2138 * @tc.name: SetWindowDelayRaiseEnabled
2139 * @tc.desc: SetWindowDelayRaiseEnabled test
2140 * @tc.type: FUNC
2141 */
2142 HWTEST_F(WindowSceneSessionImplTest, SetWindowDelayRaiseEnabled, Function | SmallTest | Level2)
2143 {
2144 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2145 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2146 window->property_->SetPersistentId(1);
2147 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
2148 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2149 window->hostSession_ = session;
2150 window->property_->SetWindowName("SetWindowDelayRaiseEnabled");
2151 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2152 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowDelayRaiseEnabled(false));
2153 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
2154 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
2155 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
2156 ASSERT_EQ(WMError::WM_OK, window->SetWindowDelayRaiseEnabled(false));
2157 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
2158 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
2159 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowDelayRaiseEnabled(false));
2160 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2161 ASSERT_EQ(WMError::WM_OK, window->SetWindowDelayRaiseEnabled(false));
2162 ASSERT_EQ(false, window->IsWindowDelayRaiseEnabled());
2163 ASSERT_EQ(WMError::WM_OK, window->SetWindowDelayRaiseEnabled(true));
2164 ASSERT_EQ(true, window->IsWindowDelayRaiseEnabled());
2165 }
2166
2167 /**
2168 * @tc.name: SetFollowParentMultiScreenPolicy
2169 * @tc.desc: SetFollowParentMultiScreenPolicy test
2170 * @tc.type: FUNC
2171 */
2172 HWTEST_F(WindowSceneSessionImplTest, SetFollowParentMultiScreenPolicy, Function | SmallTest | Level2)
2173 {
2174 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
2175 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
2176 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
2177 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
2178 window->hostSession_ = session;
2179 window->property_->SetWindowName("SetFollowParentMultiScreenPolicy");
2180 window->property_->SetPersistentId(0);
2181 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFollowParentMultiScreenPolicy(true));
2182 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFollowParentMultiScreenPolicy(false));
2183 window->property_->SetPersistentId(1);
2184 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
2185 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetFollowParentMultiScreenPolicy(true));
2186 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetFollowParentMultiScreenPolicy(false));
2187 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
2188 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
2189 window->windowSystemConfig_.freeMultiWindowSupport_ = false;
2190 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetFollowParentMultiScreenPolicy(true));
2191 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetFollowParentMultiScreenPolicy(false));
2192 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
2193 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
2194 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2195 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetFollowParentMultiScreenPolicy(true));
2196 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetFollowParentMultiScreenPolicy(false));
2197 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
2198 ASSERT_EQ(WMError::WM_OK, window->SetFollowParentMultiScreenPolicy(true));
2199 ASSERT_EQ(WMError::WM_OK, window->SetFollowParentMultiScreenPolicy(false));
2200 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
2201 ASSERT_EQ(WMError::WM_OK, window->SetFollowParentMultiScreenPolicy(true));
2202 ASSERT_EQ(WMError::WM_OK, window->SetFollowParentMultiScreenPolicy(false));
2203 }
2204 } // namespace
2205 } // namespace Rosen
2206 } // namespace OHOS
2207