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: Close01
649 * @tc.desc: Close
650 * @tc.type: FUNC
651 */
652 HWTEST_F(WindowSceneSessionImplTest, Close01, Function | SmallTest | Level2)
653 {
654 sptr<WindowOption> option = new (std::nothrow) WindowOption();
655 option->SetWindowName("Close01");
656 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
657 ASSERT_NE(nullptr, windowSceneSession);
658 windowSceneSession->property_->SetPersistentId(1);
659 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
660 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
661 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
662 ASSERT_NE(nullptr, session);
663 windowSceneSession->hostSession_ = session;
664 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Close());
665 }
666
667 /**
668 * @tc.name: Close02
669 * @tc.desc: Close
670 * @tc.type: FUNC
671 */
672 HWTEST_F(WindowSceneSessionImplTest, Close02, Function | SmallTest | Level2)
673 {
674 sptr<WindowOption> option = new (std::nothrow) WindowOption();
675 option->SetWindowName("Close02");
676 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
677 ASSERT_NE(nullptr, windowSceneSession);
678 windowSceneSession->property_->SetPersistentId(-1);
679 windowSceneSession->property_->SetParentPersistentId(-1);
680 windowSceneSession->property_->SetPersistentId(1);
681 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
682 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
683 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
684 ASSERT_NE(nullptr, session);
685 }
686
687 /**
688 * @tc.name: SetActive01
689 * @tc.desc: SetActive
690 * @tc.type: FUNC
691 */
692 HWTEST_F(WindowSceneSessionImplTest, SetActive01, Function | SmallTest | Level2)
693 {
694 sptr<WindowOption> option = new (std::nothrow) WindowOption();
695 option->SetWindowName("SetActive01");
696 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
697 ASSERT_NE(nullptr, windowSceneSession);
698 windowSceneSession->property_->SetPersistentId(1);
699 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
700 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
701 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
702 ASSERT_NE(nullptr, session);
703
704 windowSceneSession->hostSession_ = session;
705 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(false));
706 ASSERT_EQ(WSError::WS_OK, windowSceneSession->SetActive(true));
707 }
708
709 /**
710 * @tc.name: Recover01
711 * @tc.desc: Recover
712 * @tc.type: FUNC
713 */
714 HWTEST_F(WindowSceneSessionImplTest, Recover01, Function | SmallTest | Level2)
715 {
716 sptr<WindowOption> option = new (std::nothrow) WindowOption();
717 option->SetWindowName("Recover01");
718 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
719 ASSERT_NE(nullptr, windowSceneSession);
720
721 windowSceneSession->property_->SetPersistentId(1);
722 windowSceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
723 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
724 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
725 ASSERT_NE(nullptr, session);
726 windowSceneSession->hostSession_ = session;
727 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Recover());
728 }
729
730 /**
731 * @tc.name: Maximize01
732 * @tc.desc: Maximize
733 * @tc.type: FUNC
734 */
735 HWTEST_F(WindowSceneSessionImplTest, Maximize01, Function | SmallTest | Level2)
736 {
737 sptr<WindowOption> option = new (std::nothrow) WindowOption();
738 option->SetWindowName("Maximize01");
739 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
740 sptr<WindowSceneSessionImpl> windowSceneSession = new (std::nothrow) WindowSceneSessionImpl(option);
741 ASSERT_NE(nullptr, windowSceneSession);
742 windowSceneSession->property_->SetPersistentId(1);
743 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
744 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
745 ASSERT_NE(nullptr, session);
746 windowSceneSession->hostSession_ = session;
747 ASSERT_EQ(WMError::WM_OK, windowSceneSession->Maximize());
748 }
749
750 /**
751 * @tc.name: Hide01
752 * @tc.desc: Hide session
753 * @tc.type: FUNC
754 */
755 HWTEST_F(WindowSceneSessionImplTest, Hide01, Function | SmallTest | Level2)
756 {
757 sptr<WindowOption> option = new (std::nothrow) WindowOption();
758 option->SetWindowName("Hide01");
759 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
760 ASSERT_NE(nullptr, window);
761 window->property_->SetPersistentId(1);
762 // show with null session
763 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->Hide(2, false, false));
764
765 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
766 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
767 ASSERT_NE(nullptr, session);
768 window->hostSession_ = session;
769 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
770 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
771
772 window->state_ = WindowState::STATE_CREATED;
773 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
774 window->state_ = WindowState::STATE_SHOWN;
775 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
776 ASSERT_EQ(WMError::WM_OK, window->Hide(2, false, false));
777
778 window->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
779 if (window->Destroy(false) == WMError::WM_OK) {
780 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Destroy(false));
781 }
782 }
783
784 /**
785 * @tc.name: Show01
786 * @tc.desc: Show session
787 * @tc.type: FUNC
788 */
789 HWTEST_F(WindowSceneSessionImplTest, Show01, Function | SmallTest | Level2)
790 {
791 sptr<WindowOption> option = new (std::nothrow) WindowOption();
792 option->SetWindowName("Show01");
793 option->SetDisplayId(0);
794 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
795 ASSERT_NE(nullptr, window);
796 window->property_->SetPersistentId(1);
797
798 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
799 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
800 ASSERT_NE(nullptr, session);
801
802 window->hostSession_ = session;
803 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
804
805 window->state_ = WindowState::STATE_CREATED;
806 ASSERT_EQ(WMError::WM_OK, window->Show(2, false));
807 ASSERT_EQ(WMError::WM_OK, window->Destroy(false));
808 }
809
810 /**
811 * @tc.name: NotifyDrawingCompleted
812 * @tc.desc: NotifyDrawingCompleted session
813 * @tc.type: FUNC
814 */
815 HWTEST_F(WindowSceneSessionImplTest, NotifyDrawingCompleted, Function | SmallTest | Level2)
816 {
817 sptr<WindowOption> option = new (std::nothrow) WindowOption();
818 ASSERT_NE(nullptr, option);
819 option->SetWindowName("NotifyDrawingCompleted");
820 option->SetDisplayId(0);
821 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
822 ASSERT_NE(nullptr, window);
823 ASSERT_NE(nullptr, window->property_);
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 window->NotifyDrawingCompleted();
832 }
833
834 /**
835 * @tc.name: SetBackgroundColor01
836 * @tc.desc: test SetBackgroundColor withow uiContent
837 * @tc.type: FUNC
838 */
839 HWTEST_F(WindowSceneSessionImplTest, SetBackgroundColor01, Function | SmallTest | Level3)
840 {
841 sptr<WindowOption> option = new (std::nothrow) WindowOption();
842 option->SetWindowName("SetBackgroundColor01");
843 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
844 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
845 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
846 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
847 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
848 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
849 ASSERT_NE(nullptr, session);
850
851 std::shared_ptr<AbilityRuntime::Context> context;
852 ASSERT_EQ(WMError::WM_OK, window->Create(context, session));
853
854 window->property_->SetPersistentId(1);
855 window->Show();
856 window->Destroy(true);
857 }
858
859 /*
860 * @tc.name: SetTransparent
861 * @tc.desc: SetTransparent test
862 * @tc.type: FUNC
863 */
864 HWTEST_F(WindowSceneSessionImplTest, SetTransparent, Function | SmallTest | Level3)
865 {
866 sptr<WindowOption> option = new (std::nothrow) WindowOption();
867 option->SetWindowName("SetTransparent");
868 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
869 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
870 window->property_->SetPersistentId(1);
871 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
872 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
873 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
874 ASSERT_NE(nullptr, session);
875 window->hostSession_ = session;
876 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
877 window->SetBackgroundColor(333);
878 if (window->SetTransparent(true) == WMError::WM_OK) {
879 ASSERT_EQ(WMError::WM_OK, window->SetTransparent(true));
880 }
881 }
882
883 /*
884 * @tc.name: SetAspectRatio
885 * @tc.desc: SetAspectRatio test
886 * @tc.type: FUNC
887 */
888 HWTEST_F(WindowSceneSessionImplTest, SetAspectRatio, Function | SmallTest | Level3)
889 {
890 sptr<WindowOption> option = new (std::nothrow) WindowOption();
891 option->SetWindowName("SetAspectRatio");
892 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
893 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
894 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetAspectRatio(0.1));
895
896 window->property_->SetPersistentId(1);
897 window->property_->SetDisplayId(3);
898 WindowLimits windowLimits = { 3, 3, 3, 3, 2.0, 2.0 };
899 window->property_->SetWindowLimits(windowLimits);
900 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
901 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
902 ASSERT_NE(nullptr, session);
903 window->hostSession_ = session;
904 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(0.1));
905 }
906
907 /*
908 * @tc.name: ResetAspectRatio
909 * @tc.desc: ResetAspectRatio test GetAvoidAreaByType
910 * @tc.type: FUNC
911 */
912 HWTEST_F(WindowSceneSessionImplTest, ResetAspectRatio, Function | SmallTest | Level3)
913 {
914 sptr<WindowOption> option = new (std::nothrow) WindowOption();
915 option->SetWindowName("ResetAspectRatio");
916 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
917 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
918 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
919 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
920 ASSERT_NE(nullptr, session);
921 window->hostSession_ = session;
922 ASSERT_EQ(WMError::WM_OK, window->ResetAspectRatio());
923 }
924
925 /*
926 * @tc.name: GetAvoidAreaByType
927 * @tc.desc: GetAvoidAreaByType test
928 * @tc.type: FUNC
929 */
930 HWTEST_F(WindowSceneSessionImplTest, GetAvoidAreaByType, Function | SmallTest | Level3)
931 {
932 sptr<WindowOption> option = new (std::nothrow) WindowOption();
933 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
934 option->SetWindowName("GetAvoidAreaByType");
935 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
936
937 window->property_->SetPersistentId(1);
938 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
939 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
940 ASSERT_NE(nullptr, session);
941 AvoidArea avoidarea;
942 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
943 }
944
945 /*
946 * @tc.name: Immersive
947 * @tc.desc: Immersive01 test
948 * @tc.type: FUNC
949 */
950 HWTEST_F(WindowSceneSessionImplTest, Immersive, Function | SmallTest | Level3)
951 {
952 sptr<WindowOption> option = new (std::nothrow) WindowOption();
953 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
954 option->SetWindowName("Immersive");
955 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
956
957
958 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(false));
959 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
960 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
961 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
962 ASSERT_NE(nullptr, session);
963 window->hostSession_ = session;
964
965 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(false));
966 ASSERT_EQ(false, window->IsLayoutFullScreen());
967 ASSERT_EQ(false, window->IsFullScreen());
968 }
969
970 /*
971 * @tc.name: SystemBarProperty
972 * @tc.desc: SystemBarProperty01 test
973 * @tc.type: FUNC
974 */
975 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty, Function | SmallTest | Level3)
976 {
977 sptr<WindowOption> option = new (std::nothrow) WindowOption();
978 option->SetWindowName("SystemBarProperty");
979 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
980 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
981
982 SystemBarProperty property = SystemBarProperty();
983 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
984 window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
985 }
986
987 /*
988 * @tc.name: SystemBarProperty02
989 * @tc.desc: SystemBarProperty02 test
990 * @tc.type: FUNC
991 */
992 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty02, Function | SmallTest | Level3)
993 {
994 sptr<WindowOption> option = new (std::nothrow) WindowOption();
995 option->SetWindowName("SystemBarProperty02");
996 ASSERT_NE(nullptr, option);
997 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
998 ASSERT_NE(nullptr, window);
999
1000 window->state_ = WindowState::STATE_SHOWN;
1001 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1002 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1003 ASSERT_NE(nullptr, session);
1004 window->property_->SetPersistentId(1);
1005 window->hostSession_ = session;
1006
1007 SystemBarProperty property;
1008 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1009 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1010
1011 property.enableAnimation_ = false;
1012 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1013 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1014 }
1015
1016 /*
1017 * @tc.name: SystemBarProperty03
1018 * @tc.desc: SystemBarProperty03 test
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty03, Function | SmallTest | Level3)
1022 {
1023 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1024 option->SetWindowName("SystemBarProperty03");
1025 ASSERT_NE(nullptr, option);
1026 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1027 ASSERT_NE(nullptr, window);
1028
1029 window->state_ = WindowState::STATE_SHOWN;
1030 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1031 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1032 ASSERT_NE(nullptr, session);
1033 window->property_->SetPersistentId(1);
1034 window->hostSession_ = session;
1035
1036 SystemBarProperty property;
1037 property.enableAnimation_ = true;
1038 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1039 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1040 }
1041
1042 /*
1043 * @tc.name: SystemBarProperty04
1044 * @tc.desc: SystemBarProperty04 test
1045 * @tc.type: FUNC
1046 */
1047 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty04, Function | SmallTest | Level3)
1048 {
1049 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1050 option->SetWindowName("SystemBarProperty04");
1051 ASSERT_NE(nullptr, option);
1052 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1053 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1054 ASSERT_NE(nullptr, window);
1055
1056 SystemBarProperty property;
1057 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1058 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1059 }
1060
1061 /*
1062 * @tc.name: SystemBarProperty05
1063 * @tc.desc: SystemBarProperty05 test
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty05, Function | SmallTest | Level3)
1067 {
1068 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1069 option->SetWindowName("SystemBarProperty05");
1070 ASSERT_NE(nullptr, option);
1071 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1072 ASSERT_NE(nullptr, window);
1073
1074 window->state_ = WindowState::STATE_SHOWN;
1075 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1076 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1077 ASSERT_NE(nullptr, session);
1078 window->property_->SetPersistentId(1);
1079 window->hostSession_ = session;
1080
1081 SystemBarProperty property;
1082 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1083 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1084
1085 property.enableAnimation_ = false;
1086 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1087 ASSERT_FALSE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1088 }
1089
1090 /*
1091 * @tc.name: SystemBarProperty06
1092 * @tc.desc: SystemBarProperty06 test
1093 * @tc.type: FUNC
1094 */
1095 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty06, Function | SmallTest | Level3)
1096 {
1097 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1098 option->SetWindowName("SystemBarProperty06");
1099 ASSERT_NE(nullptr, option);
1100 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1101 ASSERT_NE(nullptr, window);
1102
1103 window->state_ = WindowState::STATE_SHOWN;
1104 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1105 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1106 ASSERT_NE(nullptr, session);
1107 window->property_->SetPersistentId(1);
1108 window->hostSession_ = session;
1109
1110 SystemBarProperty property;
1111 property.enableAnimation_ = true;
1112 ASSERT_EQ(WMError::WM_OK, window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1113 ASSERT_TRUE(window->property_->GetSystemBarProperty()[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_);
1114 }
1115
1116 /*
1117 * @tc.name: SystemBarProperty07
1118 * @tc.desc: SystemBarProperty07 test
1119 * @tc.type: FUNC
1120 */
1121 HWTEST_F(WindowSceneSessionImplTest, SystemBarProperty07, Function | SmallTest | Level3)
1122 {
1123 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1124 option->SetWindowName("SystemBarProperty07");
1125 ASSERT_NE(nullptr, option);
1126 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1127 ASSERT_NE(nullptr, window);
1128
1129 window->state_ = WindowState::STATE_SHOWN;
1130 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1131 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1132 ASSERT_NE(nullptr, session);
1133 window->property_->SetPersistentId(1);
1134 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
1135 window->hostSession_ = session;
1136
1137 SystemBarProperty property;
1138 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1139 ASSERT_EQ(SystemBarSettingFlag::DEFAULT_SETTING,
1140 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1141
1142 property.enable_ = false;
1143 property.settingFlag_ = SystemBarSettingFlag::ENABLE_SETTING;
1144 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1145 ASSERT_EQ(SystemBarSettingFlag::ENABLE_SETTING,
1146 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1147
1148 property.backgroundColor_ = 0xB3000000;
1149 property.settingFlag_ = SystemBarSettingFlag::COLOR_SETTING;
1150 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1151 ASSERT_EQ(SystemBarSettingFlag::COLOR_SETTING,
1152 window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR).settingFlag_);
1153
1154 property.enable_ = true;
1155 property.backgroundColor_ = 0x4C000000;
1156 property.settingFlag_ = SystemBarSettingFlag::ALL_SETTING;
1157 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1158 ASSERT_EQ(WMError::WM_OK, window->Destroy(true));
1159 }
1160
1161 /*
1162 * @tc.name: SetSystemBarProperties
1163 * @tc.desc: SetSystemBarProperties test
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(WindowSceneSessionImplTest, SetSystemBarProperties, Function | SmallTest | Level3)
1167 {
1168 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1169 ASSERT_NE(nullptr, option);
1170 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1171 option->SetWindowName("SetSystemBarProperties");
1172 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1173 ASSERT_NE(nullptr, window);
1174 window->state_ = WindowState::STATE_SHOWN;
1175 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1176 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1177 ASSERT_NE(nullptr, session);
1178 window->property_->SetPersistentId(1);
1179 window->hostSession_ = session;
1180 std::map<WindowType, SystemBarProperty> properties;
1181 std::map<WindowType, SystemBarPropertyFlag> propertyFlags;
1182 SystemBarProperty current = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
1183 SystemBarProperty property;
1184 properties[WindowType::WINDOW_TYPE_STATUS_BAR] = property;
1185 SystemBarPropertyFlag propertyFlag;
1186 propertyFlag.contentColorFlag = true;
1187 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR] = propertyFlag;
1188 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperties(properties, propertyFlags));
1189 if (property.contentColor_ != current.contentColor_) {
1190 std::map<WindowType, SystemBarProperty> currProperties;
1191 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(currProperties));
1192 ASSERT_EQ(currProperties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_, property.contentColor_);
1193 }
1194 }
1195
1196 /*
1197 * @tc.name: GetSystemBarProperties
1198 * @tc.desc: GetSystemBarProperties test
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(WindowSceneSessionImplTest, GetSystemBarProperties, Function | SmallTest | Level3)
1202 {
1203 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1204 ASSERT_NE(nullptr, option);
1205 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1206 option->SetWindowName("GetSystemBarProperties");
1207 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1208 ASSERT_NE(nullptr, window);
1209 std::map<WindowType, SystemBarProperty> properties;
1210 ASSERT_EQ(WMError::WM_OK, window->GetSystemBarProperties(properties));
1211 }
1212
1213 /*
1214 * @tc.name: SpecificBarProperty
1215 * @tc.desc: SpecificBarProperty01 test
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(WindowSceneSessionImplTest, SpecificBarProperty, Function | SmallTest | Level3)
1219 {
1220 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1221 option->SetWindowName("SpecificBarProperty");
1222 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1223 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1224
1225 SystemBarProperty property = SystemBarProperty();
1226 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1227 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1228 if (window->property_ == nullptr) {
1229 ASSERT_EQ(WMError::WM_ERROR_NULLPTR,
1230 window->SetSpecificBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1231 }
1232 }
1233
1234 /*
1235 * @tc.name: NotifySpecificWindowSessionProperty
1236 * @tc.desc: NotifySpecificWindowSessionProperty01 test
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(WindowSceneSessionImplTest, NotifySpecificWindowSessionProperty, Function | SmallTest | Level3)
1240 {
1241 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1242 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1243 option->SetWindowName("NotifySpecificWindowSessionProperty");
1244 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1245
1246 SystemBarProperty property = SystemBarProperty();
1247 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW,
1248 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1249 window->property_->SetPersistentId(190);
1250 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1251 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1252 ASSERT_NE(nullptr, session);
1253 window->hostSession_ = session;
1254 window->state_ = WindowState::STATE_HIDDEN;
1255 ASSERT_EQ(WMError::WM_OK,
1256 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1257 window->state_ = WindowState::STATE_SHOWN;
1258 ASSERT_EQ(WMError::WM_OK,
1259 window->NotifySpecificWindowSessionProperty(WindowType::WINDOW_TYPE_STATUS_BAR, property));
1260 }
1261
1262 /*
1263 * @tc.name: LimitCameraFloatWindowMininumSize
1264 * @tc.desc: LimitCameraFloatWindowMininumSize01 test
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(WindowSceneSessionImplTest, LimitCameraFloatWindowMininumSize, Function | SmallTest | Level3)
1268 {
1269 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1270 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1271 option->SetWindowName("LimitCameraFloatWindowMininumSize");
1272 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1273 uint32_t width = 33;
1274 uint32_t height = 31;
1275 float vpr = 0.0f;
1276 window->LimitCameraFloatWindowMininumSize(width, height, vpr);
1277 }
1278
1279 /*
1280 * @tc.name: NotifyWindowNeedAvoid
1281 * @tc.desc: NotifyWindowNeedAvoid test
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(WindowSceneSessionImplTest, NotifyWindowNeedAvoid, Function | SmallTest | Level3)
1285 {
1286 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1287 option->SetWindowName("NotifyWindowNeedAvoid");
1288 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1289 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->NotifyWindowNeedAvoid(false));
1290
1291 window->state_ = WindowState::STATE_SHOWN;
1292 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1293 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1294 ASSERT_NE(nullptr, session);
1295 window->property_->SetPersistentId(190);
1296 window->hostSession_ = session;
1297 ASSERT_EQ(WMError::WM_OK, window->NotifyWindowNeedAvoid(false));
1298 }
1299
1300 /*
1301 * @tc.name: SetLayoutFullScreenByApiVersion
1302 * @tc.desc: SetLayoutFullScreenByApiVersion test
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreenByApiVersion, Function | SmallTest | Level3)
1306 {
1307 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1308 option->SetWindowName("SetLayoutFullScreenByApiVersion");
1309 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1310 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreenByApiVersion(false));
1311 window->state_ = WindowState::STATE_SHOWN;
1312 window->property_->SetPersistentId(190);
1313 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1314 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1315 ASSERT_NE(nullptr, session);
1316 window->hostSession_ = session;
1317 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreenByApiVersion(false));
1318 }
1319
1320 /*
1321 * @tc.name: SetGlobalMaximizeMode
1322 * @tc.desc: SetGlobalMaximizeMode test
1323 * @tc.type: FUNC
1324 */
1325 HWTEST_F(WindowSceneSessionImplTest, SetGlobalMaximizeMode, Function | SmallTest | Level3)
1326 {
1327 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1328 option->SetWindowName("SetGlobalMaximizeMode");
1329 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1330 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1331
1332 window->state_ = WindowState::STATE_SHOWN;
1333 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1334 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1335 ASSERT_NE(nullptr, session);
1336 window->property_->SetPersistentId(190);
1337 window->hostSession_ = session;
1338 window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1339 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1340
1341 window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1342 ASSERT_EQ(WMError::WM_OK, window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER));
1343 }
1344
1345 /*
1346 * @tc.name: CheckParmAndPermission
1347 * @tc.desc: CheckParmAndPermission test
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(WindowSceneSessionImplTest, CheckParmAndPermission, Function | SmallTest | Level3)
1351 {
1352 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1353 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1354 window->property_->SetWindowName("CheckParmAndPermission");
1355 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1356
1357 auto surfaceNode = window->GetSurfaceNode();
1358 if (surfaceNode == nullptr) {
1359 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1360 } else {
1361 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1362 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1363 ASSERT_EQ(WMError::WM_OK, window->CheckParmAndPermission());
1364 }
1365 }
1366
1367 /*
1368 * @tc.name: SetBackdropBlurStyle
1369 * @tc.desc: SetBackdropBlurStyle test
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(WindowSceneSessionImplTest, SetBackdropBlurStyle, Function | SmallTest | Level3)
1373 {
1374 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1375 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1376 window->property_->SetWindowName("SetBackdropBlurStyle");
1377 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1378 window->property_->SetDisplayId(3);
1379
1380 auto surfaceNode = window->GetSurfaceNode();
1381 if (surfaceNode == nullptr) {
1382 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1383 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1384 } else {
1385 ASSERT_EQ(WMError::WM_OK, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_OFF));
1386 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackdropBlurStyle(WindowBlurStyle::WINDOW_BLUR_THICK));
1387 }
1388 }
1389
1390 /*
1391 * @tc.name: SetTurnScreenOn
1392 * @tc.desc: SetTurnScreenOn test
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(WindowSceneSessionImplTest, SetTurnScreenOn, Function | SmallTest | Level3)
1396 {
1397 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1398 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1399 window->property_->SetWindowName("SetTurnScreenOn");
1400 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1401 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(false));
1402
1403 window->property_->SetPersistentId(1);
1404 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1405 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1406 ASSERT_NE(nullptr, session);
1407 window->hostSession_ = session;
1408 window->SetTurnScreenOn(false);
1409 }
1410
1411 /*
1412 * @tc.name: SetBlur
1413 * @tc.desc: SetBlur test
1414 * @tc.type: FUNC
1415 */
1416 HWTEST_F(WindowSceneSessionImplTest, SetBlur, Function | SmallTest | Level3)
1417 {
1418 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1419 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1420 window->property_->SetWindowName("SetBlur");
1421
1422 auto surfaceNode = window->GetSurfaceNode();
1423 if (surfaceNode == nullptr) {
1424 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1425 } else {
1426 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1427 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBlur(-1.0));
1428 ASSERT_EQ(WMError::WM_OK, window->SetBlur(1.0));
1429 }
1430 }
1431
1432 /*
1433 * @tc.name: SetKeepScreenOn
1434 * @tc.desc: SetKeepScreenOn test
1435 * @tc.type: FUNC
1436 */
1437 HWTEST_F(WindowSceneSessionImplTest, SetKeepScreenOn, Function | SmallTest | Level3)
1438 {
1439 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1440 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1441 window->property_->SetWindowName("SetKeepScreenOn");
1442 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1443 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(false));
1444
1445 window->property_->SetPersistentId(1);
1446 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1447 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1448 ASSERT_NE(nullptr, session);
1449 window->hostSession_ = session;
1450 window->SetKeepScreenOn(false);
1451 ASSERT_FALSE(window->IsKeepScreenOn());
1452 }
1453
1454 /*
1455 * @tc.name: SetPrivacyMode
1456 * @tc.desc: SetPrivacyMode test
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(WindowSceneSessionImplTest, SetPrivacyMode, Function | SmallTest | Level3)
1460 {
1461 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1462 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1463 window->property_->SetWindowName("SetPrivacyMode");
1464 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1465 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetPrivacyMode(false));
1466
1467 window->property_->SetPersistentId(1);
1468 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1469 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1470 ASSERT_NE(nullptr, session);
1471 window->hostSession_ = session;
1472 if (WMError::WM_OK == window->SetPrivacyMode(false)) {
1473 ASSERT_EQ(WMError::WM_OK, window->SetPrivacyMode(false));
1474 ASSERT_EQ(false, window->IsPrivacyMode());
1475 } else if (WMError::WM_DO_NOTHING == window->SetPrivacyMode(false)) {
1476 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetPrivacyMode(false));
1477 }
1478 }
1479
1480 /*
1481 * @tc.name: IsPrivacyMode
1482 * @tc.desc: IsPrivacyMode test
1483 * @tc.type: FUNC
1484 */
1485 HWTEST_F(WindowSceneSessionImplTest, IsPrivacyModec, Function | SmallTest | Level3)
1486 {
1487 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1488 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1489 window->property_->SetWindowName("IsPrivacyModec");
1490 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1491 window->property_->SetPersistentId(1);
1492 window->SetPrivacyMode(false);
1493 }
1494
1495 /*
1496 * @tc.name: SetSystemPrivacyMode
1497 * @tc.desc: SetSystemPrivacyMode test
1498 * @tc.type: FUNC
1499 */
1500 HWTEST_F(WindowSceneSessionImplTest, SetSystemPrivacyMode, Function | SmallTest | Level3)
1501 {
1502 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1503 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1504 window->property_->SetWindowName("SetSystemPrivacyMode");
1505 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1506 window->SetSystemPrivacyMode(false);
1507 ASSERT_EQ(false, window->property_->GetSystemPrivacyMode());
1508 }
1509
1510 /*
1511 * @tc.name: SetSnapshotSkip
1512 * @tc.desc: SetSnapshotSkip test
1513 * @tc.type: FUNC
1514 */
1515 HWTEST_F(WindowSceneSessionImplTest, SetSnapshotSkip, Function | SmallTest | Level3)
1516 {
1517 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1518 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1519 window->property_->SetWindowName("SetSnapshotSkip");
1520 window->property_->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
1521 window->property_->SetPersistentId(1);
1522 auto surfaceNode_mocker = CreateRSSurfaceNode();
1523 if (surfaceNode_mocker != nullptr) {
1524 ASSERT_NE(nullptr, surfaceNode_mocker);
1525 }
1526
1527 window->surfaceNode_ = surfaceNode_mocker;
1528 auto surfaceNode = window->GetSurfaceNode();
1529
1530 if (surfaceNode != nullptr) {
1531 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSnapshotSkip(false));
1532 } else {
1533 ASSERT_EQ(nullptr, surfaceNode);
1534 }
1535 }
1536
1537 /*
1538 * @tc.name: SetImmersiveModeEnabledState
1539 * @tc.desc: SetImmersiveModeEnabledState test
1540 * @tc.type: FUNC
1541 */
1542 HWTEST_F(WindowSceneSessionImplTest, SetImmersiveModeEnabledState, Function | SmallTest | Level3)
1543 {
1544 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1545 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1546 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1547
1548 window->property_->SetPersistentId(1);
1549 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1550 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1551 ASSERT_NE(nullptr, session);
1552 window->hostSession_ = session;
1553 window->property_->SetWindowName("SetImmersiveModeEnabledState");
1554 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1555 window->state_ = WindowState::STATE_CREATED;
1556 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(false));
1557
1558 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1559 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1560 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1561 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1562 ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
1563
1564 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1565 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1566 ASSERT_EQ(true, window->IsLayoutFullScreen());
1567 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1568 ASSERT_EQ(false, window->IsLayoutFullScreen());
1569 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1570 ASSERT_EQ(true, window->IsLayoutFullScreen());
1571 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1572 ASSERT_EQ(false, window->IsLayoutFullScreen());
1573
1574 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1575 ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1576 ASSERT_EQ(true, window->IsLayoutFullScreen());
1577 ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1578 ASSERT_EQ(WMError::WM_OK, window->MaximizeFloating());
1579 ASSERT_EQ(true, window->IsLayoutFullScreen());
1580 }
1581
1582 /*
1583 * @tc.name: SetLayoutFullScreen
1584 * @tc.desc: SetLayoutFullScreen test
1585 * @tc.type: FUNC
1586 */
1587 HWTEST_F(WindowSceneSessionImplTest, SetLayoutFullScreen, Function | SmallTest | Level3)
1588 {
1589 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1590 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1591 window->property_->SetWindowName("SetLayoutFullScreen");
1592 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1593 window->SetLayoutFullScreen(false);
1594
1595 window->property_->SetPersistentId(1);
1596 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1597 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1598 ASSERT_NE(nullptr, session);
1599 window->hostSession_ = session;
1600 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1601 ASSERT_EQ(false, window->IsLayoutFullScreen());
1602 }
1603
1604 /*
1605 * @tc.name: SetFullScreen
1606 * @tc.desc: SetFullScreen test
1607 * @tc.type: FUNC
1608 */
1609 HWTEST_F(WindowSceneSessionImplTest, SetFullScreen, Function | SmallTest | Level3)
1610 {
1611 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1612 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1613 window->property_->SetWindowName("SetFullScreen");
1614 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1615 window->SetFullScreen(false);
1616 window->property_->SetPersistentId(1);
1617 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1618 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
1619 ASSERT_NE(nullptr, session);
1620 window->hostSession_ = session;
1621
1622 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
1623 ASSERT_EQ(false, window->IsFullScreen());
1624 }
1625
1626 /*
1627 * @tc.name: SetShadowOffsetX
1628 * @tc.desc: SetShadowOffsetX test
1629 * @tc.type: FUNC
1630 */
1631 HWTEST_F(WindowSceneSessionImplTest, SetShadowOffsetX, Function | SmallTest | Level3)
1632 {
1633 sptr<WindowOption> option = new (std::nothrow) WindowOption();
1634 sptr<WindowSceneSessionImpl> window = new (std::nothrow) WindowSceneSessionImpl(option);
1635 window->property_->SetWindowName("SetShadowOffsetX");
1636 window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1637 auto surfaceNode = window->GetSurfaceNode();
1638 if (surfaceNode == nullptr) {
1639 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->CheckParmAndPermission());
1640 } else {
1641 ASSERT_EQ(WMError::WM_OK, window->SetShadowOffsetX(1.0));
1642 }
1643 }
1644
1645 /*
1646 * @tc.name: SetGestureBackEnabled
1647 * @tc.desc: SetGestureBackEnabled test
1648 * @tc.type: FUNC
1649 */
1650 HWTEST_F(WindowSceneSessionImplTest, SetGestureBackEnabled, Function | SmallTest | Level3)
1651 {
1652 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1653 ASSERT_NE(nullptr, option);
1654 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
1655 ASSERT_NE(nullptr, window);
1656 window->property_->SetPersistentId(1);
1657 SessionInfo sessionInfo = {"CreateTestBundle", "CreateTestModule", "CreateTestAbility"};
1658 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1659 ASSERT_NE(nullptr, session);
1660 window->hostSession_ = session;
1661 window->property_->SetWindowName("SetGestureBackEnabled");
1662 window->windowSystemConfig_.uiType_ = "pc";
1663 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetGestureBackEnabled(false));
1664 window->property_->SetWindowType(WindowType::WINDOW_TYPE_PIP);
1665 window->state_ = WindowState::STATE_CREATED;
1666 window->windowSystemConfig_.uiType_ = "phone";
1667 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetGestureBackEnabled(false));
1668 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1669 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1670 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(false));
1671 bool enable = true;
1672 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
1673 ASSERT_EQ(false, enable);
1674 ASSERT_EQ(WMError::WM_OK, window->SetGestureBackEnabled(true));
1675 ASSERT_EQ(WMError::WM_OK, window->GetGestureBackEnabled(enable));
1676 ASSERT_EQ(true, enable);
1677 }
1678 }
1679 } // namespace Rosen
1680 } // namespace OHOS
1681