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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
100 {
101 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
102 option->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
103 option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
104 ASSERT_NE(WindowMode::WINDOW_MODE_UNDEFINED, option->GetWindowMode());
105 }
106
107 /**
108 * @tc.name: WindowMode03
109 * @tc.desc: SetWindowMode/GetWindowMode
110 * @tc.type: FUNC
111 */
112 HWTEST_F(WindowOptionTest, WindowMode03, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
385 {
386 sptr<WindowOption> option = new WindowOption();
387 option->SetCallingWindow(1);
388 ASSERT_EQ(1, option->GetCallingWindow());
389 }
390
391 /**
392 * @tc.name: SetAndGetWindowSessionType
393 * @tc.desc: SetAndGetWindowSessionType fun
394 * @tc.type: FUNC
395 */
396 HWTEST_F(WindowOptionTest, SetAndGetWindowSessionType, TestSize.Level1)
397 {
398 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
399 option->SetWindowSessionType(WindowSessionType::SCENE_SESSION);
400 option->GetWindowSessionType();
401 ASSERT_EQ(WindowSessionType::SCENE_SESSION, option->GetWindowSessionType());
402 }
403
404 /**
405 * @tc.name: GetWindowSessionType
406 * @tc.desc: GetWindowSessionType fun
407 * @tc.type: FUNC
408 */
409 HWTEST_F(WindowOptionTest, GetWindowSessionType, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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 option->SetUIExtensionUsage(static_cast<uint32_t>(UIExtensionUsage::UIEXTENSION_USAGE_END));
482 EXPECT_EQ(static_cast<uint32_t>(UIExtensionUsage::EMBEDDED), option->GetUIExtensionUsage());
483 }
484
485 /**
486 * @tc.name: SetDialogDecorEnable
487 * @tc.desc: SetDialogDecorEnable
488 * @tc.type: FUNC
489 */
490 HWTEST_F(WindowOptionTest, SetDialogDecorEnable, TestSize.Level1)
491 {
492 sptr<WindowOption> option = new WindowOption();
493 ASSERT_NE(nullptr, option);
494 option->SetDialogDecorEnable(true);
495 ASSERT_EQ(true, option->GetDialogDecorEnable());
496 option->SetDialogDecorEnable(false);
497 ASSERT_EQ(false, option->GetDialogDecorEnable());
498 }
499
500 /**
501 * @tc.name: SetDialogTitle
502 * @tc.desc: SetDialogTitle
503 * @tc.type: FUNC
504 */
505 HWTEST_F(WindowOptionTest, SetDialogTitle, TestSize.Level1)
506 {
507 sptr<WindowOption> option = new WindowOption();
508 ASSERT_NE(nullptr, option);
509 option->SetDialogTitle("Test");
510 std::string ret = option->GetDialogTitle();
511 ASSERT_EQ(true, ret == "Test");
512 }
513
514 /**
515 * @tc.name: SetWindowTopmost
516 * @tc.desc: SetWindowTopmost
517 * @tc.type: FUNC
518 */
519 HWTEST_F(WindowOptionTest, SetWindowTopmost, TestSize.Level1)
520 {
521 sptr<WindowOption> option = new WindowOption();
522 ASSERT_NE(nullptr, option);
523 option->SetWindowTopmost(true);
524 ASSERT_EQ(true, option->GetWindowTopmost());
525 option->SetWindowTopmost(false);
526 ASSERT_EQ(false, option->GetWindowTopmost());
527 }
528
529 /**
530 * @tc.name: SetAndIsSystemKeyboard
531 * @tc.desc: test SetIsSystemKeyboard and IsSystemKeyboard
532 * @tc.type: FUNC
533 */
534 HWTEST_F(WindowOptionTest, SetAndIsSystemKeyboard, TestSize.Level1)
535 {
536 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
537 ASSERT_EQ(false, option->IsSystemKeyboard());
538 option->SetIsSystemKeyboard(true);
539 ASSERT_EQ(true, option->IsSystemKeyboard());
540 }
541
542 /**
543 * @tc.name: SetDensity
544 * @tc.desc: test SetDensity and GetDensity
545 * @tc.type: FUNC
546 */
547 HWTEST_F(WindowOptionTest, SetDensity, TestSize.Level1)
548 {
549 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
550 ASSERT_NE(nullptr, option);
551 ASSERT_EQ(1.0f, option->GetDensity());
552 float density = 5.0f;
553 option->SetDensity(density);
554 ASSERT_EQ(density, option->GetDensity());
555 }
556
557 /**
558 * @tc.name: SetIsDensityFollowHost
559 * @tc.desc: test SetIsDensityFollowHost and GetIsDensityFollowHost
560 * @tc.type: FUNC
561 */
562 HWTEST_F(WindowOptionTest, SetIsDensityFollowHost, TestSize.Level1)
563 {
564 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
565 ASSERT_NE(nullptr, option);
566 ASSERT_EQ(false, option->GetIsDensityFollowHost());
567 option->SetIsDensityFollowHost(true);
568 ASSERT_EQ(true, option->GetIsDensityFollowHost());
569 }
570
571 /**
572 * @tc.name: SetDefaultDensityEnabled
573 * @tc.desc: test SetIsDensityFollowHost and IsDefaultDensityEnabled
574 * @tc.type: FUNC
575 */
576 HWTEST_F(WindowOptionTest, SetDefaultDensityEnabled, TestSize.Level1)
577 {
578 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
579 ASSERT_NE(nullptr, option);
580 EXPECT_EQ(false, option->IsDefaultDensityEnabled());
581 option->SetDefaultDensityEnabled(true);
582 EXPECT_EQ(true, option->IsDefaultDensityEnabled());
583 }
584
585 /**
586 * @tc.name: SetSubWindowZLevel
587 * @tc.desc: test SetSubWindowZLevel
588 * @tc.type: FUNC
589 */
590 HWTEST_F(WindowOptionTest, SetSubWindowZLevel, TestSize.Level1)
591 {
592 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
593 option->SetSubWindowZLevel(1);
594 ASSERT_EQ(1, option->zLevel_);
595 }
596
597 /**
598 * @tc.name: GetSubWindowZLevel
599 * @tc.desc: test GetSubWindowZLevel
600 * @tc.type: FUNC
601 */
602 HWTEST_F(WindowOptionTest, GetSubWindowZLevel, TestSize.Level1)
603 {
604 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
605 option->zLevel_ = 1;
606 ASSERT_EQ(1, option->GetSubWindowZLevel());
607 }
608
609 /**
610 * @tc.name: SetZIndex
611 * @tc.desc: test SetZIndex
612 * @tc.type: FUNC
613 */
614 HWTEST_F(WindowOptionTest, SetZIndex, TestSize.Level1)
615 {
616 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
617 option->SetZIndex(0);
618 ASSERT_EQ(0, option->GetZIndex());
619 }
620
621 /**
622 * @tc.name: SetConstrainedModal
623 * @tc.desc: test SetConstrainedModal and GetIsDensityFollowHost
624 * @tc.type: FUNC
625 */
626 HWTEST_F(WindowOptionTest, SetConstrainedModal, TestSize.Level1)
627 {
628 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
629 ASSERT_EQ(false, option->IsConstrainedModal());
630 option->SetConstrainedModal(true);
631 ASSERT_EQ(false, option->IsConstrainedModal());
632 option->SetUIExtensionUsage(static_cast<uint32_t>(UIExtensionUsage::MODAL));
633 option->SetConstrainedModal(true);
634 ASSERT_EQ(true, option->IsConstrainedModal());
635 }
636 } // namespace
637 } // namespace Rosen
638 } // namespace OHOS
639