1 /*
2 * Copyright (c) 2025 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
18 #include "ability_context_impl.h"
19
20 #include "mock_session.h"
21 #include "window_scene_session_impl.h"
22 #include "window_test_utils.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 using Utils = WindowTestUtils;
30
31 class WindowSpecialWindowTest : public testing::Test {
32 public:
33 void SetUp() override;
34 void TearDown() override;
35
36 private:
37 static constexpr uint32_t TEST_SLEEP_S = 1; // test sleep time
38 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
39 };
40
SetUp()41 void WindowSpecialWindowTest::SetUp()
42 {
43 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
44 }
45
TearDown()46 void WindowSpecialWindowTest::TearDown()
47 {
48 abilityContext_ = nullptr;
49 }
50
51 namespace {
52 /**
53 * @tc.name: SetSubWindowModal01
54 * @tc.desc: SubWindowModal
55 * @tc.type: FUNC
56 */
57 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal01, TestSize.Level1)
58 {
59 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
60 option->SetWindowName("Window1_1");
61 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
62 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
63
64 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
65 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
66 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
67 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
68
69 window->property_->SetPersistentId(10011);
70 window->hostSession_ = session;
71
72 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
73 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(true));
74 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
75 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(false));
76 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
77 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(true));
78
79 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
80 window->property_->SetPcAppInpadCompatibleMode(true);
81 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
82 EXPECT_EQ(WMError::WM_OK, window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY));
83
84 window->Destroy(true, true);
85 }
86
87 /**
88 * @tc.name: SetSubWindowModal02
89 * @tc.desc: SubWindowModal
90 * @tc.type: FUNC
91 */
92 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal02, TestSize.Level1)
93 {
94 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
95 option->SetWindowName("Window1_2");
96 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
97 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
98
99 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
100 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
101 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
102 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
103
104 window->property_->SetPersistentId(10012);
105 window->hostSession_ = session;
106
107 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
108 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true));
109 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
110 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false));
111 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
112 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true));
113
114 window->Destroy(true, true);
115 }
116
117 /**
118 * @tc.name: SetSubWindowModal04
119 * @tc.desc: SubWindowModal
120 * @tc.type: FUNC
121 */
122 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal04, TestSize.Level1)
123 {
124 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
125 option->SetWindowName("Window1_4");
126 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
127 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
128
129 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
130 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
131 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
132 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
133
134 window->property_->SetPersistentId(10014);
135 window->hostSession_ = session;
136
137 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
138 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true));
139 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
140 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false));
141 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
142 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true));
143
144 window->Destroy(true, true);
145 }
146
147 /**
148 * @tc.name: SetSubWindowModal05
149 * @tc.desc: SubWindowModal
150 * @tc.type: FUNC
151 */
152 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal05, TestSize.Level1)
153 {
154 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
155 option->SetWindowName("Window1_5");
156 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
157 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
158
159 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
160 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
161 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
162 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
163
164 window->property_->SetPersistentId(10015);
165 window->hostSession_ = session;
166
167 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
168 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
169 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
170 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(false, ModalityType::WINDOW_MODALITY));
171 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
172 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
173
174 window->Destroy(true, true);
175 }
176
177 /**
178 * @tc.name: SetSubWindowModal06
179 * @tc.desc: SubWindowModal
180 * @tc.type: FUNC
181 */
182 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal06, TestSize.Level1)
183 {
184 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
185 option->SetWindowName("Window1_6");
186 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
187 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
188
189 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
190 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
191 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
192 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
193
194 window->property_->SetPersistentId(10016);
195 window->hostSession_ = session;
196
197 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
198 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
199 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
200 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false, ModalityType::WINDOW_MODALITY));
201 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
202 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
203
204 window->Destroy(true, true);
205 }
206
207 /**
208 * @tc.name: SetSubWindowModal07
209 * @tc.desc: SubWindowModal
210 * @tc.type: FUNC
211 */
212 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal07, TestSize.Level1)
213 {
214 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
215 option->SetWindowName("Window1_7");
216 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
217 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
218
219 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
220 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
221 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
222 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
223
224 window->property_->SetPersistentId(10017);
225 window->hostSession_ = session;
226
227 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
228 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
229 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
230 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false, ModalityType::WINDOW_MODALITY));
231 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
232 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::WINDOW_MODALITY));
233
234 window->Destroy(true, true);
235 }
236
237 /**
238 * @tc.name: SetSubWindowModal08
239 * @tc.desc: SubWindowModal
240 * @tc.type: FUNC
241 */
242 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal08, TestSize.Level1)
243 {
244 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
245 option->SetWindowName("Window1_8");
246 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
247 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
248
249 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
250 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
251 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
252 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
253
254 window->property_->SetPersistentId(10018);
255 window->hostSession_ = session;
256
257 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
258 WMError res1 = window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY);
259 ASSERT_EQ(res1, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
260
261 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
262 ASSERT_EQ(WMError::WM_OK, window->SetSubWindowModal(false, ModalityType::APPLICATION_MODALITY));
263
264 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
265 WMError res3 = window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY);
266 ASSERT_EQ(res3, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
267
268 window->Destroy(true, true);
269 }
270
271 /**
272 * @tc.name: SetSubWindowModal09
273 * @tc.desc: SubWindowModal
274 * @tc.type: FUNC
275 */
276 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal09, TestSize.Level1)
277 {
278 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
279 option->SetWindowName("Window1_9");
280 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
281 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
282
283 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
284 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
285 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
286 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
287
288 window->property_->SetPersistentId(10019);
289 window->hostSession_ = session;
290
291 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
292 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY));
293 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
294 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false, ModalityType::APPLICATION_MODALITY));
295 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
296 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY));
297
298 window->Destroy(true, true);
299 }
300
301 /**
302 * @tc.name: SetSubWindowModal10
303 * @tc.desc: SubWindowModal
304 * @tc.type: FUNC
305 */
306 HWTEST_F(WindowSpecialWindowTest, SetSubWindowModal10, TestSize.Level1)
307 {
308 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
309 option->SetWindowName("Window1_10");
310 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
311 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
312
313 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
314 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
315 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
316 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
317
318 window->property_->SetPersistentId(10110);
319 window->hostSession_ = session;
320
321 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
322 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY));
323 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
324 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(false, ModalityType::APPLICATION_MODALITY));
325 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
326 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetSubWindowModal(true, ModalityType::APPLICATION_MODALITY));
327
328 window->Destroy(true, true);
329 }
330
331 /**
332 * @tc.name: SetWindowModal01
333 * @tc.desc: WindowModal
334 * @tc.type: FUNC
335 */
336 HWTEST_F(WindowSpecialWindowTest, SetWindowModal01, TestSize.Level1)
337 {
338 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
339 option->SetWindowName("Window4_1");
340 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
341 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
342
343 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
344 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
345 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
346 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
347
348 window->property_->SetPersistentId(10041);
349 window->hostSession_ = session;
350
351 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
352 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
353 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
354 ASSERT_EQ(WMError::WM_OK, window->SetWindowModal(false));
355 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
356 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
357
358 window->Destroy(true, true);
359 }
360
361 /**
362 * @tc.name: SetWindowModal02
363 * @tc.desc: WindowModal
364 * @tc.type: FUNC
365 */
366 HWTEST_F(WindowSpecialWindowTest, SetWindowModal02, TestSize.Level1)
367 {
368 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
369 option->SetWindowName("Window4_2");
370 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
371 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
372
373 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
374 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
375 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
376 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
377
378 window->property_->SetPersistentId(10042);
379 window->hostSession_ = session;
380
381 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
382 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
383 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
384 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetWindowModal(false));
385 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
386 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
387
388 window->Destroy(true, true);
389 }
390
391 /**
392 * @tc.name: SetWindowModal03
393 * @tc.desc: WindowModal
394 * @tc.type: FUNC
395 */
396 HWTEST_F(WindowSpecialWindowTest, SetWindowModal03, TestSize.Level1)
397 {
398 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
399 option->SetWindowName("Window4_3");
400 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
401 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
402
403 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
404 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
405 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
406 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
407
408 window->property_->SetPersistentId(10043);
409 window->hostSession_ = session;
410
411 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
412 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
413 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
414 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->SetWindowModal(false));
415 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
416 ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SetWindowModal(true));
417
418 window->Destroy(true, true);
419 }
420
421 /**
422 * @tc.name: setWindowMask01
423 * @tc.desc: setWindowMask
424 * @tc.type: FUNC
425 */
426 HWTEST_F(WindowSpecialWindowTest, setWindowMask01, TestSize.Level1)
427 {
428 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
429 option->SetWindowName("Window3_1");
430 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
431 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
432
433 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
434 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
435 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
436 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
437
438 window->property_->SetPersistentId(10031);
439 window->hostSession_ = session;
440
441 std::vector<std::vector<uint32_t>> windowMask;
442 windowMask = { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } };
443 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
444 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
445 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
446 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
447 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
448 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
449
450 window->Destroy(true, true);
451 }
452
453 /**
454 * @tc.name: setWindowMask02
455 * @tc.desc: setWindowMask
456 * @tc.type: FUNC
457 */
458 HWTEST_F(WindowSpecialWindowTest, setWindowMask02, TestSize.Level1)
459 {
460 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
461 option->SetWindowName("Window3_2");
462 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
463 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
464
465 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
466 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
467 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
468 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
469
470 window->property_->SetPersistentId(10032);
471 window->hostSession_ = session;
472
473 std::vector<std::vector<uint32_t>> windowMask;
474 windowMask = { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } };
475 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
476 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
477 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
478 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
479 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
480 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
481
482 window->Destroy(true, true);
483 }
484
485 /**
486 * @tc.name: setWindowMask03
487 * @tc.desc: setWindowMask
488 * @tc.type: FUNC
489 */
490 HWTEST_F(WindowSpecialWindowTest, setWindowMask03, TestSize.Level1)
491 {
492 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
493 option->SetWindowName("Window3_3");
494 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
495 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
496
497 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
498 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
499 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
500 ASSERT_EQ(WMError::WM_OK, window->Create(abilityContext_, session));
501
502 window->property_->SetPersistentId(10033);
503 window->hostSession_ = session;
504
505 std::vector<std::vector<uint32_t>> windowMask;
506 windowMask = { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } };
507 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
508 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
509 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
510 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
511 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
512 ASSERT_EQ(WMError::WM_OK, window->SetWindowMask(windowMask));
513
514 window->Destroy(true, true);
515 }
516
517 } // namespace
518 } // namespace Rosen
519 } // namespace OHOS