1 /*
2 * Copyright (c) 2024 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 "screen_session_manager/include/screen_session_manager.h"
19 #include "screen_session_manager/include/screen_setting_helper.h"
20 #include "window_manager_hilog.h"
21 #include "scene_board_judgement.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace {
29 constexpr uint32_t SLEEP_TIME_US = 100000;
30 }
31
32 class ScreenSettingHelperTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUpTestCase()40 void ScreenSettingHelperTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void ScreenSettingHelperTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void ScreenSettingHelperTest::SetUp()
49 {
50 }
51
TearDown()52 void ScreenSettingHelperTest::TearDown()
53 {
54 usleep(SLEEP_TIME_US);
55 }
56
57 namespace {
58 /**
59 * @tc.name: RegisterSettingDpiObserver
60 * @tc.desc: RegisterSettingDpiObserver
61 * @tc.type: FUNC
62 */
63 HWTEST_F(ScreenSettingHelperTest, RegisterSettingDpiObserver, TestSize.Level1)
64 {
__anon866ea65a0302(const std::string&) 65 auto func = [] (const std::string&) {
66 TLOGI(WmsLogTag::DMS, "UT test");
67 };
68 ScreenSettingHelper::RegisterSettingDpiObserver(func);
69 ScreenSettingHelper::dpiObserver_ = nullptr;
70 ASSERT_EQ(ScreenSettingHelper::dpiObserver_, nullptr);
71 }
72
73 /**
74 * @tc.name: UnregisterSettingDpiObserver01
75 * @tc.desc: UnregisterSettingDpiObserver01
76 * @tc.type: FUNC
77 */
78 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingDpiObserver01, TestSize.Level1)
79 {
80 ScreenSettingHelper::dpiObserver_ = new SettingObserver;
81 ScreenSettingHelper::UnregisterSettingDpiObserver();
82 ASSERT_EQ(ScreenSettingHelper::dpiObserver_, nullptr);
83 }
84
85 /**
86 * @tc.name: UnregisterSettingDpiObserver02
87 * @tc.desc: UnregisterSettingDpiObserver02
88 * @tc.type: FUNC
89 */
90 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingDpiObserver02, TestSize.Level1)
91 {
92 ScreenSettingHelper::dpiObserver_ = nullptr;
93 ScreenSettingHelper::UnregisterSettingDpiObserver();
94 ASSERT_EQ(ScreenSettingHelper::dpiObserver_, nullptr);
95 }
96
97 /**
98 * @tc.name: GetSettingDpi01
99 * @tc.desc: GetSettingDpi01
100 * @tc.type: FUNC
101 */
102 HWTEST_F(ScreenSettingHelperTest, GetSettingDpi01, TestSize.Level1)
103 {
104 uint32_t dpi = 0;
105 std::string key = "test";
106 bool ret = ScreenSettingHelper::GetSettingDpi(dpi, key);
107 ASSERT_FALSE(ret);
108 }
109
110 /**
111 * @tc.name: RegisterSettingCastObserver01
112 * @tc.desc: RegisterSettingCastObserver
113 * @tc.type: FUNC
114 */
115 HWTEST_F(ScreenSettingHelperTest, RegisterSettingCastObserver01, TestSize.Level1)
116 {
__anon866ea65a0402(const std::string&) 117 auto func = [] (const std::string&) {
118 TLOGI(WmsLogTag::DMS, "UT test");
119 };
120 ScreenSettingHelper::castObserver_ = new SettingObserver;
121 ScreenSettingHelper::RegisterSettingCastObserver(func);
122 ASSERT_NE(ScreenSettingHelper::castObserver_, nullptr);
123 }
124
125 /**
126 * @tc.name: RegisterSettingCastObserver02
127 * @tc.desc: RegisterSettingCastObserver02
128 * @tc.type: FUNC
129 */
130 HWTEST_F(ScreenSettingHelperTest, RegisterSettingCastObserver02, TestSize.Level1)
131 {
__anon866ea65a0502(const std::string&) 132 auto func = [] (const std::string&) {
133 TLOGI(WmsLogTag::DMS, "UT test");
134 };
135 ScreenSettingHelper::castObserver_ = nullptr;
136 ScreenSettingHelper::RegisterSettingCastObserver(func);
137 ASSERT_NE(ScreenSettingHelper::castObserver_, nullptr);
138 }
139
140 /**
141 * @tc.name: UnregisterSettingCastObserver01
142 * @tc.desc: UnregisterSettingCastObserver01
143 * @tc.type: FUNC
144 */
145 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingCastObserver01, TestSize.Level1)
146 {
147 ScreenSettingHelper::castObserver_ = nullptr;
148 ScreenSettingHelper::UnregisterSettingCastObserver();
149 ASSERT_EQ(ScreenSettingHelper::castObserver_, nullptr);
150 }
151
152 /**
153 * @tc.name: UnregisterSettingCastObserver02
154 * @tc.desc: UnregisterSettingCastObserver02
155 * @tc.type: FUNC
156 */
157 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingCastObserver02, TestSize.Level1)
158 {
159 ScreenSettingHelper::castObserver_ = new SettingObserver;
160 ScreenSettingHelper::UnregisterSettingCastObserver();
161 ASSERT_EQ(ScreenSettingHelper::castObserver_, nullptr);
162 }
163
164 /**
165 * @tc.name: GetSettingCast01
166 * @tc.desc: GetSettingCast01
167 * @tc.type: FUNC
168 */
169 HWTEST_F(ScreenSettingHelperTest, GetSettingCast01, TestSize.Level1)
170 {
171 bool enable = true;
172 std::string key = "test";
173 bool ret = ScreenSettingHelper::GetSettingCast(enable, key);
174 ASSERT_FALSE(ret);
175 }
176
177 /**
178 * @tc.name: GetSettingCast02
179 * @tc.desc: GetSettingCast02
180 * @tc.type: FUNC
181 */
182 HWTEST_F(ScreenSettingHelperTest, GetSettingCast02, TestSize.Level1)
183 {
184 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
185 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
186 }
187 bool enable = true;
188 std::string key = "default_display_dpi";
189 bool ret = ScreenSettingHelper::GetSettingCast(enable, key);
190 ASSERT_TRUE(ret);
191 }
192
193 /**
194 * @tc.name: UnregisterSettingRotationObserver01
195 * @tc.desc: UnregisterSettingRotationObserver01
196 * @tc.type: FUNC
197 */
198 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingRotationObserver01, TestSize.Level1)
199 {
200 ScreenSettingHelper::rotationObserver_ = nullptr;
201 ASSERT_EQ(ScreenSettingHelper::rotationObserver_, nullptr);
202 }
203
204 /**
205 * @tc.name: UnregisterSettingRotationObserver02
206 * @tc.desc: UnregisterSettingRotationObserver02
207 * @tc.type: FUNC
208 */
209 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingRotationObserver02, TestSize.Level1)
210 {
211 ScreenSettingHelper::rotationObserver_ = new SettingObserver;
212 ASSERT_NE(ScreenSettingHelper::rotationObserver_, nullptr);
213 }
214
215 /**
216 * @tc.name: SetSettingRotation
217 * @tc.desc: SetSettingRotation
218 * @tc.type: FUNC
219 */
220 HWTEST_F(ScreenSettingHelperTest, SetSettingRotation, TestSize.Level1)
221 {
222 int32_t rotation = 180;
223 ScreenSettingHelper::SetSettingRotation(rotation);
224 ASSERT_NE(ScreenSettingHelper::rotationObserver_, nullptr);
225 }
226
227 /**
228 * @tc.name: GetSettingRotation01
229 * @tc.desc: GetSettingRotation01
230 * @tc.type: FUNC
231 */
232 HWTEST_F(ScreenSettingHelperTest, GetSettingRotation01, TestSize.Level1)
233 {
234 int32_t rotation = 0;
235 std::string key = "test";
236 auto result = ScreenSettingHelper::GetSettingRotation(rotation, key);
237 ASSERT_EQ(result, false);
238 }
239
240 /**
241 * @tc.name: GetSettingRotation02
242 * @tc.desc: GetSettingRotation02
243 * @tc.type: FUNC
244 */
245 HWTEST_F(ScreenSettingHelperTest, GetSettingRotation02, TestSize.Level1)
246 {
247 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
248 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
249 }
250 int32_t rotation = 0;
251 std::string key = "default_display_dpi";
252 auto result = ScreenSettingHelper::GetSettingRotation(rotation, key);
253 ASSERT_EQ(result, true);
254 }
255
256 /**
257 * @tc.name: SetSettingRotationScreenId
258 * @tc.desc: SetSettingRotationScreenId
259 * @tc.type: FUNC
260 */
261 HWTEST_F(ScreenSettingHelperTest, SetSettingRotationScreenId, TestSize.Level1)
262 {
263 int32_t screenId = 0;
264 ScreenSettingHelper::SetSettingRotationScreenId(screenId);
265 ASSERT_NE(ScreenSettingHelper::rotationObserver_, nullptr);
266 }
267
268 /**
269 * @tc.name: GetSettingRotationScreenID01
270 * @tc.desc: GetSettingRotationScreenID01
271 * @tc.type: FUNC
272 */
273 HWTEST_F(ScreenSettingHelperTest, GetSettingRotationScreenID01, TestSize.Level1)
274 {
275 int32_t screenId = 0;
276 std::string key = "test";
277 auto result = ScreenSettingHelper::GetSettingRotationScreenID(screenId, key);
278 ASSERT_EQ(result, false);
279 }
280
281 /**
282 * @tc.name: GetSettingRotationScreenID02
283 * @tc.desc: GetSettingRotationScreenID02
284 * @tc.type: FUNC
285 */
286 HWTEST_F(ScreenSettingHelperTest, GetSettingRotationScreenID02, TestSize.Level1)
287 {
288 int32_t screenId = 0;
289 std::string key = "screen_rotation_screen_id_value";
290 auto result = ScreenSettingHelper::GetSettingRotationScreenID(screenId, key);
291 ASSERT_EQ(result, false);
292 }
293
294 /**
295 * @tc.name: GetSettingValue
296 * @tc.desc: GetSettingValue
297 * @tc.type: FUNC
298 */
299 HWTEST_F(ScreenSettingHelperTest, GetSettingValue, TestSize.Level1)
300 {
301 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
302 uint32_t value = 0;
303 std::string key = "test";
304 bool ret = screenSettingHelper.GetSettingValue(value, key);
305 ASSERT_FALSE(ret);
306 }
307
308 /**
309 * @tc.name: RemoveInvalidChar01
310 * @tc.desc: RemoveInvalidChar Test01
311 * @tc.type: FUNC
312 */
313 HWTEST_F(ScreenSettingHelperTest, RemoveInvalidChar01, TestSize.Level1)
314 {
315 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
316 std::string test_str = "test";
317 auto ret = screenSettingHelper.RemoveInvalidChar(test_str);
318 ASSERT_EQ(ret, "");
319 }
320
321 /**
322 * @tc.name: RemoveInvalidChar02
323 * @tc.desc: RemoveInvalidChar Test02
324 * @tc.type: FUNC
325 */
326 HWTEST_F(ScreenSettingHelperTest, RemoveInvalidChar02, TestSize.Level1)
327 {
328 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
329 std::string test_str = "test 2.0 ,";
330 auto ret = screenSettingHelper.RemoveInvalidChar(test_str);
331 ASSERT_EQ(ret, " 2.0 ,");
332 }
333
334 /**
335 * @tc.name: SplitString
336 * @tc.desc: SplitString Test01
337 * @tc.type: FUNC
338 */
339 HWTEST_F(ScreenSettingHelperTest, SplitString01, TestSize.Level1)
340 {
341 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
342 std::vector<std::string> splitValues = {"split", "test"};
343 std::string input = "";
344 char delimiter = ',';
345 auto ret = screenSettingHelper.SplitString(splitValues, input, delimiter);
346 ASSERT_FALSE(ret);
347 }
348
349 /**
350 * @tc.name: SplitString
351 * @tc.desc: SplitString Test02
352 * @tc.type: FUNC
353 */
354 HWTEST_F(ScreenSettingHelperTest, SplitString02, TestSize.Level1)
355 {
356 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
357 std::vector<std::string> splitValues = {};
358 std::string input = "test, str";
359 char delimiter = ',';
360 auto ret = screenSettingHelper.SplitString(splitValues, input, delimiter);
361 ASSERT_TRUE(ret);
362 }
363
364 /**
365 * @tc.name: IsNumber01
366 * @tc.desc: IsNumber01 Test
367 * @tc.type: FUNC
368 */
369 HWTEST_F(ScreenSettingHelperTest, IsNumber01, TestSize.Level1)
370 {
371 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
372 std::string test_str = "12.34";
373 auto ret = screenSettingHelper.IsNumber(test_str);
374 ASSERT_TRUE(ret);
375 }
376
377 /**
378 * @tc.name: IsNumber02
379 * @tc.desc: IsNumber02 Test
380 * @tc.type: FUNC
381 */
382 HWTEST_F(ScreenSettingHelperTest, IsNumber02, TestSize.Level1)
383 {
384 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
385 std::string test_str = "test";
386 auto ret = screenSettingHelper.IsNumber(test_str);
387 ASSERT_FALSE(ret);
388 }
389
390 /**
391 * @tc.name: ConvertStrToUInt64Test01
392 * @tc.desc: ConvertStrToUInt64Test01
393 * @tc.type: FUNC
394 */
395 HWTEST_F(ScreenSettingHelperTest, ConvertStrToUInt64Test01, TestSize.Level1)
396 {
397 uint64_t num = 0;
398 std::string str = "fvcea";
399 bool ret = ScreenSettingHelper::ConvertStrToUint64(str, num);
400 ASSERT_FALSE(ret);
401 ASSERT_EQ(num, 0);
402 }
403
404 /**
405 * @tc.name: ConvertStrToUInt64Test02
406 * @tc.desc: ConvertStrToUInt64Test02
407 * @tc.type: FUNC
408 */
409 HWTEST_F(ScreenSettingHelperTest, ConvertStrToUInt64Test02, TestSize.Level1)
410 {
411 uint64_t num = 0;
412 std::string str = "2349z";
413 bool ret = ScreenSettingHelper::ConvertStrToUint64(str, num);
414 ASSERT_FALSE(ret);
415 ASSERT_EQ(num, 0);
416 }
417
418 /**
419 * @tc.name: ConvertStrToUInt64Test03
420 * @tc.desc: ConvertStrToUInt64Test03
421 * @tc.type: FUNC
422 */
423 HWTEST_F(ScreenSettingHelperTest, ConvertStrToUint64Test03, TestSize.Level1)
424 {
425 uint64_t num = 0;
426 std::string str = "2349";
427 bool ret = ScreenSettingHelper::ConvertStrToUint64(str, num);
428 ASSERT_TRUE(ret);
429 ASSERT_EQ(num, 2349);
430 }
431
432 /**
433 * @tc.name: RegisterSettingWireCastObserver01
434 * @tc.desc: RegisterSettingWireCastObserver01
435 * @tc.type: FUNC
436 */
437 HWTEST_F(ScreenSettingHelperTest, RegisterSettingWireCastObserver01, TestSize.Level1)
438 {
__anon866ea65a0602(const std::string&) 439 auto func = [] (const std::string&) {
440 TLOGI(WmsLogTag::DMS, "UT test");
441 };
442 ScreenSettingHelper::wireCastObserver_ = new SettingObserver;
443 ScreenSettingHelper::RegisterSettingWireCastObserver(func);
444 ASSERT_NE(ScreenSettingHelper::wireCastObserver_, nullptr);
445 }
446
447 /**
448 * @tc.name: UnregisterSettingWireCastObserver01
449 * @tc.desc: UnregisterSettingWireCastObserver01
450 * @tc.type: FUNC
451 */
452 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingWireCastObserver01, TestSize.Level1)
453 {
454 ScreenSettingHelper::wireCastObserver_ = nullptr;
455 ScreenSettingHelper::UnregisterSettingWireCastObserver();
456 ASSERT_EQ(ScreenSettingHelper::wireCastObserver_, nullptr);
457 }
458
459 /**
460 * @tc.name: UnregisterSettingWireCastObserver02
461 * @tc.desc: UnregisterSettingWireCastObserver02
462 * @tc.type: FUNC
463 */
464 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingWireCastObserver02, TestSize.Level1)
465 {
466 ScreenSettingHelper::wireCastObserver_ = new SettingObserver;
467 ScreenSettingHelper::UnregisterSettingWireCastObserver();
468 ASSERT_EQ(ScreenSettingHelper::wireCastObserver_, nullptr);
469 }
470
471 /**
472 * @tc.name: UpdateScreenModeTest
473 * @tc.desc: Test UpdateScreenMode for mode not equl nomal mode then return false
474 * @tc.type: FUNC
475 */
476 HWTEST_F(ScreenSettingHelperTest, UpdateScreenMode, Function | SmallTest | Level3)
477 {
478 MultiScreenInfo info;
479 uint32_t mode = 3; //unnomal mode
480 bool isExternal = true;
481 auto ret = ScreenSettingHelper::UpdateScreenMode(info, mode, isExternal);
482 ASSERT_FALSE(ret);
483 }
484
485 /**
486 * @tc.name: UpdateScreenModeTest001
487 * @tc.desc: Test UpdateScreenMode for mode equl SCREEN_MAIN_IN_DATA then return true
488 * @tc.type: FUNC
489 */
490 HWTEST_F(ScreenSettingHelperTest, UpdateScreenModeTest001, Function | SmallTest | Level3)
491 {
492 MultiScreenInfo info;
493 uint32_t mode = 0; //mode is SCREEN_MAIN_IN_DATA
494 bool isExternal = true;
495 auto ret = ScreenSettingHelper::UpdateScreenMode(info, mode, isExternal);
496 ASSERT_TRUE(ret);
497 ASSERT_EQ(info.isExtendMain, isExternal);
498 }
499
500 /**
501 * @tc.name: UpdateScreenModeTest002
502 * @tc.desc: Test UpdateScreenMode for mode not equl SCREEN_MIRROR_IN_DATA then return true
503 * @tc.type: FUNC
504 */
505 HWTEST_F(ScreenSettingHelperTest, UpdateScreenModeTest002, Function | SmallTest | Level3)
506 {
507 MultiScreenInfo info;
508 uint32_t mode = 1; //mode is SCREEN_MIRROR_IN_DATA
509 bool isExternal = true;
510 auto ret = ScreenSettingHelper::UpdateScreenMode(info, mode, isExternal);
511 ASSERT_TRUE(ret);
512 ASSERT_EQ(info.multiScreenMode, MultiScreenMode::SCREEN_MIRROR);
513 }
514
515 /**
516 * @tc.name: UpdateScreenModeTest003
517 * @tc.desc: Test UpdateScreenMode for mode not equl SCREEN_EXTEND_IN_DATA then return true
518 * @tc.type: FUNC
519 */
520 HWTEST_F(ScreenSettingHelperTest, UpdateScreenModeTest003, Function | SmallTest | Level3)
521 {
522 MultiScreenInfo info;
523 uint32_t mode = 2; //mode is SCREEN_EXTEND_IN_DATA
524 bool isExternal = true;
525 auto ret = ScreenSettingHelper::UpdateScreenMode(info, mode, isExternal);
526 ASSERT_TRUE(ret);
527 ASSERT_EQ(info.multiScreenMode, MultiScreenMode::SCREEN_EXTEND);
528 }
529
530 /**
531 * @tc.name: GetScreenModeTest
532 * @tc.desc: Test GetScreenMode func
533 * @tc.type: FUNC
534 */
535 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest, Function | SmallTest | Level3)
536 {
537 MultiScreenInfo info;
538 string inputString;
539 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
540 ASSERT_FALSE(ret);
541 }
542
543 /**
544 * @tc.name: GetScreenModeTest001
545 * @tc.desc: Test GetScreenMode func
546 * @tc.type: FUNC
547 */
548 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest001, Function | SmallTest | Level3)
549 {
550 MultiScreenInfo info;
551 string inputString = "1 ";
552 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
553 ASSERT_FALSE(ret);
554 }
555
556 /**
557 * @tc.name: GetScreenModeTest002
558 * @tc.desc: Test GetScreenMode func
559 * @tc.type: FUNC
560 */
561 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest002, Function | SmallTest | Level3)
562 {
563 MultiScreenInfo info;
564 string inputString = "1 2";
565 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
566 ASSERT_TRUE(ret);
567 }
568
569 /**
570 * @tc.name: GetScreenModeTest003
571 * @tc.desc: Test GetScreenMode func
572 * @tc.type: FUNC
573 */
574 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest003, Function | SmallTest | Level3)
575 {
576 MultiScreenInfo info;
577 string inputString = "1 2 3";
578 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
579 ASSERT_FALSE(ret);
580 }
581
582 /**
583 * @tc.name: GetScreenModeTest004
584 * @tc.desc: Test GetScreenMode func
585 * @tc.type: FUNC
586 */
587 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest004, Function | SmallTest | Level3)
588 {
589 MultiScreenInfo info;
590 string inputString = "3 2";
591 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
592 ASSERT_FALSE(ret);
593 }
594
595 /**
596 * @tc.name: GetScreenModeTest005
597 * @tc.desc: Test GetScreenMode func
598 * @tc.type: FUNC
599 */
600 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest005, Function | SmallTest | Level3)
601 {
602 MultiScreenInfo info;
603 string inputString = "1 3";
604 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
605 ASSERT_FALSE(ret);
606 }
607
608 /**
609 * @tc.name: GetScreenModeTest006
610 * @tc.desc: Test GetScreenMode func
611 * @tc.type: FUNC
612 */
613 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest006, Function | SmallTest | Level3)
614 {
615 MultiScreenInfo info;
616 string inputString = "e 1";
617 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
618 ASSERT_FALSE(ret);
619 }
620
621 /**
622 * @tc.name: GetScreenModeTest007
623 * @tc.desc: Test GetScreenMode func
624 * @tc.type: FUNC
625 */
626 HWTEST_F(ScreenSettingHelperTest, GetScreenModeTest007, Function | SmallTest | Level3)
627 {
628 MultiScreenInfo info;
629 string inputString = "1 e";
630 auto ret = ScreenSettingHelper::GetScreenMode(info, inputString);
631 ASSERT_FALSE(ret);
632 }
633
634 /**
635 * @tc.name: GetScreenRelativePositionTest
636 * @tc.desc: Test GetScreenRelativePosition func
637 * @tc.type: FUNC
638 */
639 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest, Function | SmallTest | Level3)
640 {
641 MultiScreenInfo info;
642 string inputString;
643 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
644 ASSERT_FALSE(ret);
645 }
646
647 /**
648 * @tc.name: GetScreenRelativePositionTest001
649 * @tc.desc: Test GetScreenRelativePosition func
650 * @tc.type: FUNC
651 */
652 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest001, Function | SmallTest | Level3)
653 {
654 MultiScreenInfo info;
655 string inputString = "1 2";
656 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
657 ASSERT_FALSE(ret);
658 }
659
660 /**
661 * @tc.name: GetScreenRelativePositionTest002
662 * @tc.desc: Test GetScreenRelativePosition func
663 * @tc.type: FUNC
664 */
665 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest002, Function | SmallTest | Level3)
666 {
667 MultiScreenInfo info;
668 string inputString = "1 2 3";
669 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
670 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
671 ASSERT_FALSE(ret);
672 } else {
673 ASSERT_TRUE(ret);
674 }
675 }
676
677 /**
678 * @tc.name: GetScreenRelativePositionTest003
679 * @tc.desc: Test GetScreenRelativePosition func
680 * @tc.type: FUNC
681 */
682 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest003, Function | SmallTest | Level3)
683 {
684 MultiScreenInfo info;
685 string inputString = "1 2 3 4";
686 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
687 ASSERT_FALSE(ret);
688 }
689
690 /**
691 * @tc.name: GetScreenRelativePositionTest004
692 * @tc.desc: Test GetScreenRelativePosition func
693 * @tc.type: FUNC
694 */
695 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest004, Function | SmallTest | Level3)
696 {
697 MultiScreenInfo info;
698 string inputString = "E 1 2";
699 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
700 ASSERT_FALSE(ret);
701 }
702
703 /**
704 * @tc.name: GetScreenRelativePositionTest005
705 * @tc.desc: Test GetScreenRelativePosition func
706 * @tc.type: FUNC
707 */
708 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest005, Function | SmallTest | Level3)
709 {
710 MultiScreenInfo info;
711 string inputString = "1 E 2";
712 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
713 ASSERT_FALSE(ret);
714 }
715
716 /**
717 * @tc.name: GetScreenRelativePositionTest006
718 * @tc.desc: Test GetScreenRelativePosition func
719 * @tc.type: FUNC
720 */
721 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest006, Function | SmallTest | Level3)
722 {
723 MultiScreenInfo info;
724 string inputString = "1 2 E";
725 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
726 ASSERT_FALSE(ret);
727 }
728
729
730 /**
731 * @tc.name: GetScreenRelativePositionTest007
732 * @tc.desc: Test GetScreenRelativePosition func
733 * @tc.type: FUNC
734 */
735 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest007, Function | SmallTest | Level3)
736 {
737 ScreenId screenId = 1001;
738 ScreenSessionConfig config = {
739 .screenId = screenId,
740 .rsId = 1001,
741 .name = "GetScreenRelativePositionTest007",
742 };
743 sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
744 ScreenSessionManager::GetInstance().screenSessionMap_[screenId] = screenSession;
745 MultiScreenInfo info;
746 info.isExtendMain = true;
747 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
748 screenSession->isInternal_ = true;
749 string inputString = "1 2 3";
750 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
751 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
752 ASSERT_FALSE(ret);
753 ASSERT_EQ(info.mainScreenOption.screenId_, 0);
754 } else {
755 ASSERT_TRUE(ret);
756 ASSERT_EQ(info.mainScreenOption.screenId_, 1);
757 }
758 ScreenSessionManager::GetInstance().screenSessionMap_.erase(screenId);
759 }
760
761 /**
762 * @tc.name: GetScreenRelativePositionTest008
763 * @tc.desc: Test GetScreenRelativePosition func
764 * @tc.type: FUNC
765 */
766 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest008, Function | SmallTest | Level3)
767 {
768 ScreenId screenId = 1001;
769 ScreenSessionConfig config = {
770 .screenId = screenId,
771 .rsId = 1001,
772 .name = "GetScreenRelativePositionTest008",
773 };
774 sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
775 ScreenSessionManager::GetInstance().screenSessionMap_[screenId] = screenSession;
776 MultiScreenInfo info;
777 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
778 screenSession->isInternal_ = true;
779 info.isExtendMain = false;
780 string inputString = "1001 2 3";
781 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
782 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
783 ASSERT_FALSE(ret);
784 ASSERT_EQ(info.secondaryScreenOption.screenId_, 0);
785 } else {
786 ASSERT_TRUE(ret);
787 ASSERT_EQ(info.secondaryScreenOption.screenId_, 1001);
788 }
789 ScreenSessionManager::GetInstance().screenSessionMap_.erase(screenId);
790 }
791
792 /**
793 * @tc.name: GetScreenRelativePositionTest009
794 * @tc.desc: Test GetScreenRelativePosition func
795 * @tc.type: FUNC
796 */
797 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest009, Function | SmallTest | Level3)
798 {
799 ScreenId screenId = 1001;
800 ScreenSessionConfig config = {
801 .screenId = screenId,
802 .rsId = 1001,
803 .name = "GetScreenRelativePositionTest009",
804 };
805 sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
806 ScreenSessionManager::GetInstance().screenSessionMap_[screenId] = screenSession;
807 MultiScreenInfo info;
808 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
809 screenSession->isInternal_ = true;
810 info.isExtendMain = true;
811 string inputString = "1001 2 3";
812 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
813 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
814 ASSERT_FALSE(ret);
815 ASSERT_EQ(info.mainScreenOption.screenId_, 0);
816 } else {
817 ASSERT_TRUE(ret);
818 ASSERT_EQ(info.mainScreenOption.screenId_, 1001);
819 }
820 ScreenSessionManager::GetInstance().screenSessionMap_.erase(screenId);
821 }
822
823 /**
824 * @tc.name: GetScreenRelativePositionTest0010
825 * @tc.desc: Test GetScreenRelativePosition func
826 * @tc.type: FUNC
827 */
828 HWTEST_F(ScreenSettingHelperTest, GetScreenRelativePositionTest0010, Function | SmallTest | Level3)
829 {
830 ScreenId screenId = 1001;
831 ScreenSessionConfig config = {
832 .screenId = screenId,
833 .rsId = 1001,
834 .name = "GetScreenRelativePositionTest0010",
835 };
836 sptr<ScreenSession> screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
837 ScreenSessionManager::GetInstance().screenSessionMap_[screenId] = screenSession;
838 MultiScreenInfo info;
839 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
840 screenSession->isInternal_ = true;
841 info.isExtendMain = false;
842 string inputString = "1 2 3";
843 auto ret = ScreenSettingHelper::GetScreenRelativePosition(info, inputString);
844 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
845 ASSERT_FALSE(ret);
846 ASSERT_EQ(info.secondaryScreenOption.screenId_, 0);
847 } else {
848 ASSERT_TRUE(ret);
849 ASSERT_EQ(info.secondaryScreenOption.screenId_, 1);
850 }
851 ScreenSessionManager::GetInstance().screenSessionMap_.erase(screenId);
852 }
853
854 /**
855 * @tc.name: GetMultiScreenInfoTest
856 * @tc.desc: Test GetMultiScreenInfo func
857 * @tc.type: FUNC
858 */
859 HWTEST_F(ScreenSettingHelperTest, GetMultiScreenInfoTest, Function | SmallTest | Level3)
860 {
861 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
862 std::string value = "";
863 std::string key = "user_set_screen_mode_edid";
864 bool ret = screenSettingHelper.SetSettingValue(key, value);
865 ASSERT_TRUE(ret);
866
867 std::map<std::string, MultiScreenInfo> multiScreenInfoMap = screenSettingHelper.GetMultiScreenInfo(key);
868 ASSERT_TRUE(multiScreenInfoMap.empty());
869 }
870
871 /**
872 * @tc.name: ConvertStrToInt32
873 * @tc.desc: Test ConvertStrToInt32 func
874 * @tc.type: FUNC
875 */
876 HWTEST_F(ScreenSettingHelperTest, ConvertStrToInt32, Function | SmallTest | Level3)
877 {
878 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
879 std::string str = "not_a_number";
880 int32_t num1 = 0;
881 EXPECT_FALSE(screenSettingHelper.ConvertStrToInt32(str, num1));
882 str = "123";
883 EXPECT_TRUE(screenSettingHelper.ConvertStrToInt32(str, num1));
884 EXPECT_EQ(123, num1);
885 }
886
887 /**
888 * @tc.name: RegisterSettingDuringCallStateObserver
889 * @tc.desc: RegisterSettingDuringCallStateObserver
890 * @tc.type: FUNC
891 */
892 HWTEST_F(ScreenSettingHelperTest, RegisterSettingDuringCallStateObserver, TestSize.Level1)
893 {
894 bool flag = false;
__anon866ea65a0702(const std::string&) 895 auto func = [&flag] (const std::string&) {
896 TLOGI(WmsLogTag::DMS, "UT test");
897 flag = true;
898 };
899 ScreenSettingHelper::RegisterSettingDuringCallStateObserver(func);
900 ASSERT_NE(ScreenSettingHelper::duringCallStateObserver_, nullptr);
901 }
902
903 /**
904 * @tc.name: UnregisterSettingDuringCallStateObserver
905 * @tc.desc: UnregisterSettingDuringCallStateObserver
906 * @tc.type: FUNC
907 */
908 HWTEST_F(ScreenSettingHelperTest, UnregisterSettingDuringCallStateObserver, TestSize.Level1)
909 {
910 ScreenSettingHelper::UnregisterSettingDuringCallStateObserver();
911 ASSERT_EQ(ScreenSettingHelper::duringCallStateObserver_, nullptr);
912 }
913
914 /**
915 * @tc.name: GetSettingDuringCallStateTest
916 * @tc.desc: Test GetSettingDuringCallState func
917 * @tc.type: FUNC
918 */
919 HWTEST_F(ScreenSettingHelperTest, GetSettingDuringCallStateTest, Function | SmallTest | Level3)
920 {
921 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
922 return;
923 }
924 ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
925 bool value = true;
926
927 screenSettingHelper.SetSettingDuringCallState("during_call_state", false);
928 screenSettingHelper.GetSettingDuringCallState(value);
929 ASSERT_FALSE(value);
930 }
931 }
932 } // namespace Rosen
933 } // namespace OHOS