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