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