1 /*
2 * Copyright (c) 2021 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 "window_option.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace Rosen {
24 namespace {
25 const SystemBarProperty SYS_BAR_PROP_DEFAULT;
26 const SystemBarProperty SYS_BAR_PROP_1(true, 0xE5111111, 0xE5222222);
27 const SystemBarProperty SYS_BAR_PROP_2(false, 0xE5222222, 0xE5333333);
28 const std::unordered_map<WindowType, SystemBarProperty>& SYS_BAR_PROPS_TEST = {
29 { WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP_1 },
30 { WindowType::WINDOW_TYPE_NAVIGATION_BAR, SYS_BAR_PROP_2 },
31 };
32 const std::unordered_map<WindowType, SystemBarProperty>& SYS_BAR_PROPS_DEFAULT = {
33 { WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP_DEFAULT },
34 { WindowType::WINDOW_TYPE_NAVIGATION_BAR, SYS_BAR_PROP_DEFAULT },
35 };
36 } // namespace
37 class WindowOptionTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 virtual void SetUp() override;
42 virtual void TearDown() override;
43 };
SetUpTestCase()44 void WindowOptionTest::SetUpTestCase() {}
45
TearDownTestCase()46 void WindowOptionTest::TearDownTestCase() {}
47
SetUp()48 void WindowOptionTest::SetUp() {}
49
TearDown()50 void WindowOptionTest::TearDown() {}
51
52 namespace {
53 /**
54 * @tc.name: WindowRect01
55 * @tc.desc: SetWindowRect/GetWindowRect
56 * @tc.type: FUNC
57 */
58 HWTEST_F(WindowOptionTest, WindowRect01, Function | SmallTest | Level2)
59 {
60 sptr<WindowOption> option = new WindowOption();
61 struct Rect rect = { 1, 2, 3u, 4u };
62 option->SetWindowRect(rect);
63
64 ASSERT_EQ(1, option->GetWindowRect().posX_);
65 ASSERT_EQ(2, option->GetWindowRect().posY_);
66 ASSERT_EQ(3u, option->GetWindowRect().width_);
67 ASSERT_EQ(4u, option->GetWindowRect().height_);
68 }
69
70 /**
71 * @tc.name: WindowType01
72 * @tc.desc: SetWindowType/GetWindowType
73 * @tc.type: FUNC
74 */
75 HWTEST_F(WindowOptionTest, WindowType01, Function | SmallTest | Level2)
76 {
77 sptr<WindowOption> option = new WindowOption();
78 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
79 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, option->GetWindowType());
80 }
81
82 /**
83 * @tc.name: WindowMode01
84 * @tc.desc: SetWindowMode/GetWindowMode
85 * @tc.type: FUNC
86 */
87 HWTEST_F(WindowOptionTest, WindowMode01, Function | SmallTest | Level2)
88 {
89 sptr<WindowOption> option = new WindowOption();
90 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
91 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, option->GetWindowMode());
92 }
93
94 /**
95 * @tc.name: WindowMode02
96 * @tc.desc: SetWindowMode/GetWindowMode
97 * @tc.type: FUNC
98 */
99 HWTEST_F(WindowOptionTest, WindowMode02, Function | SmallTest | Level2)
100 {
101 sptr<WindowOption> option = new WindowOption();
102 WindowMode defaultMode = option->GetWindowMode();
103 option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
104 ASSERT_EQ(defaultMode, option->GetWindowMode());
105 }
106
107 /**
108 * @tc.name: WindowMode03
109 * @tc.desc: SetWindowMode/GetWindowMode
110 * @tc.type: FUNC
111 */
112 HWTEST_F(WindowOptionTest, WindowMode03, Function | SmallTest | Level2)
113 {
114 sptr<WindowOption> option = new WindowOption();
115 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
116 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, option->GetWindowMode());
117 }
118
119 /**
120 * @tc.name: WindowMode04
121 * @tc.desc: SetWindowMode/GetWindowMode
122 * @tc.type: FUNC
123 */
124 HWTEST_F(WindowOptionTest, WindowMode04, Function | SmallTest | Level2)
125 {
126 sptr<WindowOption> option = new WindowOption();
127 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY);
128 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, option->GetWindowMode());
129 }
130
131 /**
132 * @tc.name: WindowMode05
133 * @tc.desc: SetWindowMode/GetWindowMode
134 * @tc.type: FUNC
135 */
136 HWTEST_F(WindowOptionTest, WindowMode05, Function | SmallTest | Level2)
137 {
138 sptr<WindowOption> option = new WindowOption();
139 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
140 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, option->GetWindowMode());
141 }
142
143 /**
144 * @tc.name: WindowMode06
145 * @tc.desc: SetWindowMode/GetWindowMode
146 * @tc.type: FUNC
147 */
148 HWTEST_F(WindowOptionTest, WindowMode06, Function | SmallTest | Level2)
149 {
150 sptr<WindowOption> option = new WindowOption();
151 option->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
152 ASSERT_EQ(WindowMode::WINDOW_MODE_PIP, option->GetWindowMode());
153 }
154
155 /**
156 * @tc.name: Focusable01
157 * @tc.desc: SetFocusable/GetFocusable
158 * @tc.type: FUNC
159 */
160 HWTEST_F(WindowOptionTest, Focusable01, Function | SmallTest | Level2)
161 {
162 sptr<WindowOption> option = new WindowOption();
163 option->SetFocusable(true);
164 ASSERT_EQ(true, option->GetFocusable());
165 }
166
167 /**
168 * @tc.name: Touchable01
169 * @tc.desc: SetTouchable/GetTouchable
170 * @tc.type: FUNC
171 */
172 HWTEST_F(WindowOptionTest, Touchable01, Function | SmallTest | Level2)
173 {
174 sptr<WindowOption> option = new WindowOption();
175 option->SetTouchable(true);
176 ASSERT_EQ(true, option->GetTouchable());
177 }
178
179 /**
180 * @tc.name: DisplayId01
181 * @tc.desc: SetDisplayId/GetDisplayId
182 * @tc.type: FUNC
183 */
184 HWTEST_F(WindowOptionTest, DisplayId01, Function | SmallTest | Level2)
185 {
186 sptr<WindowOption> option = new WindowOption();
187 option->SetDisplayId(1);
188 ASSERT_EQ(1, option->GetDisplayId());
189 }
190
191 /**
192 * @tc.name: ParentId01
193 * @tc.desc: SetParentId/GetParentId
194 * @tc.type: FUNC
195 */
196 HWTEST_F(WindowOptionTest, ParentId01, Function | SmallTest | Level2)
197 {
198 sptr<WindowOption> option = new WindowOption();
199 option->SetParentId(1);
200 ASSERT_EQ(1, option->GetParentId());
201 }
202
203 /**
204 * @tc.name: WindowName01
205 * @tc.desc: SetWindowName/GetWindowName
206 * @tc.type: FUNC
207 */
208 HWTEST_F(WindowOptionTest, WindowName01, Function | SmallTest | Level2)
209 {
210 sptr<WindowOption> option = new WindowOption();
211 option->SetWindowName("Sub Window");
212 ASSERT_EQ("Sub Window", option->GetWindowName());
213 }
214
215 /**
216 * @tc.name: BundleName01
217 * @tc.desc: SetBundleName/GetBundleName
218 * @tc.type: FUNC
219 */
220 HWTEST_F(WindowOptionTest, BundleName01, Function | SmallTest | Level2)
221 {
222 sptr<WindowOption> option = new WindowOption();
223 option->SetBundleName("settings");
224 ASSERT_EQ("settings", option->GetBundleName());
225 }
226
227 /**
228 * @tc.name: WindowFlag01
229 * @tc.desc: SetWindowFlags/GetWindowFlags
230 * @tc.type: FUNC
231 */
232 HWTEST_F(WindowOptionTest, WindowFlag01, Function | SmallTest | Level2)
233 {
234 sptr<WindowOption> option = new WindowOption();
235 option->SetWindowFlags(1u);
236 ASSERT_EQ(1u, option->GetWindowFlags());
237 }
238
239 /**
240 * @tc.name: WindowFlag02
241 * @tc.desc: AddWindowFlag/GetWindowFlags
242 * @tc.type: FUNC
243 */
244 HWTEST_F(WindowOptionTest, WindowFlag02, Function | SmallTest | Level2)
245 {
246 sptr<WindowOption> option = new WindowOption();
247 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
248 ASSERT_EQ(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID), option->GetWindowFlags());
249 }
250
251 /**
252 * @tc.name: WindowFlag03
253 * @tc.desc: AddWindowFlag/RemoveWindowFlag/GetWindowFlags
254 * @tc.type: FUNC
255 */
256 HWTEST_F(WindowOptionTest, WindowFlag03, Function | SmallTest | Level2)
257 {
258 sptr<WindowOption> option = new WindowOption();
259 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
260 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
261 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
262 ASSERT_EQ(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_PARENT_LIMIT), option->GetWindowFlags());
263 }
264
265 /**
266 * @tc.name: SetGetSystemBarProperty01
267 * @tc.desc: SetSystemBarProperty with test param and get
268 * @tc.type: FUNC
269 */
270 HWTEST_F(WindowOptionTest, SetGetSystemBarProperty01, Function | SmallTest | Level3)
271 {
272 sptr<WindowOption> option = new WindowOption();
273 option->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP_1);
274 option->SetSystemBarProperty(WindowType::WINDOW_TYPE_NAVIGATION_BAR, SYS_BAR_PROP_2);
275 ASSERT_EQ(SYS_BAR_PROPS_TEST, option->GetSystemBarProperty());
276 }
277
278 /**
279 * @tc.name: SetGetSystemBarProperty02
280 * @tc.desc: SetSystemBarProperty with invalid type and get
281 * @tc.type: FUNC
282 */
283 HWTEST_F(WindowOptionTest, SetGetSystemBarProperty02, Function | SmallTest | Level3)
284 {
285 sptr<WindowOption> option = new WindowOption();
286 option->SetSystemBarProperty(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, SYS_BAR_PROP_1);
287 option->SetSystemBarProperty(WindowType::WINDOW_TYPE_MEDIA, SYS_BAR_PROP_2);
288 ASSERT_EQ(SYS_BAR_PROPS_DEFAULT, option->GetSystemBarProperty());
289 }
290
291 /**
292 * @tc.name: SetGetSystemBarProperty03
293 * @tc.desc: GetSystemBarProperty with no set
294 * @tc.type: FUNC
295 */
296 HWTEST_F(WindowOptionTest, SetGetSystemBarProperty03, Function | SmallTest | Level3)
297 {
298 sptr<WindowOption> option = new WindowOption();
299 ASSERT_EQ(SYS_BAR_PROPS_DEFAULT, option->GetSystemBarProperty());
300 }
301
302 /**
303 * @tc.name: HitOffset
304 * @tc.desc: HitOffset setter/getter test
305 * @tc.type: FUNC
306 */
307 HWTEST_F(WindowOptionTest, HitOffset, Function | SmallTest | Level3)
308 {
309 sptr<WindowOption> option = new WindowOption();
310 option->SetHitOffset(1, 1);
311 PointInfo point = { 1, 1 };
312 ASSERT_EQ(point.x, option->GetHitOffset().x);
313 ASSERT_EQ(point.y, option->GetHitOffset().y);
314 }
315
316 /**
317 * @tc.name: KeepScreenOn
318 * @tc.desc: KeepScreenOn setter/getter test
319 * @tc.type: FUNC
320 */
321 HWTEST_F(WindowOptionTest, KeepScreenOn, Function | SmallTest | Level3)
322 {
323 sptr<WindowOption> option = new WindowOption();
324 option->SetKeepScreenOn(true);
325 ASSERT_EQ(true, option->IsKeepScreenOn());
326 option->SetKeepScreenOn(false);
327 ASSERT_EQ(false, option->IsKeepScreenOn());
328 }
329
330 /**
331 * @tc.name: viewKeepScreenOn
332 * @tc.desc: viewKeepScreenOn setter/getter test
333 * @tc.type: FUNC
334 */
335 HWTEST_F(WindowOptionTest, ViewKeepScreenOn, TestSize.Level1)
336 {
337 sptr<WindowOption> option = new WindowOption();
338 option->SetViewKeepScreenOn(true);
339 ASSERT_EQ(true, option->IsViewKeepScreenOn());
340 option->SetViewKeepScreenOn(false);
341 ASSERT_EQ(false, option->IsViewKeepScreenOn());
342 }
343
344 /**
345 * @tc.name: TurnScreenOn
346 * @tc.desc: TurnScreenOn setter/getter test
347 * @tc.type: FUNC
348 */
349 HWTEST_F(WindowOptionTest, TurnScreenOn, Function | SmallTest | Level3)
350 {
351 sptr<WindowOption> option = new WindowOption();
352 option->SetTurnScreenOn(true);
353 ASSERT_EQ(true, option->IsTurnScreenOn());
354 option->SetTurnScreenOn(false);
355 ASSERT_EQ(false, option->IsTurnScreenOn());
356 }
357
358 /**
359 * @tc.name: Brightness
360 * @tc.desc: Brightness setter/getter test
361 * @tc.type: FUNC
362 */
363 HWTEST_F(WindowOptionTest, Brightness, Function | SmallTest | Level3)
364 {
365 sptr<WindowOption> option = new WindowOption();
366 option->SetBrightness(MINIMUM_BRIGHTNESS);
367 ASSERT_EQ(MINIMUM_BRIGHTNESS, option->GetBrightness());
368 option->SetBrightness(MAXIMUM_BRIGHTNESS);
369 ASSERT_EQ(MAXIMUM_BRIGHTNESS, option->GetBrightness());
370
371 float brightness = -0.5;
372 option->SetBrightness(brightness);
373 ASSERT_EQ(brightness, option->GetBrightness());
374 brightness = 2.0;
375 option->SetBrightness(brightness);
376 ASSERT_EQ(brightness, option->GetBrightness());
377 }
378
379 /**
380 * @tc.name: CallingWindow
381 * @tc.desc: CallingWindow setter/getter test
382 * @tc.type: FUNC
383 */
384 HWTEST_F(WindowOptionTest, CallingWindow, Function | SmallTest | Level3)
385 {
386 sptr<WindowOption> option = new WindowOption();
387 option->SetCallingWindow(1);
388 ASSERT_EQ(1, option->GetCallingWindow());
389 }
390
391 /**
392 * @tc.name: SetWindowSessionType
393 * @tc.desc: SetWindowSessionType fun
394 * @tc.type: FUNC
395 */
396 HWTEST_F(WindowOptionTest, SetWindowSessionType, Function | SmallTest | Level3)
397 {
398 sptr<WindowOption> option = new WindowOption();
399 auto ret = true;
400 option->SetWindowSessionType(WindowSessionType::SCENE_SESSION);
401 ASSERT_EQ(true, ret);
402 }
403
404 /**
405 * @tc.name: GetWindowSessionType
406 * @tc.desc: GetWindowSessionType fun
407 * @tc.type: FUNC
408 */
409 HWTEST_F(WindowOptionTest, GetWindowSessionType, Function | SmallTest | Level3)
410 {
411 sptr<WindowOption> option = new WindowOption();
412 option->SetWindowSessionType(WindowSessionType::SCENE_SESSION);
413 option->GetWindowSessionType();
414 ASSERT_EQ(WindowSessionType::SCENE_SESSION, option->GetWindowSessionType());
415 }
416
417 /**
418 * @tc.name: Test01
419 * @tc.desc: Test01
420 * @tc.type: FUNC
421 */
422 HWTEST_F(WindowOptionTest, Test01, Function | SmallTest | Level3)
423 {
424 sptr<WindowOption> option = new WindowOption();
425 ASSERT_NE(nullptr, option);
426 option->SetIsUIExtFirstSubWindow(true);
427 option->SetSubWindowTitle("Test");
428 std::string ret = option->GetSubWindowTitle();
429 ASSERT_EQ(true, ret == "Test");
430 option->SetSubWindowDecorEnable(true);
431 bool ret1 = option->GetSubWindowDecorEnable();
432 ASSERT_EQ(true, ret1);
433 option->SetOnlySupportSceneBoard(true);
434 bool ret2 = option->GetOnlySupportSceneBoard();
435 ASSERT_EQ(true, ret2);
436 }
437
438 /**
439 * @tc.name: RealParentId
440 * @tc.desc: RealParentId setter and getter test
441 * @tc.type: FUNC
442 */
443 HWTEST_F(WindowOptionTest, SetRealParentId, Function | SmallTest | Level3)
444 {
445 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
446 ASSERT_NE(nullptr, option);
447 option->SetRealParentId(114);
448 EXPECT_EQ(114, option->GetRealParentId());
449 option->SetRealParentId(514);
450 EXPECT_EQ(514, option->GetRealParentId());
451 }
452
453 /**
454 * @tc.name: SetParentWindowType
455 * @tc.desc: SetParentWindowType setter and getter test
456 * @tc.type: FUNC
457 */
458 HWTEST_F(WindowOptionTest, SetParentWindowType, Function | SmallTest | Level3)
459 {
460 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
461 ASSERT_NE(nullptr, option);
462 option->SetParentWindowType(WindowType::WINDOW_TYPE_TOAST);
463 EXPECT_EQ(WindowType::WINDOW_TYPE_TOAST, option->GetParentWindowType());
464 option->SetParentWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
465 EXPECT_EQ(WindowType::WINDOW_TYPE_APP_COMPONENT, option->GetParentWindowType());
466 }
467
468 /**
469 * @tc.name: UIExtensionUsage
470 * @tc.desc: UIExtensionUsage setter and getter test
471 * @tc.type: FUNC
472 */
473 HWTEST_F(WindowOptionTest, SetUIExtensionUsage, Function | SmallTest | Level3)
474 {
475 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
476 ASSERT_NE(nullptr, option);
477 option->SetUIExtensionUsage(0);
478 EXPECT_EQ(0, option->GetUIExtensionUsage());
479 option->SetUIExtensionUsage(1);
480 EXPECT_EQ(1, option->GetUIExtensionUsage());
481 }
482
483 /**
484 * @tc.name: SetDialogDecorEnable
485 * @tc.desc: SetDialogDecorEnable
486 * @tc.type: FUNC
487 */
488 HWTEST_F(WindowOptionTest, SetDialogDecorEnable, Function | SmallTest | Level3)
489 {
490 sptr<WindowOption> option = new WindowOption();
491 ASSERT_NE(nullptr, option);
492 option->SetDialogDecorEnable(true);
493 ASSERT_EQ(true, option->GetDialogDecorEnable());
494 option->SetDialogDecorEnable(false);
495 ASSERT_EQ(false, option->GetDialogDecorEnable());
496 }
497
498 /**
499 * @tc.name: SetDialogTitle
500 * @tc.desc: SetDialogTitle
501 * @tc.type: FUNC
502 */
503 HWTEST_F(WindowOptionTest, SetDialogTitle, Function | SmallTest | Level3)
504 {
505 sptr<WindowOption> option = new WindowOption();
506 ASSERT_NE(nullptr, option);
507 option->SetDialogTitle("Test");
508 std::string ret = option->GetDialogTitle();
509 ASSERT_EQ(true, ret == "Test");
510 }
511
512 /**
513 * @tc.name: SetWindowTopmost
514 * @tc.desc: SetWindowTopmost
515 * @tc.type: FUNC
516 */
517 HWTEST_F(WindowOptionTest, SetWindowTopmost, Function | SmallTest | Level3)
518 {
519 sptr<WindowOption> option = new WindowOption();
520 ASSERT_NE(nullptr, option);
521 option->SetWindowTopmost(true);
522 ASSERT_EQ(true, option->GetWindowTopmost());
523 option->SetWindowTopmost(false);
524 ASSERT_EQ(false, option->GetWindowTopmost());
525 }
526
527 /**
528 * @tc.name: SetAndIsSystemKeyboard
529 * @tc.desc: test SetIsSystemKeyboard and IsSystemKeyboard
530 * @tc.type: FUNC
531 */
532 HWTEST_F(WindowOptionTest, SetAndIsSystemKeyboard, Function | SmallTest | Level3)
533 {
534 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
535 ASSERT_EQ(false, option->IsSystemKeyboard());
536 option->SetIsSystemKeyboard(true);
537 ASSERT_EQ(true, option->IsSystemKeyboard());
538 }
539
540 /**
541 * @tc.name: SetDensity
542 * @tc.desc: test SetDensity and GetDensity
543 * @tc.type: FUNC
544 */
545 HWTEST_F(WindowOptionTest, SetDensity, Function | SmallTest | Level3)
546 {
547 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
548 ASSERT_NE(nullptr, option);
549 ASSERT_EQ(1.0f, option->GetDensity());
550 float density = 5.0f;
551 option->SetDensity(density);
552 ASSERT_EQ(density, option->GetDensity());
553 }
554
555 /**
556 * @tc.name: SetIsDensityFollowHost
557 * @tc.desc: test SetIsDensityFollowHost and GetIsDensityFollowHost
558 * @tc.type: FUNC
559 */
560 HWTEST_F(WindowOptionTest, SetIsDensityFollowHost, Function | SmallTest | Level3)
561 {
562 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
563 ASSERT_NE(nullptr, option);
564 ASSERT_EQ(false, option->GetIsDensityFollowHost());
565 option->SetIsDensityFollowHost(true);
566 ASSERT_EQ(true, option->GetIsDensityFollowHost());
567 }
568
569 /**
570 * @tc.name: SetSubWindowZLevel
571 * @tc.desc: test SetSubWindowZLevel
572 * @tc.type: FUNC
573 */
574 HWTEST_F(WindowOptionTest, SetSubWindowZLevel, Function | SmallTest | Level3)
575 {
576 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
577 option->SetSubWindowZLevel(1);
578 ASSERT_EQ(1, option->zLevel_);
579 }
580
581 /**
582 * @tc.name: GetSubWindowZLevel
583 * @tc.desc: test GetSubWindowZLevel
584 * @tc.type: FUNC
585 */
586 HWTEST_F(WindowOptionTest, GetSubWindowZLevel, Function | SmallTest | Level3)
587 {
588 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
589 option->zLevel_ = 1;
590 ASSERT_EQ(1, option->GetSubWindowZLevel());
591 }
592
593 /**
594 * @tc.name: SetConstrainedModal
595 * @tc.desc: test SetConstrainedModal and GetIsDensityFollowHost
596 * @tc.type: FUNC
597 */
598 HWTEST_F(WindowOptionTest, SetConstrainedModal, Function | SmallTest | Level3)
599 {
600 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
601 ASSERT_EQ(false, option->IsConstrainedModal());
602 option->SetConstrainedModal(true);
603 ASSERT_EQ(false, option->IsConstrainedModal());
604 option->SetUIExtensionUsage(static_cast<uint32_t>(UIExtensionUsage::MODAL));
605 option->SetConstrainedModal(true);
606 ASSERT_EQ(true, option->IsConstrainedModal());
607 }
608 } // namespace
609 } // namespace Rosen
610 } // namespace OHOS
611