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 #include <hisysevent.h>
18
19 #include "fold_screen_controller/super_fold_sensor_manager.h"
20 #include "fold_screen_state_internel.h"
21 #include "window_manager_hilog.h"
22 #include "screen_session_manager.h"
23 #include "scene_board_judgement.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr uint32_t SLEEP_TIME_US = 100000;
32 constexpr uint16_t VALID_HALL_STATUS = 0;
33 constexpr uint16_t HALL_HAVE_KEYBOARD_THRESHOLD = 0B0100;
34 }
35
36 class SuperFoldSensorManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void SuperFoldSensorManagerTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void SuperFoldSensorManagerTest::TearDownTestCase()
49 {
50 }
51
SetUp()52 void SuperFoldSensorManagerTest::SetUp()
53 {
54 }
55
TearDown()56 void SuperFoldSensorManagerTest::TearDown()
57 {
58 usleep(SLEEP_TIME_US);
59 }
60
61 namespace {
62 /**
63 * @tc.name: RegisterPostureCallback01
64 * @tc.desc: test function : RegisterPostureCallback
65 * @tc.type: FUNC
66 */
67 HWTEST_F(SuperFoldSensorManagerTest, RegisterPostureCallback01, TestSize.Level1)
68 {
69 SuperFoldSensorManager mgr = SuperFoldSensorManager();
70 mgr.RegisterPostureCallback();
71 ASSERT_NE(mgr.postureUser.callback, nullptr);
72 }
73
74 /**
75 * @tc.name: RegisterPostureCallback01
76 * @tc.desc: test function : RegisterPostureCallback
77 * @tc.type: FUNC
78 */
79 HWTEST_F(SuperFoldSensorManagerTest, RegisterPostureCallback02, TestSize.Level1)
80 {
81 SuperFoldSensorManager mgr = SuperFoldSensorManager();
82 mgr.RegisterPostureCallback();
83 void (*func)(SensorEvent *event) = nullptr;
84 ASSERT_NE(mgr.postureUser.callback, func);
85 }
86
87 /**
88 * @tc.name: UnregisterPostureCallback01
89 * @tc.desc: test function : UnregisterPostureCallback
90 * @tc.type: FUNC
91 */
92 HWTEST_F(SuperFoldSensorManagerTest, UnregisterPostureCallback01, TestSize.Level1)
93 {
94 SuperFoldSensorManager mgr = SuperFoldSensorManager();
95 mgr.UnregisterPostureCallback();
96 ASSERT_EQ(mgr.postureUser.callback, nullptr);
97 }
98
99 /**
100 * @tc.name: UnregisterPostureCallback02
101 * @tc.desc: test function : UnregisterPostureCallback
102 * @tc.type: FUNC
103 */
104 HWTEST_F(SuperFoldSensorManagerTest, UnregisterPostureCallback02, TestSize.Level1)
105 {
106 SuperFoldSensorManager mgr = SuperFoldSensorManager();
107 mgr.UnregisterPostureCallback();
108 void (*func)(SensorEvent *event) = nullptr;
109 ASSERT_EQ(mgr.postureUser.callback, func);
110 }
111
112 /**
113 * @tc.name: RegisterHallCallback01
114 * @tc.desc: test function : RegisterHallCallback
115 * @tc.type: FUNC
116 */
117 HWTEST_F(SuperFoldSensorManagerTest, RegisterHallCallback01, TestSize.Level1)
118 {
119 SuperFoldSensorManager mgr = SuperFoldSensorManager();
120 mgr.RegisterHallCallback();
121 ASSERT_NE(mgr.hallUser.callback, nullptr);
122 }
123
124 /**
125 * @tc.name: RegisterHallCallback02
126 * @tc.desc: test function : RegisterHallCallback
127 * @tc.type: FUNC
128 */
129 HWTEST_F(SuperFoldSensorManagerTest, RegisterHallCallback02, TestSize.Level1)
130 {
131 SuperFoldSensorManager mgr = SuperFoldSensorManager();
132 mgr.RegisterHallCallback();
133 void (*func)(SensorEvent *event) = nullptr;
134 ASSERT_NE(mgr.hallUser.callback, func);
135 }
136
137 /**
138 * @tc.name: UnregisterHallCallback01
139 * @tc.desc: test function : UnregisterHallCallback
140 * @tc.type: FUNC
141 */
142 HWTEST_F(SuperFoldSensorManagerTest, UnregisterHallCallback01, TestSize.Level1)
143 {
144 SuperFoldSensorManager mgr = SuperFoldSensorManager();
145 mgr.UnregisterHallCallback();
146 ASSERT_EQ(mgr.hallUser.callback, nullptr);
147 }
148
149 /**
150 * @tc.name: UnregisterHallCallback02
151 * @tc.desc: test function : UnregisterHallCallback
152 * @tc.type: FUNC
153 */
154 HWTEST_F(SuperFoldSensorManagerTest, UnregisterHallCallback02, TestSize.Level1)
155 {
156 SuperFoldSensorManager mgr = SuperFoldSensorManager();
157 mgr.UnregisterHallCallback();
158 void (*func)(SensorEvent *event) = nullptr;
159 ASSERT_EQ(mgr.hallUser.callback, func);
160 }
161
162 /**
163 * @tc.name: HandlePostureData01
164 * @tc.desc: test function : HandlePostureData
165 * @tc.type: FUNC
166 */
167 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData01, TestSize.Level1)
168 {
169 SuperFoldSensorManager mgr = SuperFoldSensorManager();
170 mgr.HandlePostureData(nullptr);
171 ASSERT_EQ(mgr.curAngle_, 170.0F);
172 }
173
174 /**
175 * @tc.name: HandlePostureData02
176 * @tc.desc: test function : HandlePostureData
177 * @tc.type: FUNC
178 */
179 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData02, TestSize.Level1)
180 {
181 SuperFoldSensorManager mgr = SuperFoldSensorManager();
182 mgr.HandlePostureData(nullptr);
183 EXPECT_EQ(mgr.curAngle_, 170.0F);
184
185 SensorEvent event;
186 PostureData postureData;
187 postureData.angle = 45.0F;
188 mgr.HandlePostureData(&event);
189 ASSERT_EQ(mgr.curAngle_, 170.0F);
190 }
191
192 /**
193 * @tc.name: HandlePostureData03
194 * @tc.desc: test function : HandlePostureData
195 * @tc.type: FUNC
196 */
197 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData03, TestSize.Level1)
198 {
199 SuperFoldSensorManager mgr = SuperFoldSensorManager();
200 mgr.HandlePostureData(nullptr);
201 ASSERT_EQ(mgr.curAngle_, 170.0F);
202
203 SensorEvent event;
204 PostureData postureData;
205 postureData.angle = 45.0F;
206 mgr.HandlePostureData(&event);
207 EXPECT_EQ(mgr.curAngle_, 170.0F);
208
209 event.data = reinterpret_cast<uint8_t*>(&postureData);
210 event.dataLen = 0;
211 mgr.HandlePostureData(&event);
212 ASSERT_EQ(mgr.curAngle_, 170.0F);
213 }
214
215 /**
216 * @tc.name: HandlePostureData04
217 * @tc.desc: test function : HandlePostureData
218 * @tc.type: FUNC
219 */
220 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData04, TestSize.Level1)
221 {
222 SuperFoldSensorManager mgr = SuperFoldSensorManager();
223 mgr.HandlePostureData(nullptr);
224 ASSERT_EQ(mgr.curAngle_, 170.0F);
225
226 SensorEvent event;
227 PostureData postureData;
228 postureData.angle = 45.0F;
229 mgr.HandlePostureData(&event);
230 EXPECT_EQ(mgr.curAngle_, 170.0F);
231
232 event.data = reinterpret_cast<uint8_t*>(&postureData);
233 event.dataLen = 0;
234 mgr.HandlePostureData(&event);
235 EXPECT_EQ(mgr.curAngle_, 170.0F);
236
237 event.dataLen = sizeof(PostureData);
238 mgr.HandlePostureData(&event);
239 ASSERT_EQ(mgr.curAngle_, 45.0F);
240 }
241
242 /**
243 * @tc.name: HandlePostureData05
244 * @tc.desc: test function: HandlePostureData when taskScheduler is valid.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData05, TestSize.Level1)
248 {
249 SuperFoldSensorManager mgr = SuperFoldSensorManager();
250 auto scheduler = std::make_shared<TaskScheduler>("task_test");
251
252 mgr.SetTaskScheduler(scheduler);
253 SensorEvent event;
254 PostureData postureData;
255 postureData.angle = 45.0F;
256 event.data = reinterpret_cast<uint8_t*>(&postureData);
257 event.dataLen = sizeof(PostureData);
258 mgr.HandlePostureData(&event);
259 EXPECT_EQ(mgr.curAngle_, 45.0F);
260 }
261
262 /**
263 * @tc.name: HandlePostureData06
264 * @tc.desc: test function: HandlePostureData when taskScheduler is nullptr.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData06, TestSize.Level1)
268 {
269 SuperFoldSensorManager mgr = SuperFoldSensorManager();
270
271 mgr.SetTaskScheduler(nullptr);
272 SensorEvent event;
273 PostureData postureData;
274 postureData.angle = 45.0F;
275 event.data = reinterpret_cast<uint8_t*>(&postureData);
276 event.dataLen = sizeof(PostureData);
277 mgr.HandlePostureData(&event);
278 EXPECT_EQ(mgr.curAngle_, 45.0F);
279 }
280
281
282 /**
283 * @tc.name: NotifyFoldAngleChanged01
284 * @tc.desc: test function : NotifyFoldAngleChanged
285 * @tc.type: FUNC
286 */
287 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged01, TestSize.Level1)
288 {
289 SuperFoldSensorManager mgr = SuperFoldSensorManager();
290 float foldAngle = 0.0F;
291 mgr.NotifyFoldAngleChanged(foldAngle);
292 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
293 usleep(SLEEP_TIME_US);
294 }
295
296 /**
297 * @tc.name: NotifyFoldAngleChanged02
298 * @tc.desc: test function : NotifyFoldAngleChanged
299 * @tc.type: FUNC
300 */
301 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged02, TestSize.Level1)
302 {
303 SuperFoldSensorManager mgr = SuperFoldSensorManager();
304 float foldAngle = 30.0F;
305 mgr.NotifyFoldAngleChanged(foldAngle);
306 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
307 usleep(SLEEP_TIME_US);
308 }
309
310 /**
311 * @tc.name: NotifyFoldAngleChanged03
312 * @tc.desc: test function : NotifyFoldAngleChanged
313 * @tc.type: FUNC
314 */
315 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged03, TestSize.Level1)
316 {
317 SuperFoldSensorManager mgr = SuperFoldSensorManager();
318 float foldAngle = 165.0F;
319 mgr.NotifyFoldAngleChanged(foldAngle);
320 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
321 usleep(SLEEP_TIME_US);
322 }
323
324 /**
325 * @tc.name: NotifyFoldAngleChanged04
326 * @tc.desc: test function : NotifyFoldAngleChanged
327 * @tc.type: FUNC
328 */
329 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged04, Function | SmallTest | Level3)
330 {
331 SuperFoldSensorManager mgr = SuperFoldSensorManager();
332 float foldAngle = 90.0F;
333 mgr.NotifyFoldAngleChanged(foldAngle);
334 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
335 usleep(SLEEP_TIME_US);
336 }
337
338 /**
339 * @tc.name: NotifyFoldAngleChanged05
340 * @tc.desc: test function : NotifyFoldAngleChanged
341 * @tc.type: FUNC
342 */
343 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged05, Function | SmallTest | Level3)
344 {
345 SuperFoldSensorManager mgr = SuperFoldSensorManager();
346 float foldAngle = 135.0F;
347 mgr.NotifyFoldAngleChanged(foldAngle);
348 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
349 usleep(SLEEP_TIME_US);
350 }
351
352 /**
353 * @tc.name: HandleHallData01
354 * @tc.desc: test function : HandleHallData
355 * @tc.type: FUNC
356 */
357 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData01, TestSize.Level1)
358 {
359 SuperFoldSensorManager mgr = SuperFoldSensorManager();
360 mgr.HandleHallData(nullptr);
361 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
362 }
363
364 /**
365 * @tc.name: HandleHallData02
366 * @tc.desc: test function : HandleHallData
367 * @tc.type: FUNC
368 */
369 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData02, TestSize.Level1)
370 {
371 SuperFoldSensorManager mgr = SuperFoldSensorManager();
372 mgr.HandleHallData(nullptr);
373 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
374
375 SensorEvent event;
376 mgr.HandleHallData(&event);
377 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
378 }
379
380 /**
381 * @tc.name: HandleHallData03
382 * @tc.desc: test function : HandleHallData
383 * @tc.type: FUNC
384 */
385 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData03, TestSize.Level1)
386 {
387 SuperFoldSensorManager mgr = SuperFoldSensorManager();
388 mgr.HandleHallData(nullptr);
389 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
390
391 SensorEvent event;
392 mgr.HandleHallData(&event);
393 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
394
395 HallData hallData;
396 event.data = reinterpret_cast<uint8_t*>(&hallData);
397 mgr.HandleHallData(&event);
398 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
399 }
400
401 /**
402 * @tc.name: HandleHallData04
403 * @tc.desc: test function : HandleHallData
404 * @tc.type: FUNC
405 */
406 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData04, TestSize.Level1)
407 {
408 SuperFoldSensorManager mgr = SuperFoldSensorManager();
409 mgr.HandleHallData(nullptr);
410 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
411
412 SensorEvent event;
413 mgr.HandleHallData(&event);
414 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
415
416 HallData hallData;
417 event.data = reinterpret_cast<uint8_t*>(&hallData);
418 mgr.HandleHallData(&event);
419 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
420
421 event.dataLen = 0;
422 mgr.HandleHallData(&event);
423 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
424 }
425
426 /**
427 * @tc.name: HandleHallData05
428 * @tc.desc: test function : HandleHallData
429 * @tc.type: FUNC
430 */
431 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData05, TestSize.Level1)
432 {
433 SuperFoldSensorManager mgr = SuperFoldSensorManager();
434 mgr.HandleHallData(nullptr);
435 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
436
437 SensorEvent event;
438 mgr.HandleHallData(&event);
439 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
440
441 HallData hallData;
442 event.data = reinterpret_cast<uint8_t*>(&hallData);
443 mgr.HandleHallData(&event);
444 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
445
446 event.dataLen = 0;
447 mgr.HandleHallData(&event);
448 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
449
450 event.dataLen = sizeof(HallData);
451 mgr.HandleHallData(&event);
452 ASSERT_EQ(mgr.curHall_, VALID_HALL_STATUS);
453 }
454
455 /**
456 * @tc.name: HandleHallData06
457 * @tc.desc: test function : HandleHallData
458 * @tc.type: FUNC
459 */
460 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData06, TestSize.Level1)
461 {
462 SuperFoldSensorManager mgr = SuperFoldSensorManager();
463 mgr.HandleHallData(nullptr);
464 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
465
466 SensorEvent event;
467 mgr.HandleHallData(&event);
468 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
469
470 HallData hallData;
471 event.data = reinterpret_cast<uint8_t*>(&hallData);
472 mgr.HandleHallData(&event);
473 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
474
475 event.dataLen = 0;
476 mgr.HandleHallData(&event);
477 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
478
479 event.dataLen = sizeof(HallData);
480 mgr.HandleHallData(&event);
481 EXPECT_EQ(mgr.curHall_, VALID_HALL_STATUS);
482
483 hallData.status = 132;
484 mgr.HandleHallData(&event);
485 ASSERT_EQ(mgr.curHall_, HALL_HAVE_KEYBOARD_THRESHOLD);
486 }
487
488 /**
489 * @tc.name: HandleHallData07
490 * @tc.desc: test function : HandleHallData when taskScheduler is valid.
491 * @tc.type: FUNC
492 */
493 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData07, TestSize.Level1)
494 {
495 SuperFoldSensorManager mgr = SuperFoldSensorManager();
496 SensorEvent event;
497 HallData hallData;
498 event.data = reinterpret_cast<uint8_t*>(&hallData);
499 event.dataLen = sizeof(HallData);
500
501 auto scheduler = std::make_shared<TaskScheduler>("task_test");
502 mgr.SetTaskScheduler(scheduler);
503 mgr.HandleHallData(&event);
504 EXPECT_EQ(mgr.curHall_, VALID_HALL_STATUS);
505 }
506
507 /**
508 * @tc.name: HandleHallData08
509 * @tc.desc: test function : HandleHallData when taskScheduler is nullptr.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData08, TestSize.Level1)
513 {
514 SuperFoldSensorManager mgr = SuperFoldSensorManager();
515 SensorEvent event;
516 HallData hallData;
517 event.data = reinterpret_cast<uint8_t*>(&hallData);
518 event.dataLen = sizeof(HallData);
519
520 mgr.SetTaskScheduler(nullptr);
521 mgr.HandleHallData(&event);
522 EXPECT_EQ(mgr.curHall_, VALID_HALL_STATUS);
523 }
524
525
526 /**
527 * @tc.name: NotifyHallChanged
528 * @tc.desc: test function : NotifyHallChanged
529 * @tc.type: FUNC
530 */
531 HWTEST_F(SuperFoldSensorManagerTest, NotifyHallChanged, Function | SmallTest | Level3)
532 {
533 SuperFoldSensorManager mgr = SuperFoldSensorManager();
534 mgr.NotifyHallChanged(0B0000);
535 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
536 mgr.NotifyHallChanged(0B0100);
537 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
538 mgr.NotifyHallChanged(0B0101);
539 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
540 mgr.curAngle_ = 165.0F;
541 mgr.NotifyHallChanged(0B0000);
542 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
543 }
544
545 /**
546 * @tc.name: HandleSuperSensorChange
547 * @tc.desc: test function : HandleSuperSensorChange
548 * @tc.type: FUNC
549 */
550 HWTEST_F(SuperFoldSensorManagerTest, HandleSuperSensorChange, Function | SmallTest | Level3)
551 {
552 SuperFoldSensorManager mgr = SuperFoldSensorManager();
553 ScreenSessionManager::GetInstance().isExtendScreenConnected_ = true;
554 mgr.HandleSuperSensorChange(SuperFoldStatusChangeEvents::ANGLE_CHANGE_EXPANDED);
555 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
556 ScreenSessionManager::GetInstance().isExtendScreenConnected_ = false;
557 mgr.HandleSuperSensorChange(SuperFoldStatusChangeEvents::ANGLE_CHANGE_EXPANDED);
558 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
559 }
560
561 /**
562 * @tc.name: HandleScreenConnectChange
563 * @tc.desc: test function : HandleScreenConnectChange
564 * @tc.type: FUNC
565 */
566 HWTEST_F(SuperFoldSensorManagerTest, HandleScreenConnectChange, Function | SmallTest | Level3)
567 {
568 SuperFoldSensorManager mgr = SuperFoldSensorManager();
569 mgr.HandleScreenConnectChange();
570 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
571 }
572
573 /**
574 * @tc.name: HandleScreenDisconnectChange
575 * @tc.desc: test function : HandleScreenDisconnectChange
576 * @tc.type: FUNC
577 */
578 HWTEST_F(SuperFoldSensorManagerTest, HandleScreenDisconnectChange, Function | SmallTest | Level3)
579 {
580 SuperFoldSensorManager mgr = SuperFoldSensorManager();
581 mgr.HandleScreenDisconnectChange();
582 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
583 }
584
585 /**
586 * @tc.name: GetCurAngle
587 * @tc.desc: test function : GetCurAngle
588 * @tc.type: FUNC
589 */
590 HWTEST_F(SuperFoldSensorManagerTest, GetCurAngle, Function | SmallTest | Level3)
591 {
592 SuperFoldSensorManager mgr = SuperFoldSensorManager();
593 mgr.curAngle_ = 110.0F;
594 float angle = mgr.GetCurAngle();
595 ASSERT_EQ(angle, 110.0F);
596 }
597
598 /**
599 * @tc.name: HandleFoldStatusLockedToExpand
600 * @tc.desc: HandleFoldStatusLockedToExpand
601 * @tc.type: FUNC
602 */
603 HWTEST_F(SuperFoldSensorManagerTest, HandleFoldStatusLockedToExpand, TestSize.Level1)
604 {
605 if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
606 GTEST_SKIP();
607 }
608 SuperFoldSensorManager mgr = SuperFoldSensorManager();
609 mgr.HandleFoldStatusLockedToExpand();
610 EXPECT_NE(SuperFoldStateManager::GetInstance().curState_, SuperFoldStatus::UNKNOWN);
611
612 mgr.HandleFoldStatusLockedToExpand();
613 EXPECT_NE(SuperFoldStateManager::GetInstance().curState_, SuperFoldStatus::UNKNOWN);
614 }
615
616 /**
617 * @tc.name: SetTaskScheduler01
618 * @tc.number: SetTaskSchedulerTest_001
619 * @tc.desc: taskScheduler_ could be properly set when the input is valid.
620 */
621 HWTEST_F(SuperFoldSensorManagerTest, SetTaskScheduler01, TestSize.Level1)
622 {
623 SuperFoldSensorManager mgr = SuperFoldSensorManager();
624 auto scheduler = std::make_shared<TaskScheduler>("task_test");
625
626 mgr.SetTaskScheduler(scheduler);
627 EXPECT_EQ(mgr.taskScheduler_.get(), scheduler.get());
628 }
629
630 /**
631 * @tc.name: SetTaskScheduler02
632 * @tc.number: SetTaskSchedulerTest_002
633 * @tc.desc: taskScheduler_ could be properly set when the input is nullptr.
634 */
635 HWTEST_F(SuperFoldSensorManagerTest, SetTaskScheduler02, TestSize.Level1)
636 {
637 SuperFoldSensorManager mgr = SuperFoldSensorManager();
638
639 mgr.SetTaskScheduler(nullptr);
640 EXPECT_EQ(mgr.taskScheduler_, nullptr);
641 }
642 }
643 } // namespace Rosen
644 } // namespace OHOS