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: RecoverAndReconnectSceneSession
385 * @tc.desc: RecoverAndReconnectSceneSession
386 * @tc.type: FUNC
387 */
388 HWTEST_F(WindowSceneSessionImplTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
389 {
390 sptr<WindowOption> option = new WindowOption();
391 option->SetWindowName("RecoverAndReconnectSceneSession");
392 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
393 ASSERT_NE(nullptr, windowSceneSession);
394 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->RecoverAndReconnectSceneSession());
395 }
396
397 /**
398 * @tc.name: IsValidSystemWindowType01
399 * @tc.desc: IsValidSystemWindowType
400 * @tc.type: FUNC
401 */
402 HWTEST_F(WindowSceneSessionImplTest, IsValidSystemWindowType01, Function | SmallTest | Level2)
403 {
404 sptr<WindowOption> option = new (std::nothrow) WindowOption();
405 option->SetWindowName("IsValidSystemWindowType01");
406 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
407 ASSERT_NE(nullptr, windowSceneSession);
408 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_SYSTEM_ALARM_WINDOW));
409 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT));
410 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA));
411 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_DIALOG));
412 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_FLOAT));
413 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_SCREENSHOT));
414 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH));
415 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_VOICE_INTERACTION));
416 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_POINTER));
417 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_TOAST));
418 ASSERT_FALSE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE));
419 ASSERT_TRUE(!windowSceneSession->IsValidSystemWindowType(WindowType::WINDOW_TYPE_APP_LAUNCHING));
420 }
421
422 /*
423 * @tc.name: InvalidWindow
424 * @tc.desc: InvalidWindow test
425 * @tc.type: FUNC
426 */
427 HWTEST_F(WindowSceneSessionImplTest, InvalidWindow, Function | SmallTest | Level3)
428 {
429 sptr<WindowOption> option = new (std::nothrow) WindowOption();
430 option->SetWindowName("InvalidWindow");
431 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
432 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveTo(0, 0));
433 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(0, 0));
434 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBackgroundColor(std::string("???")));
435 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(false));
436 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Show(2, false));
437 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(2, 2));
438 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Minimize());
439 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Maximize());
440 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MaximizeFloating());
441 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Recover());
442 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MaximizeFloating());
443 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGlobalMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR));
444 }
445
446 /**
447 * @tc.name: FindParentSessionByParentId01
448 * @tc.desc: FindParentSessionByParentId
449 * @tc.type: FUNC
450 */
451 HWTEST_F(WindowSceneSessionImplTest, FindParentSessionByParentId01, Function | SmallTest | Level2)
452 {
453 sptr<WindowOption> option = new (std::nothrow) WindowOption();
454 option->SetWindowTag(WindowTag::MAIN_WINDOW);
455 option->SetWindowName("FindParentSessionByParentId01");
456 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
457 ASSERT_NE(nullptr, windowSceneSession);
458
459 windowSceneSession->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
460 ASSERT_TRUE(windowSceneSession->FindMainWindowWithContext() == nullptr);
461 windowSceneSession->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_END);
462 ASSERT_TRUE(windowSceneSession->FindMainWindowWithContext() == nullptr);
463
464 windowSceneSession->property_->SetPersistentId(1112);
465 windowSceneSession->property_->SetParentId(1000);
466 windowSceneSession->property_->SetParentPersistentId(1000);
467 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
468 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
469 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
470 ASSERT_NE(nullptr, session);
471 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Create(abilityContext_, session));
472 windowSceneSession->hostSession_ = session;
473 ASSERT_TRUE(nullptr != windowSceneSession->FindParentSessionByParentId(1112));
474 windowSceneSession->Destroy(true);
475 }
476
477 /**
478 * @tc.name: DisableAppWindowDecor01
479 * @tc.desc: DisableAppWindowDecor
480 * @tc.type: FUNC
481 */
482 HWTEST_F(WindowSceneSessionImplTest, DisableAppWindowDecor01, Function | SmallTest | Level3)
483 {
484 sptr<WindowOption> option = new (std::nothrow) WindowOption();
485 option->SetWindowName("DisableAppWindowDecor01");
486 sptr<WindowSceneSessionImpl> windowSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
487 ASSERT_NE(nullptr, windowSession);
488
489 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
490 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
491
492 ASSERT_NE(nullptr, session);
493 std::shared_ptr<AbilityRuntime::Context> context;
494 ASSERT_EQ(WMError::WM_OK, windowSession->Create(context, session));
495 windowSession->property_->SetPersistentId(1);
496
497 windowSession->UpdateDecorEnable(false);
498 windowSession->windowSystemConfig_.isSystemDecorEnable_ = false;
499 windowSession->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
500 windowSession->DisableAppWindowDecor();
501 ASSERT_FALSE(windowSession->IsDecorEnable());
502 windowSession->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
503 windowSession->DisableAppWindowDecor();
504 windowSession->Destroy(true);
505 }
506
507 /**
508 * @tc.name: RaiseToAppTop01
509 * @tc.desc: RaiseToAppTop
510 * @tc.type: FUNC
511 */
512 HWTEST_F(WindowSceneSessionImplTest, RaiseToAppTop01, Function | SmallTest | Level2)
513 {
514 sptr<WindowOption> option = new (std::nothrow) WindowOption();
515 option->SetWindowName("RaiseToAppTop01");
516 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
517 ASSERT_NE(nullptr, windowSceneSession);
518
519 windowSceneSession->property_->SetPersistentId(6);
520 windowSceneSession->property_->SetParentPersistentId(6);
521 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
522 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->RaiseToAppTop());
523
524 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
525 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
526 windowSceneSession->hostSession_ = session;
527 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, windowSceneSession->RaiseToAppTop());
528
529 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
530 windowSceneSession->state_ = WindowState::STATE_HIDDEN;
531 ASSERT_EQ(WMError::WM_DO_NOTHING, windowSceneSession->RaiseToAppTop());
532
533 windowSceneSession->state_ = WindowState::STATE_SHOWN;
534 ASSERT_EQ(WMError::WM_OK, windowSceneSession->RaiseToAppTop());
535 }
536
537 /**
538 * @tc.name: Resize01
539 * @tc.desc: Resize
540 * @tc.type: FUNC
541 */
542 HWTEST_F(WindowSceneSessionImplTest, Resize01, Function | SmallTest | Level2)
543 {
544 sptr<WindowOption> option = new (std::nothrow) WindowOption();
545 option->SetWindowName("Resize01");
546 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
547 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
548 ASSERT_NE(nullptr, windowSceneSession);
549
550 windowSceneSession->property_->SetPersistentId(888);
551 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
552 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
553 ASSERT_NE(nullptr, session);
554 windowSceneSession->hostSession_ = session;
555 Rect rect = {2, 2, 2, 2};
556 windowSceneSession->property_->SetWindowRect(rect);
557 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
558 windowSceneSession->state_ = WindowState::STATE_FROZEN;
559 windowSceneSession->hostSession_ = session;
560 windowSceneSession->Resize(1, 1);
561 }
562
563 /**
564 * @tc.name: GetGlobalScaledRect
565 * @tc.desc: GetGlobalScaledRect
566 * @tc.type: FUNC
567 */
568 HWTEST_F(WindowSceneSessionImplTest, GetGlobalScaledRect, Function | SmallTest | Level2)
569 {
570 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
571 option->SetWindowName("GetGlobalScaledRect");
572 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
573 Rect globalScaledRect;
574 windowSceneSession->property_->SetPersistentId(6);
575 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, windowSceneSession->GetGlobalScaledRect(globalScaledRect));
576
577 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
578 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
579 windowSceneSession->hostSession_ = session;
580 ASSERT_EQ(WMError::WM_OK, windowSceneSession->GetGlobalScaledRect(globalScaledRect));
581 }
582
583 /**
584 * @tc.name: MoveTo01
585 * @tc.desc: MoveTo
586 * @tc.type: FUNC
587 */
588 HWTEST_F(WindowSceneSessionImplTest, MoveTo01, Function | SmallTest | Level2)
589 {
590 sptr<WindowOption> option = new (std::nothrow) WindowOption();
591 option->SetWindowName("MoveTo01");
592 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
593 ASSERT_NE(nullptr, windowSceneSession);
594
595 windowSceneSession->property_->SetPersistentId(1);
596 windowSceneSession->state_ = WindowState::STATE_HIDDEN;
597 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
598 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
599 ASSERT_NE(nullptr, session);
600 windowSceneSession->hostSession_ = session;
601 ASSERT_EQ(WMError::WM_OK, windowSceneSession->MoveTo(2, 2));
602 }
603
604 /**
605 * @tc.name: Minimize01
606 * @tc.desc: Minimize
607 * @tc.type: FUNC
608 */
609 HWTEST_F(WindowSceneSessionImplTest, Minimize01, Function | SmallTest | Level2)
610 {
611 sptr<WindowOption> option = new (std::nothrow) WindowOption();
612 option->SetWindowName("Minimize01");
613 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
614 ASSERT_NE(nullptr, windowSceneSession);
615
616 windowSceneSession->property_->SetPersistentId(1);
617 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
618 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
619 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
620 ASSERT_NE(nullptr, session);
621 windowSceneSession->hostSession_ = session;
622 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Minimize());
623 }
624
625 /**
626 * @tc.name: StartMove01
627 * @tc.desc: StartMove
628 * @tc.type: FUNC
629 */
630 HWTEST_F(WindowSceneSessionImplTest, StartMove01, Function | SmallTest | Level2)
631 {
632 sptr<WindowOption> option = new (std::nothrow) WindowOption();
633 option->SetWindowName("StartMove01");
634 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
635 ASSERT_NE(nullptr, windowSceneSession);
636 windowSceneSession->property_->SetPersistentId(1);
637 // show with null session
638
639 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
640 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
641 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
642 windowSceneSession->hostSession_ = session;
643 windowSceneSession->StartMove();
644 ASSERT_NE(nullptr, session);
645 }
646
647 /**
648 * @tc.name: StartMoveWindow_IsDeviceSupportOrNot
649 * @tc.desc: StartMoveWindow Test, is device support or not
650 * @tc.type: FUNC
651 */
652 HWTEST_F(WindowSceneSessionImplTest, StartMoveWindow_IsDeviceSupportOrNot, Function | SmallTest | Level2)
653 {
654 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
655 option->SetWindowName("StartMoveWindow_IsDeviceSupportOrNot");
656 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
657 window->property_->SetPersistentId(1);
658 window->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
659 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
660 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
661 window->hostSession_ = session;
662
663 window->windowSystemConfig_.uiType_ = UI_TYPE_PHONE;
664 ASSERT_EQ(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
665
666 window->windowSystemConfig_.uiType_ = UI_TYPE_PC;
667 ASSERT_NE(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
668
669 window->windowSystemConfig_.uiType_ = UI_TYPE_PAD;
670 window->windowSystemConfig_.freeMultiWindowEnable_ = true;
671 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
672 ASSERT_NE(window->StartMoveWindow(), WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT);
673 }
674
675 /**
676 * @tc.name: Close01
677 * @tc.desc: Close
678 * @tc.type: FUNC
679 */
680 HWTEST_F(WindowSceneSessionImplTest, Close01, Function | SmallTest | Level2)
681 {
682 sptr<WindowOption> option = new (std::nothrow) WindowOption();
683 option->SetWindowName("Close01");
684 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
685 ASSERT_NE(nullptr, windowSceneSession);
686 windowSceneSession->property_->SetPersistentId(1);
687 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
688 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
689 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
690 ASSERT_NE(nullptr, session);
691 windowSceneSession->hostSession_ = session;
692 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Close());
693 }
694
695 /**
696 * @tc.name: Close02
697 * @tc.desc: Close
698 * @tc.type: FUNC
699 */
700 HWTEST_F(WindowSceneSessionImplTest, Close02, Function | SmallTest | Level2)
701 {
702 sptr<WindowOption> option = new (std::nothrow) WindowOption();
703 option->SetWindowName("Close02");
704 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
705 ASSERT_NE(nullptr, windowSceneSession);
706 windowSceneSession->property_->SetPersistentId(-1);
707 windowSceneSession->property_->SetParentPersistentId(-1);
708 windowSceneSession->property_->SetPersistentId(1);
709 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
710 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
711 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
712 ASSERT_NE(nullptr, session);
713 }
714
715 /**
716 * @tc.name: SetActive01
717 * @tc.desc: SetActive
718 * @tc.type: FUNC
719 */
720 HWTEST_F(WindowSceneSessionImplTest, SetActive01, Function | SmallTest | Level2)
721 {
722 sptr<WindowOption> option = new (std::nothrow) WindowOption();
723 option->SetWindowName("SetActive01");
724 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
725 ASSERT_NE(nullptr, windowSceneSession);
726 windowSceneSession->property_->SetPersistentId(1);
727 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
728 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
729 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
730 ASSERT_NE(nullptr, session);
731
732 windowSceneSession->hostSession_ = session;
733 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(false));
734 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(true));
735 }
736
737 /**
738 * @tc.name: Recover01
739 * @tc.desc: Recover
740 * @tc.type: FUNC
741 */
742 HWTEST_F(WindowSceneSessionImplTest, Recover01, Function | SmallTest | Level2)
743 {
744 sptr<WindowOption> option = new (std::nothrow) WindowOption();
745 option->SetWindowName("Recover01");
746 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
747 ASSERT_NE(nullptr, windowSceneSession);
748
749 windowSceneSession->property_->SetPersistentId(1);
750 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
751 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
752 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
753 ASSERT_NE(nullptr, session);
754 windowSceneSession->hostSession_ = session;
755 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Recover());
756 }
757
758 /**
759 * @tc.name: Maximize01
760 * @tc.desc: Maximize
761 * @tc.type: FUNC
762 */
763 HWTEST_F(WindowSceneSessionImplTest, Maximize01, Function | SmallTest | Level2)
764 {
765 sptr<WindowOption> option = new (std::nothrow) WindowOption();
766 option->SetWindowName("Maximize01");
767 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
768 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
769 ASSERT_NE(nullptr, windowSceneSession);
770 windowSceneSession->property_->SetPersistentId(1);
771 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
772 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
773 ASSERT_NE(nullptr, session);
774 windowSceneSession->hostSession_ = session;
775 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Maximize());
776 }
777
778 /**
779 * @tc.name: Hide01
780 * @tc.desc: Hide session
781 * @tc.type: FUNC
782 */
783 HWTEST_F(WindowSceneSessionImplTest, Hide01, Function | SmallTest | Level2)
784 {
785 sptr<WindowOption> option = new (std::nothrow) WindowOption();
786 option->SetWindowName("Hide01");
787 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
788 ASSERT_NE(nullptr, window);
789 window->property_->SetPersistentId(1);
790 // show with null session
791 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->Hide(2, false, false));
792
793 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
794 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
795 ASSERT_NE(nullptr, session);
796 window->hostSession_ = session;
797 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
798 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
799
800 window->state_ = WindowState::STATE_CREATED;
801 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
802 window->state_ = WindowState::STATE_SHOWN;
803 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
804 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
805
806 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
807 if (window->Destroy(false) == WMError::WM_OK) {
808 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
809 }
810 }
811
812 /**
813 * @tc.name: Show01
814 * @tc.desc: Show session
815 * @tc.type: FUNC
816 */
817 HWTEST_F(WindowSceneSessionImplTest, Show01, Function | SmallTest | Level2)
818 {
819 sptr<WindowOption> option = new (std::nothrow) WindowOption();
820 option->SetWindowName("Show01");
821 option->SetDisplayId(0);
822 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
823 ASSERT_NE(nullptr, window);
824 window->property_->SetPersistentId(1);
825
826 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
827 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
828 ASSERT_NE(nullptr, session);
829
830 window->hostSession_ = session;
831 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
832
833 window->state_ = WindowState::STATE_CREATED;
834 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
835 ASSERT_EQ(WMError::WM_OK, window->Destroy(false));
836 }
837
838 /**
839 * @tc.name: NotifyDrawingCompleted
840 * @tc.desc: NotifyDrawingCompleted session
841 * @tc.type: FUNC
842 */
843 HWTEST_F(WindowSceneSessionImplTest, NotifyDrawingCompleted, Function | SmallTest | Level2)
844 {
845 sptr<WindowOption> option = new (std::nothrow) WindowOption();
846 ASSERT_NE(nullptr, option);
847 option->SetWindowName("NotifyDrawingCompleted");
848 option->SetDisplayId(0);
849 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
850 ASSERT_NE(nullptr, window);
851 ASSERT_NE(nullptr, window->property_);
852 window->property_->SetPersistentId(1);
853
854 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
855 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
856 ASSERT_NE(nullptr, session);
857
858 window->hostSession_ = session;
859 window->NotifyDrawingCompleted();
860 }
861
862 /**
863 * @tc.name: SetBackgroundColor01
864 * @tc.desc: test SetBackgroundColor withow uiContent
865 * @tc.type: FUNC
866 */
867 HWTEST_F(WindowSceneSessionImplTest, SetBackgroundColor01, Function | SmallTest | Level3)
868 {
869 sptr<WindowOption> option = new (std::nothrow) WindowOption();
870 option->SetWindowName("SetBackgroundColor01");
871 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
872 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
873 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
874 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
875 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
876 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
877 ASSERT_NE(nullptr, session);
878
879 std::shared_ptr<AbilityRuntime::Context> context;
880 ASSERT_EQ(WMError::WM_OK, window->Create(context, session));
881
882 window->property_->SetPersistentId(1);
883 window->Show();
884 window->Destroy(true);
885 }
886
887 /**
888 * @tc.name: NotifyRemoveStartingWindow
889 * @tc.desc: NotifyRemoveStartingWindow session
890 * @tc.type: FUNC
891 */
892 HWTEST_F(WindowSceneSessionImplTest, NotifyRemoveStartingWindow, Function | SmallTest | Level2)
893 {
894 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
895 ASSERT_NE(nullptr, option);
896 option->SetWindowName("NotifyRemoveStartingWindow");
897 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
898 ASSERT_NE(nullptr, window);
899 window->property_->SetPersistentId(1);
900
901 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
902 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
903 ASSERT_NE(nullptr, session);
904
905 window->hostSession_ = session;
906 window->NotifyRemoveStartingWindow();
907 }
908
909 /**
910 * @tc.name: SetTransparent
911 * @tc.desc: SetTransparent test
912 * @tc.type: FUNC
913 */
914 HWTEST_F(WindowSceneSessionImplTest, SetTransparent, Function | SmallTest | Level3)
915 {
916 sptr<WindowOption> option = new (std::nothrow) WindowOption();
917 option->SetWindowName("SetTransparent");
918 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
919 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
920 window->property_->SetPersistentId(1);
921 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
922 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
923 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
924 ASSERT_NE(nullptr, session);
925 window->hostSession_ = session;
926 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
927 window->SetBackgroundColor(333);
928 if (window->SetTransparent(true) == WMError::WM_OK) {
929 ASSERT_EQ(WMError::WM_OK, window->SetTransparent(true));
930 }
931 }
932
933 /*
934 * @tc.name: SetAspectRatio
935 * @tc.desc: SetAspectRatio test
936 * @tc.type: FUNC
937 */
938 HWTEST_F(WindowSceneSessionImplTest, SetAspectRatio, Function | SmallTest | Level3)
939 {
940 sptr<WindowOption> option = new (std::nothrow) WindowOption();
941 option->SetWindowName("SetAspectRatio");
942 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
943 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
944 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetAspectRatio(0.1));
945
946 window->property_->SetPersistentId(1);
947 window->property_->SetDisplayId(3);
948 WindowLimits windowLimits = { 3, 3, 3, 3, 2.0, 2.0 };
949 window->property_->SetWindowLimits(windowLimits);
950 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
951 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
952 ASSERT_NE(nullptr, session);
953 window->hostSession_ = session;
954 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(0.1));
955 }
956
957 /*
958 * @tc.name: ResetAspectRatio
959 * @tc.desc: ResetAspectRatio test GetAvoidAreaByType
960 * @tc.type: FUNC
961 */
962 HWTEST_F(WindowSceneSessionImplTest, ResetAspectRatio, Function | SmallTest | Level3)
963 {
964 sptr<WindowOption> option = new (std::nothrow) WindowOption();
965 option->SetWindowName("ResetAspectRatio");
966 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
967 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
968 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
969 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
970 ASSERT_NE(nullptr, session);
971 window->hostSession_ = session;
972 ASSERT_EQ(WMError::WM_OK, window->ResetAspectRatio());
973 }
974
975 /*
976 * @tc.name: GetAvoidAreaByType
977 * @tc.desc: GetAvoidAreaByType test
978 * @tc.type: FUNC
979 */
980 HWTEST_F(WindowSceneSessionImplTest, GetAvoidAreaByType, Function | SmallTest | Level3)
981 {
982 sptr<WindowOption> option = new (std::nothrow) WindowOption();
983 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
984 option->SetWindowName("GetAvoidAreaByType");
985 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
986
987 window->property_->SetPersistentId(1);
988 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
989 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
990 ASSERT_NE(nullptr, session);
991 AvoidArea avoidarea;
992 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
993 }
994
995 /*
996 * @tc.name: Immersive
997 * @tc.desc: Immersive01 test
998 * @tc.type: FUNC
999 */
1000 HWTEST_F(WindowSceneSessionImplTest, Immersive, Function | SmallTest | Level3)
1001 {
1002 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1003 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1004 option->SetWindowName("Immersive");
1005 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1006
1007
1008 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
1009 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1010 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1011 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1012 ASSERT_NE(nullptr, session);
1013 window->hostSession_ = session;
1014
1015 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
1016 ASSERT_EQ(false, window->IsLayoutFullScreen());
1017 ASSERT_EQ(false, window->IsFullScreen());
1018 }
1019
1020 /*
1021 * @tc.name: SystemBarProperty
1022 * @tc.desc: SystemBarProperty01 test
1023 * @tc.type: FUNC
1024 */
1025 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty, Function | SmallTest | Level3)
1026 {
1027 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1028 option->SetWindowName("SystemBarProperty");
1029 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1030 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1031
1032 SystemBarProperty property = SystemBarProperty();
1033 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1034 window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1035 }
1036
1037 /*
1038 * @tc.name: SystemBarProperty02
1039 * @tc.desc: SystemBarProperty02 test
1040 * @tc.type: FUNC
1041 */
1042 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty02, Function | SmallTest | Level3)
1043 {
1044 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1045 option->SetWindowName("SystemBarProperty02");
1046 ASSERT_NE(nullptr, option);
1047 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1048 ASSERT_NE(nullptr, window);
1049
1050 window->state_ = WindowState::STATE_SHOWN;
1051 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1052 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1053 ASSERT_NE(nullptr, session);
1054 window->property_->SetPersistentId(1);
1055 window->hostSession_ = session;
1056
1057 SystemBarProperty property;
1058 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1059 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1060
1061 property.enableAnimation_ = false;
1062 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1063 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1064 }
1065
1066 /*
1067 * @tc.name: SystemBarProperty03
1068 * @tc.desc: SystemBarProperty03 test
1069 * @tc.type: FUNC
1070 */
1071 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty03, Function | SmallTest | Level3)
1072 {
1073 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1074 option->SetWindowName("SystemBarProperty03");
1075 ASSERT_NE(nullptr, option);
1076 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1077 ASSERT_NE(nullptr, window);
1078
1079 window->state_ = WindowState::STATE_SHOWN;
1080 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1081 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1082 ASSERT_NE(nullptr, session);
1083 window->property_->SetPersistentId(1);
1084 window->hostSession_ = session;
1085
1086 SystemBarProperty property;
1087 property.enableAnimation_ = true;
1088 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1089 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1090 }
1091
1092 /*
1093 * @tc.name: SystemBarProperty04
1094 * @tc.desc: SystemBarProperty04 test
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty04, Function | SmallTest | Level3)
1098 {
1099 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1100 option->SetWindowName("SystemBarProperty04");
1101 ASSERT_NE(nullptr, option);
1102 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1103 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1104 ASSERT_NE(nullptr, window);
1105
1106 SystemBarProperty property;
1107 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1108 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1109 }
1110
1111 /*
1112 * @tc.name: SystemBarProperty05
1113 * @tc.desc: SystemBarProperty05 test
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty05, Function | SmallTest | Level3)
1117 {
1118 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1119 option->SetWindowName("SystemBarProperty05");
1120 ASSERT_NE(nullptr, option);
1121 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1122 ASSERT_NE(nullptr, window);
1123
1124 window->state_ = WindowState::STATE_SHOWN;
1125 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1126 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1127 ASSERT_NE(nullptr, session);
1128 window->property_->SetPersistentId(1);
1129 window->hostSession_ = session;
1130
1131 SystemBarProperty property;
1132 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1133 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1134
1135 property.enableAnimation_ = false;
1136 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1137 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1138 }
1139
1140 /*
1141 * @tc.name: SystemBarProperty06
1142 * @tc.desc: SystemBarProperty06 test
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty06, Function | SmallTest | Level3)
1146 {
1147 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1148 option->SetWindowName("SystemBarProperty06");
1149 ASSERT_NE(nullptr, option);
1150 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1151 ASSERT_NE(nullptr, window);
1152
1153 window->state_ = WindowState::STATE_SHOWN;
1154 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1155 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1156 ASSERT_NE(nullptr, session);
1157 window->property_->SetPersistentId(1);
1158 window->hostSession_ = session;
1159
1160 SystemBarProperty property;
1161 property.enableAnimation_ = true;
1162 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1163 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1164 }
1165
1166 /*
1167 * @tc.name: SystemBarProperty07
1168 * @tc.desc: SystemBarProperty07 test
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty07, Function | SmallTest | Level3)
1172 {
1173 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1174 option->SetWindowName("SystemBarProperty07");
1175 ASSERT_NE(nullptr, option);
1176 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1177 ASSERT_NE(nullptr, window);
1178
1179 window->state_ = WindowState::STATE_SHOWN;
1180 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1181 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1182 ASSERT_NE(nullptr, session);
1183 window->property_->SetPersistentId(1);
1184 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
1185 window->hostSession_ = session;
1186
1187 SystemBarProperty property;
1188 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1189 ASSERT_EQ(SystemBarSettingFlag::DEFAULT_SETTING,
1190 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1191
1192 property.enable_ = false;
1193 property.settingFlag_ = SystemBarSettingFlag::ENABLE_SETTING;
1194 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1195 ASSERT_EQ(SystemBarSettingFlag::ENABLE_SETTING,
1196 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1197
1198 property.backgroundColor_ = 0xB3000000;
1199 property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
1200 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1201 ASSERT_EQ(SystemBarSettingFlag::COLOR_SETTING,
1202 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1203
1204 property.enable_ = true;
1205 property.backgroundColor_ = 0x4C000000;
1206 property.settingFlag_ = SystemBarSettingFlag::ALL_SETTING;
1207 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1208 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1209 }
1210
1211 /*
1212 * @tc.name: SetSystemBarProperties
1213 * @tc.desc: SetSystemBarProperties test
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(WindowSceneSessionImplTest, SetSystemBarProperties, Function | SmallTest | Level3)
1217 {
1218 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1219 ASSERT_NE(nullptr, option);
1220 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1221 option->SetWindowName("SetSystemBarProperties");
1222 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1223 ASSERT_NE(nullptr, window);
1224 window->state_ = WindowState::STATE_SHOWN;
1225 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1226 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1227 ASSERT_NE(nullptr, session);
1228 window->property_->SetPersistentId(1);
1229 window->hostSession_ = session;
1230 std::map<WindowType, SystemBarProperty> properties;
1231 std::map<WindowType, SystemBarPropertyFlag> propertyFlags;
1232 SystemBarProperty current = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
1233 SystemBarProperty property;
1234 properties[WindowType::WINDOW_TYPE_STATUS_BAR] = property;
1235 SystemBarPropertyFlag propertyFlag;
1236 propertyFlag.contentColorFlag = true;
1237 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR] = propertyFlag;
1238 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperties(properties, propertyFlags));
1239 if (property.contentColor_ != current.contentColor_) {
1240 std::map<WindowType, SystemBarProperty> currProperties;
1241 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(currProperties));
1242 ASSERT_EQ(currProperties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_, property.contentColor_);
1243 }
1244 }
1245
1246 /*
1247 * @tc.name: GetSystemBarProperties
1248 * @tc.desc: GetSystemBarProperties test
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(WindowSceneSessionImplTest, GetSystemBarProperties, Function | SmallTest | Level3)
1252 {
1253 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1254 ASSERT_NE(nullptr, option);
1255 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1256 option->SetWindowName("GetSystemBarProperties");
1257 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1258 ASSERT_NE(nullptr, window);
1259 std::map<WindowType, SystemBarProperty> properties;
1260 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(properties));
1261 }
1262
1263 /*
1264 * @tc.name: SpecificBarProperty
1265 * @tc.desc: SpecificBarProperty01 test
1266 * @tc.type: FUNC
1267 */
1268 HWTEST_F(WindowSceneSessionImplTest, SpecificBarProperty, Function | SmallTest | Level3)
1269 {
1270 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1271 option->SetWindowName("SpecificBarProperty");
1272 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1273 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1274
1275 SystemBarProperty property = SystemBarProperty();
1276 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1277 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1278 if (window->property_ == nullptr) {
1279 ASSERT_EQ(WMError::WM_ERROR_NULLPTR,
1280 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1281 }
1282 }
1283
1284 /*
1285 * @tc.name: NotifySpecificWindowSessionProperty
1286 * @tc.desc: NotifySpecificWindowSessionProperty01 test
1287 * @tc.type: FUNC
1288 */
1289 HWTEST_F(WindowSceneSessionImplTest, NotifySpecificWindowSessionProperty, Function | SmallTest | Level3)
1290 {
1291 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1292 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1293 option->SetWindowName("NotifySpecificWindowSessionProperty");
1294 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1295
1296 SystemBarProperty property = SystemBarProperty();
1297 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1298 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1299 window->property_->SetPersistentId(190);
1300 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1301 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1302 ASSERT_NE(nullptr, session);
1303 window->hostSession_ = session;
1304 window->state_ = WindowState::STATE_HIDDEN;
1305 ASSERT_EQ(WMError::WM_OK,
1306 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1307 window->state_ = WindowState::STATE_SHOWN;
1308 ASSERT_EQ(WMError::WM_OK,
1309 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1310 }
1311
1312 /*
1313 * @tc.name: LimitCameraFloatWindowMininumSize
1314 * @tc.desc: LimitCameraFloatWindowMininumSize01 test
1315 * @tc.type: FUNC
1316 */
1317 HWTEST_F(WindowSceneSessionImplTest, LimitCameraFloatWindowMininumSize, Function | SmallTest | Level3)
1318 {
1319 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1320 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1321 option->SetWindowName("LimitCameraFloatWindowMininumSize");
1322 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1323 uint32_t width = 33;
1324 uint32_t height = 31;
1325 float vpr = 0.0f;
1326 window->LimitCameraFloatWindowMininumSize(width, height, vpr);
1327 }
1328
1329 /*
1330 * @tc.name: NotifyWindowNeedAvoid
1331 * @tc.desc: NotifyWindowNeedAvoid test
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(WindowSceneSessionImplTest, NotifyWindowNeedAvoid, Function | SmallTest | Level3)
1335 {
1336 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1337 option->SetWindowName("NotifyWindowNeedAvoid");
1338 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1339 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->NotifyWindowNeedAvoid(false));
1340
1341 window->state_ = WindowState::STATE_SHOWN;
1342 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1343 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1344 ASSERT_NE(nullptr, session);
1345 window->property_->SetPersistentId(190);
1346 window->hostSession_ = session;
1347 ASSERT_EQ(WMError::WM_OK, window->NotifyWindowNeedAvoid(false));
1348 }
1349
1350 /*
1351 * @tc.name: SetLayoutFullScreenByApiVersion
1352 * @tc.desc: SetLayoutFullScreenByApiVersion test
1353 * @tc.type: FUNC
1354 */
1355 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreenByApiVersion, Function | SmallTest | Level3)
1356 {
1357 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1358 option->SetWindowName("SetLayoutFullScreenByApiVersion");
1359 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1360 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreenByApiVersion(false));
1361 window->state_ = WindowState::STATE_SHOWN;
1362 window->property_->SetPersistentId(190);
1363 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1364 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1365 ASSERT_NE(nullptr, session);
1366 window->hostSession_ = session;
1367 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreenByApiVersion(false));
1368 }
1369
1370 /*
1371 * @tc.name: SetGlobalMaximizeMode
1372 * @tc.desc: SetGlobalMaximizeMode test
1373 * @tc.type: FUNC
1374 */
1375 HWTEST_F(WindowSceneSessionImplTest, SetGlobalMaximizeMode, Function | SmallTest | Level3)
1376 {
1377 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1378 option->SetWindowName("SetGlobalMaximizeMode");
1379 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1380 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1381
1382 window->state_ = WindowState::STATE_SHOWN;
1383 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1384 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1385 ASSERT_NE(nullptr, session);
1386 window->property_->SetPersistentId(190);
1387 window->hostSession_ = session;
1388 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1389 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1390
1391 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1392 ASSERT_EQ(WMError::WM_OK, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1393 }
1394
1395 /*
1396 * @tc.name: CheckParmAndPermission
1397 * @tc.desc: CheckParmAndPermission test
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(WindowSceneSessionImplTest, CheckParmAndPermission, Function | SmallTest | Level3)
1401 {
1402 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1403 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1404 window->property_->SetWindowName("CheckParmAndPermission");
1405 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1406
1407 auto surfaceNode = window->GetSurfaceNode();
1408 if (surfaceNode == nullptr) {
1409 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1410 } else {
1411 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1412 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1413 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1414 }
1415 }
1416
1417 /*
1418 * @tc.name: SetBackdropBlurStyle
1419 * @tc.desc: SetBackdropBlurStyle test
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(WindowSceneSessionImplTest, SetBackdropBlurStyle, Function | SmallTest | Level3)
1423 {
1424 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1425 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1426 window->property_->SetWindowName("SetBackdropBlurStyle");
1427 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1428 window->property_->SetDisplayId(3);
1429
1430 auto surfaceNode = window->GetSurfaceNode();
1431 if (surfaceNode == nullptr) {
1432 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1433 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1434 } else {
1435 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1436 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_THICK));
1437 }
1438 }
1439
1440 /*
1441 * @tc.name: SetTurnScreenOn
1442 * @tc.desc: SetTurnScreenOn test
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(WindowSceneSessionImplTest, SetTurnScreenOn, Function | SmallTest | Level3)
1446 {
1447 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1448 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1449 window->property_->SetWindowName("SetTurnScreenOn");
1450 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1451 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(false));
1452
1453 window->property_->SetPersistentId(1);
1454 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1455 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1456 ASSERT_NE(nullptr, session);
1457 window->hostSession_ = session;
1458 window->SetTurnScreenOn(false);
1459 }
1460
1461 /*
1462 * @tc.name: SetBlur
1463 * @tc.desc: SetBlur test
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(WindowSceneSessionImplTest, SetBlur, Function | SmallTest | Level3)
1467 {
1468 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1469 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1470 window->property_->SetWindowName("SetBlur");
1471
1472 auto surfaceNode = window->GetSurfaceNode();
1473 if (surfaceNode == nullptr) {
1474 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1475 } else {
1476 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1477 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBlur(-1.0));
1478 ASSERT_EQ(WMError::WM_OK, window->SetBlur(1.0));
1479 }
1480 }
1481
1482 /*
1483 * @tc.name: SetKeepScreenOn
1484 * @tc.desc: SetKeepScreenOn test
1485 * @tc.type: FUNC
1486 */
1487 HWTEST_F(WindowSceneSessionImplTest, SetKeepScreenOn, Function | SmallTest | Level3)
1488 {
1489 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1490 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1491 window->property_->SetWindowName("SetKeepScreenOn");
1492 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1493 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(false));
1494
1495 window->property_->SetPersistentId(1);
1496 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1497 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1498 ASSERT_NE(nullptr, session);
1499 window->hostSession_ = session;
1500 window->SetKeepScreenOn(false);
1501 ASSERT_FALSE(window->IsKeepScreenOn());
1502 }
1503
1504 /*
1505 * @tc.name: DestoryInner01
1506 * @tc.desc: DestoryInner01
1507 * @tc.type: FUNC
1508 */
1509 HWTEST_F(WindowSceneSessionImplTest, DestoryInner01, Function | SmallTest | Level2)
1510 {
1511 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1512 ASSERT_NE(nullptr, option);
1513 option->SetWindowName("DestoryInner01");
1514 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1515 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1516 ASSERT_NE(window, nullptr);
1517 SessionInfo sessionInfo = {"DestoryInnerBundle", "DestoryInnerModule", "DestoryInnerAbility"};
1518 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1519 ASSERT_NE(session, nullptr);
1520 window->property_->SetPersistentId(123);
1521 window->property_->SetExtensionFlag(true);
1522 window->hostSession_ = session;
1523 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->DestroyInner(true));
1524 window->property_->SetExtensionFlag(false);
1525 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->DestroyInner(true));
1526 }
1527
1528 /*
1529 * @tc.name: DestoryInner02
1530 * @tc.desc: DestoryInner02
1531 * @tc.type: FUNC
1532 */
1533 HWTEST_F(WindowSceneSessionImplTest, DestoryInner02, Function | SmallTest | Level2)
1534 {
1535 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1536 ASSERT_NE(nullptr, option);
1537 option->SetWindowName("DestoryInner02");
1538 option->SetWindowType(WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1539 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1540 ASSERT_NE(window, nullptr);
1541 SessionInfo sessionInfo = {"DestoryInnerBundle", "DestoryInnerModule", "DestoryInnerAbility"};
1542 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1543 ASSERT_NE(session, nullptr);
1544 window->property_->SetPersistentId(134);
1545 window->property_->SetExtensionFlag(true);
1546 window->hostSession_ = session;
1547 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->DestroyInner(true));
1548 window->property_->SetExtensionFlag(false);
1549 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->DestroyInner(true));
1550 }
1551
1552 /*
1553 * @tc.name: SetPrivacyMode
1554 * @tc.desc: SetPrivacyMode test
1555 * @tc.type: FUNC
1556 */
1557 HWTEST_F(WindowSceneSessionImplTest, SetPrivacyMode, Function | SmallTest | Level3)
1558 {
1559 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1560 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1561 window->property_->SetWindowName("SetPrivacyMode");
1562 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1563 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetPrivacyMode(false));
1564
1565 window->property_->SetPersistentId(1);
1566 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1567 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1568 ASSERT_NE(nullptr, session);
1569 window->hostSession_ = session;
1570 if (WMError::WM_OK == window->SetPrivacyMode(false)) {
1571 ASSERT_EQ(WMError::WM_OK, window->SetPrivacyMode(false));
1572 ASSERT_EQ(false, window->IsPrivacyMode());
1573 } else if (WMError::WM_DO_NOTHING == window->SetPrivacyMode(false)) {
1574 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetPrivacyMode(false));
1575 }
1576 }
1577
1578 /**
1579 * @tc.name: IsPrivacyMode
1580 * @tc.desc: Set window privacy mode as true and false
1581 * @tc.type: FUNC
1582 */
1583 HWTEST_F(WindowSceneSessionImplTest, IsPrivacyModec, Function | SmallTest | Level3)
1584 {
1585 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1586 ASSERT_NE(nullptr, option);
1587 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1588 ASSERT_NE(nullptr, window);
1589 window->property_->SetWindowName("IsPrivacyModec");
1590 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1591 window->property_->SetPersistentId(1);
1592 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1593 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1594 ASSERT_NE(nullptr, session);
1595 window->hostSession_ = session;
1596 window->SetPrivacyMode(true);
1597 ASSERT_EQ(true, window->IsPrivacyMode());
1598 window->SetPrivacyMode(false);
1599 ASSERT_EQ(false, window->IsPrivacyMode());
1600 }
1601
1602 /*
1603 * @tc.name: SetSystemPrivacyMode
1604 * @tc.desc: SetSystemPrivacyMode test
1605 * @tc.type: FUNC
1606 */
1607 HWTEST_F(WindowSceneSessionImplTest, SetSystemPrivacyMode, Function | SmallTest | Level3)
1608 {
1609 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1610 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1611 window->property_->SetWindowName("SetSystemPrivacyMode");
1612 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1613 window->SetSystemPrivacyMode(false);
1614 ASSERT_EQ(false, window->property_->GetSystemPrivacyMode());
1615 }
1616
1617 /*
1618 * @tc.name: SetSnapshotSkip
1619 * @tc.desc: SetSnapshotSkip test
1620 * @tc.type: FUNC
1621 */
1622 HWTEST_F(WindowSceneSessionImplTest, SetSnapshotSkip, Function | SmallTest | Level3)
1623 {
1624 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1625 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1626 window->property_->SetWindowName("SetSnapshotSkip");
1627 window->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1628 window->property_->SetPersistentId(1);
1629 auto surfaceNode_mocker = CreateRSSurfaceNode();
1630 if (surfaceNode_mocker != nullptr) {
1631 ASSERT_NE(nullptr, surfaceNode_mocker);
1632 }
1633
1634 window->surfaceNode_ = surfaceNode_mocker;
1635 auto surfaceNode = window->GetSurfaceNode();
1636
1637 if (surfaceNode != nullptr) {
1638 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSnapshotSkip(false));
1639 } else {
1640 ASSERT_EQ(nullptr, surfaceNode);
1641 }
1642 }
1643
1644 /*
1645 * @tc.name: SetImmersiveModeEnabledState
1646 * @tc.desc: SetImmersiveModeEnabledState test
1647 * @tc.type: FUNC
1648 */
1649 HWTEST_F(WindowSceneSessionImplTest, SetImmersiveModeEnabledState, Function | SmallTest | Level3)
1650 {
1651 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1652 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1653 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1654
1655 window->property_->SetPersistentId(1);
1656 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1657 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1658 ASSERT_NE(nullptr, session);
1659 window->hostSession_ = session;
1660 window->property_->SetWindowName("SetImmersiveModeEnabledState");
1661 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1662 window->state_ = WindowState::STATE_CREATED;
1663 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1664
1665 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1666 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1667 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1668 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1669 ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
1670
1671 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1672 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1673 ASSERT_EQ(true, window->IsLayoutFullScreen());
1674 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1675 ASSERT_EQ(false, window->IsLayoutFullScreen());
1676 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1677 ASSERT_EQ(true, window->IsLayoutFullScreen());
1678 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1679 ASSERT_EQ(false, window->IsLayoutFullScreen());
1680
1681 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1682 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1683 ASSERT_EQ(true, window->IsLayoutFullScreen());
1684 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1685 ASSERT_EQ(WMError::WM_OK, window->MaximizeFloating());
1686 ASSERT_EQ(true, window->IsLayoutFullScreen());
1687 }
1688
1689 /*
1690 * @tc.name: SetLayoutFullScreen
1691 * @tc.desc: SetLayoutFullScreen test
1692 * @tc.type: FUNC
1693 */
1694 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreen, Function | SmallTest | Level3)
1695 {
1696 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1697 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1698 window->property_->SetWindowName("SetLayoutFullScreen");
1699 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1700 window->SetLayoutFullScreen(false);
1701
1702 window->property_->SetPersistentId(1);
1703 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1704 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1705 ASSERT_NE(nullptr, session);
1706 window->hostSession_ = session;
1707 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1708 ASSERT_EQ(false, window->IsLayoutFullScreen());
1709 }
1710
1711 /**
1712 * @tc.name: SetTitleAndDockHoverShown
1713 * @tc.desc: SetTitleAndDockHoverShown test
1714 * @tc.type: FUNC
1715 */
1716 HWTEST_F(WindowSceneSessionImplTest, SetTitleAndDockHoverShown, Function | SmallTest | Level3)
1717 {
1718 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1719 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1720
1721 window->property_->SetPersistentId(1);
1722 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1723 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1724 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1725 window->hostSession_ = session;
1726 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetTitleAndDockHoverShown(true, true));
1727
1728 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1729 window->windowSystemConfig_.uiType_ = "phone";
1730 EXPECT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetTitleAndDockHoverShown(true, true));
1731
1732 window->windowSystemConfig_.uiType_ = "pc";
1733 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1734 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetTitleAndDockHoverShown(true, true));
1735 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1736 EXPECT_EQ(WMError::WM_OK, window->SetTitleAndDockHoverShown(true, true));
1737 }
1738
1739 /*
1740 * @tc.name: SetFullScreen
1741 * @tc.desc: SetFullScreen test
1742 * @tc.type: FUNC
1743 */
1744 HWTEST_F(WindowSceneSessionImplTest, SetFullScreen, Function | SmallTest | Level3)
1745 {
1746 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1747 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1748 window->property_->SetWindowName("SetFullScreen");
1749 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1750 window->SetFullScreen(false);
1751 window->property_->SetPersistentId(1);
1752 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1753 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1754 ASSERT_NE(nullptr, session);
1755 window->hostSession_ = session;
1756
1757 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
1758 ASSERT_EQ(false, window->IsFullScreen());
1759 }
1760
1761 /*
1762 * @tc.name: SetShadowOffsetX
1763 * @tc.desc: SetShadowOffsetX test
1764 * @tc.type: FUNC
1765 */
1766 HWTEST_F(WindowSceneSessionImplTest, SetShadowOffsetX, Function | SmallTest | Level3)
1767 {
1768 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1769 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1770 window->property_->SetWindowName("SetShadowOffsetX");
1771 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1772 auto surfaceNode = window->GetSurfaceNode();
1773 if (surfaceNode == nullptr) {
1774 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1775 } else {
1776 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetX(1.0));
1777 }
1778 }
1779
1780 /*
1781 * @tc.name: SetGestureBackEnabled
1782 * @tc.desc: SetGestureBackEnabled test
1783 * @tc.type: FUNC
1784 */
1785 HWTEST_F(WindowSceneSessionImplTest, SetGestureBackEnabled, Function | SmallTest | Level3)
1786 {
1787 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1788 ASSERT_NE(nullptr, option);
1789 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1790 ASSERT_NE(nullptr, window);
1791 window->property_->SetPersistentId(1);
1792 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1793 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1794 ASSERT_NE(nullptr, session);
1795 window->hostSession_ = session;
1796 window->property_->SetWindowName("SetGestureBackEnabled");
1797 window->windowSystemConfig_.uiType_ = "pc";
1798 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetGestureBackEnabled(false));
1799 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1800 window->state_ = WindowState::STATE_CREATED;
1801 window->windowSystemConfig_.uiType_ = "phone";
1802 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGestureBackEnabled(false));
1803 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1804 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1805 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(false));
1806 bool enable = true;
1807 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
1808 ASSERT_EQ(false, enable);
1809 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(true));
1810 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
1811 ASSERT_EQ(true, enable);
1812 }
1813 }
1814 } // namespace Rosen
1815 } // namespace OHOS
1816