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 "screen_session_manager/include/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.h"
18 #include "screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h"
19 #include "fold_screen_state_internel.h"
20 #include "window_manager_hilog.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 namespace {
28 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
29 }
30 namespace {
31 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)32 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
33 const char *msg)
34 {
35 g_errLog = msg;
36 }
37 }
38 class SecondaryDisplaySensorFoldStateManagerTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 };
45
SetUpTestCase()46 void SecondaryDisplaySensorFoldStateManagerTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void SecondaryDisplaySensorFoldStateManagerTest::TearDownTestCase()
51 {
52 usleep(SLEEP_TIME_IN_US);
53 }
54
SetUp()55 void SecondaryDisplaySensorFoldStateManagerTest::SetUp()
56 {
57 }
58
TearDown()59 void SecondaryDisplaySensorFoldStateManagerTest::TearDown()
60 {
61 }
62
63 namespace {
64 /**
65 * @tc.name: HandleAngleOrHallChange01
66 * @tc.desc: test function : HandleAngleOrHallChange
67 * @tc.type: FUNC
68 */
69 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange01, TestSize.Level1)
70 {
71 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
72 return;
73 }
74 std::vector<float> angels = {0, 0, 0};
75 std::vector<uint16_t> halls = {0, 0};
76 bool isPostureRegistered = true;
77 sptr<FoldScreenPolicy> foldScreenPolicy = nullptr;
78 SecondaryDisplaySensorFoldStateManager manager;
79 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
80 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true), FoldStatus::FOLDED);
81 }
82
83 /**
84 * @tc.name: HandleAngleOrHallChange02
85 * @tc.desc: test angles.size() != 3
86 * @tc.type: FUNC
87 */
88 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange02, TestSize.Level1)
89 {
90 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
91 return;
92 }
93 std::vector<float> angels = {0, 0};
94 std::vector<uint16_t> halls = {0, 0};
95 bool isPostureRegistered = true;
96 sptr<FoldScreenPolicy> foldScreenPolicy = nullptr;
97 SecondaryDisplaySensorFoldStateManager manager;
98 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
99 angels = {0, 0, 0};
100 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true), FoldStatus::FOLDED);
101 }
102
103 /**
104 * @tc.name: HandleAngleOrHallChange03
105 * @tc.desc: test isSecondaryReflexion
106 * @tc.type: FUNC
107 */
108 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange03, TestSize.Level1)
109 {
110 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
111 return;
112 }
113 std::vector<float> angels = {180, 180, 1};
114 std::vector<uint16_t> halls = {1, 1};
115 bool isPostureRegistered = true;
116 std::recursive_mutex displayInfoMutex;
117 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
118 sptr<FoldScreenPolicy> foldScreenPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex,
119 screenPowerTaskScheduler);
120 EXPECT_NE(foldScreenPolicy, nullptr);
121 SecondaryDisplaySensorFoldStateManager manager;
122 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
123 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
124 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
125 }
126
127 /**
128 * @tc.name: HandleAngleOrHallChange04
129 * @tc.desc: test isHasReflexioned && !isSecondaryReflexion
130 * @tc.type: FUNC
131 */
132 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange04, TestSize.Level1)
133 {
134 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
135 return;
136 }
137 std::vector<float> angels = {180, 180, 0};
138 std::vector<uint16_t> halls = {1, 1};
139 bool isPostureRegistered = true;
140 std::recursive_mutex displayInfoMutex;
141 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
142 sptr<FoldScreenPolicy> foldScreenPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex,
143 screenPowerTaskScheduler);
144 EXPECT_NE(foldScreenPolicy, nullptr);
145 SecondaryDisplaySensorFoldStateManager manager;
146 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
147 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
148 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
149 }
150
151 /**
152 * @tc.name: HandleAngleOrHallChange05
153 * @tc.desc: test curHallAB_ && curHallBC_
154 * @tc.type: FUNC
155 */
156 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange05, TestSize.Level1)
157 {
158 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
159 return;
160 }
161 std::vector<float> angels = { 180, 180, 0 };
162 std::vector<uint16_t> halls = { 1, 1 };
163 bool isPostureRegistered = true;
164 std::recursive_mutex displayInfoMutex;
165 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
166 sptr<FoldScreenPolicy> foldScreenPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex,
167 screenPowerTaskScheduler);
168 ASSERT_NE(foldScreenPolicy, nullptr);
169 SecondaryDisplaySensorFoldStateManager manager;
170 manager.curHallAB_ = 0;
171 manager.curHallBC_ = 0;
172 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
173 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
174 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
175 manager.curHallAB_ = 0;
176 manager.curHallBC_ = 1;
177 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
178 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
179 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
180 manager.curHallAB_ = 1;
181 manager.curHallBC_ = 0;
182 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
183 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
184 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
185 }
186
187 /**
188 * @tc.name: HandleAngleOrHallChange06
189 * @tc.desc: test halls size
190 * @tc.type: FUNC
191 */
192 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange06, TestSize.Level1)
193 {
194 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
195 return;
196 }
197 g_errLog.clear();
198 LOG_SetCallback(MyLogCallback);
199 std::vector<float> angels = { 180, 180, 0 };
200 std::vector<uint16_t> halls = { 1, 1, 1 };
201 bool isPostureRegistered = true;
202 std::recursive_mutex displayInfoMutex;
203 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
204 sptr<FoldScreenPolicy> foldScreenPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex,
205 screenPowerTaskScheduler);
206 ASSERT_NE(foldScreenPolicy, nullptr);
207 SecondaryDisplaySensorFoldStateManager manager;
208 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
209 EXPECT_TRUE(g_errLog.find("halls size is not right") != std::string::npos);
210 }
211
212 /**
213 * @tc.name: HandleAngleOrHallChange07
214 * @tc.desc: test halls size
215 * @tc.type: FUNC
216 */
217 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleAngleOrHallChange07, TestSize.Level1)
218 {
219 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
220 return;
221 }
222 g_errLog.clear();
223 LOG_SetCallback(MyLogCallback);
224 std::vector<float> angels = { 180, 180, 0 };
225 std::vector<uint16_t> halls = { 1, 1 };
226 bool isPostureRegistered = false;
227 std::recursive_mutex displayInfoMutex;
228 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
229 sptr<FoldScreenPolicy> foldScreenPolicy = new SecondaryDisplayFoldPolicy(displayInfoMutex,
230 screenPowerTaskScheduler);
231 ASSERT_NE(foldScreenPolicy, nullptr);
232 SecondaryDisplaySensorFoldStateManager manager;
233 manager.HandleAngleOrHallChange(angels, halls, foldScreenPolicy, isPostureRegistered);
234 EXPECT_EQ(manager.GetNextFoldState(angels, halls, isPostureRegistered, true),
235 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
236 }
237
238 /**
239 * @tc.name: UpdateSwitchScreenBoundaryForLargeFoldDeviceAB
240 * @tc.desc: test function : UpdateSwitchScreenBoundaryForLargeFoldDeviceAB
241 * @tc.type: FUNC
242 */
243 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, UpdateSwitchScreenBoundaryForLargeFoldDeviceAB,
244 TestSize.Level1)
245 {
246 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
247 return;
248 }
249 float angel = 0;
250 uint16_t hall = 0;
251 SecondaryDisplaySensorFoldStateManager manager;
252 FoldStatus state = FoldStatus::UNKNOWN;
253 manager.UpdateSwitchScreenBoundaryForLargeFoldDeviceAB(angel, hall, state);
254 EXPECT_EQ(manager.allowUserSensorForLargeFoldDeviceAB, 0);
255
256 angel = 91.0F;
257 hall = 1;
258 manager.UpdateSwitchScreenBoundaryForLargeFoldDeviceAB(angel, hall, state);
259 EXPECT_EQ(manager.allowUserSensorForLargeFoldDeviceAB, 1);
260 }
261
262 /**
263 * @tc.name: UpdateSwitchScreenBoundaryForLargeFoldDeviceBC
264 * @tc.desc: test function : UpdateSwitchScreenBoundaryForLargeFoldDeviceBC
265 * @tc.type: FUNC
266 */
267 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, UpdateSwitchScreenBoundaryForLargeFoldDeviceBC,
268 TestSize.Level1)
269 {
270 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
271 return;
272 }
273 float angel = 0;
274 uint16_t hall = 0;
275 SecondaryDisplaySensorFoldStateManager manager;
276 FoldStatus state = FoldStatus::UNKNOWN;
277 manager.UpdateSwitchScreenBoundaryForLargeFoldDeviceBC(angel, hall, state);
278 EXPECT_EQ(manager.allowUserSensorForLargeFoldDeviceBC, 0);
279
280 angel = 91.0F;
281 hall = 1;
282 manager.UpdateSwitchScreenBoundaryForLargeFoldDeviceBC(angel, hall, state);
283 EXPECT_EQ(manager.allowUserSensorForLargeFoldDeviceBC, 1);
284 }
285
286 /**
287 * @tc.name: GetNextFoldStateHalf01
288 * @tc.desc: test function : GetNextFoldStateHalf
289 * @tc.type: FUNC
290 */
291 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, GetNextFoldStateHalf01, TestSize.Level1)
292 {
293 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
294 return;
295 }
296 float angel = -0.1;
297 uint16_t hall = 0;
298 int32_t allowUserSensorForLargeFoldDevice = 0;
299 SecondaryDisplaySensorFoldStateManager manager;
300 FoldStatus state = FoldStatus::UNKNOWN;
301 auto result1 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
302 EXPECT_EQ(static_cast<int>(result1), 0);
303
304 angel = 90.0F;
305 hall = 1;
306 auto result2 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
307 EXPECT_EQ(static_cast<int>(result2), 3);
308
309 angel = 130.0F - 0.1;
310 hall = 1;
311 auto result3 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
312 EXPECT_EQ(static_cast<int>(result3), 3);
313
314 angel = 130.0F - 0.1;
315 hall = 0;
316 auto result4 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
317 EXPECT_EQ(static_cast<int>(result4), 3);
318
319 angel = 130.0F + 0.1;
320 hall = 0;
321 auto result5 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
322 EXPECT_EQ(static_cast<int>(result5), 3);
323
324 angel = 140.0F + 0.1;
325 hall = 0;
326 auto result6 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
327 EXPECT_EQ(static_cast<int>(result6), 3);
328
329 angel = 140.0F + 0.1;
330 hall = 1;
331 auto result7 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
332 EXPECT_EQ(static_cast<int>(result7), 1);
333 }
334
335 /**
336 * @tc.name: GetNextFoldStateHalf02
337 * @tc.desc: test function : GetNextFoldStateHalf
338 * @tc.type: FUNC
339 */
340 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, GetNextFoldStateHalf02, TestSize.Level1)
341 {
342 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
343 return;
344 }
345 SecondaryDisplaySensorFoldStateManager manager;
346 int32_t allowUserSensorForLargeFoldDevice = 1;
347 FoldStatus state = FoldStatus::UNKNOWN;
348 float angel = 45.0F;
349 uint16_t hall = 1;
350 auto result1 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
351 EXPECT_EQ(static_cast<int>(result1), 0);
352
353 angel = 70.0F - 0.1;
354 auto result2 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
355 EXPECT_EQ(static_cast<int>(result2), 2);
356
357 angel = 70.0F + 0.1;
358 auto result3 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
359 EXPECT_EQ(static_cast<int>(result3), 3);
360
361 angel = 130.0F - 0.1;
362 auto result4 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
363 EXPECT_EQ(static_cast<int>(result4), 3);
364
365 angel = 130.0F + 0.1;
366 auto result5 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
367 EXPECT_EQ(static_cast<int>(result5), 3);
368
369 angel = 80.0F - 0.1;
370 auto result6 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
371 EXPECT_EQ(static_cast<int>(result6), 3);
372
373 angel = 70.0F + 0.1;
374 hall = 0;
375 auto result7 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
376 EXPECT_EQ(static_cast<int>(result7), 3);
377
378 angel = 130.0F + 0.1;
379 auto result8 = manager.GetNextFoldStateHalf(angel, hall, state, allowUserSensorForLargeFoldDevice);
380 EXPECT_EQ(static_cast<int>(result8), 3);
381 }
382
383 /**
384 * @tc.name: GetGlobalFoldState
385 * @tc.desc: test function : GetGlobalFoldState
386 * @tc.type: FUNC
387 */
388 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, GetGlobalFoldState, TestSize.Level1)
389 {
390 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
391 return;
392 }
393 SecondaryDisplaySensorFoldStateManager manager;
394 FoldStatus nextStatePrimary = FoldStatus::EXPAND;
395 FoldStatus nextStateSecondary = FoldStatus::EXPAND;
396 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
397 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND);
398
399 nextStatePrimary = FoldStatus::FOLDED;
400 nextStateSecondary = FoldStatus::EXPAND;
401 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
402 FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND);
403
404 nextStatePrimary = FoldStatus::HALF_FOLD;
405 nextStateSecondary = FoldStatus::EXPAND;
406 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
407 FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_EXPAND);
408
409 nextStatePrimary = FoldStatus::EXPAND;
410 nextStateSecondary = FoldStatus::FOLDED;
411 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
412 FoldStatus::EXPAND);
413
414 nextStatePrimary = FoldStatus::FOLDED;
415 nextStateSecondary = FoldStatus::FOLDED;
416 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
417 FoldStatus::FOLDED);
418
419 nextStatePrimary = FoldStatus::HALF_FOLD;
420 nextStateSecondary = FoldStatus::FOLDED;
421 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
422 FoldStatus::HALF_FOLD);
423
424 nextStatePrimary = FoldStatus::EXPAND;
425 nextStateSecondary = FoldStatus::HALF_FOLD;
426 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
427 FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_HALF_FOLDED);
428
429 nextStatePrimary = FoldStatus::FOLDED;
430 nextStateSecondary = FoldStatus::HALF_FOLD;
431 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
432 FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_HALF_FOLDED);
433
434 nextStatePrimary = FoldStatus::HALF_FOLD;
435 nextStateSecondary = FoldStatus::HALF_FOLD;
436 EXPECT_EQ(manager.GetGlobalFoldState(nextStatePrimary, nextStateSecondary),
437 FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_HALF_FOLDED);
438 }
439
440 /**
441 * @tc.name: HandleSecondaryOneStep0
442 * @tc.desc: test function : HandleSecondaryOneStep
443 * @tc.type: FUNC
444 */
445 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleSecondaryOneStep0,
446 TestSize.Level1)
447 {
448 std::vector<float> angles = {0.0f, 0.0f, 0.0f};
449 std::vector<uint16_t> halls = {0, 0};
450 SecondaryDisplaySensorFoldStateManager manager;
451 FoldStatus previousState = FoldStatus::EXPAND;
452 FoldStatus nextState = FoldStatus::HALF_FOLD;
453 FoldStatus newState = FoldStatus::UNKNOWN;
454 newState = manager.HandleSecondaryOneStep(previousState, nextState, angles, halls);
455 EXPECT_EQ(FoldStatus::HALF_FOLD, newState);
456
457 previousState = FoldStatus::FOLDED;
458 nextState = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
459 newState = manager.HandleSecondaryOneStep(previousState, nextState, angles, halls);
460 EXPECT_EQ(FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND, newState);
461 }
462
463 /**
464 * @tc.name: HandleSecondaryOneStep1
465 * @tc.desc: test function : HandleSecondaryOneStep
466 * @tc.type: FUNC
467 */
468 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, HandleSecondaryOneStep1,
469 TestSize.Level1)
470 {
471 std::vector<float> angles = {0.0f, 0.0f, 0.0f};
472 std::vector<uint16_t> halls = {0, 0};
473 SecondaryDisplaySensorFoldStateManager manager;
474 FoldStatus previousState = FoldStatus::FOLDED;
475 FoldStatus nextState = FoldStatus::HALF_FOLD;
476 manager.HandleSecondaryOneStep(previousState, nextState, angles, halls);
477 EXPECT_FALSE(manager.isInOneStep_);
478 }
479
480 /**
481 * @tc.name: CalculateNewABFoldStatus
482 * @tc.desc: test function : CalculateNewABFoldStatus
483 * @tc.type: FUNC
484 */
485 HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, CalculateNewABFoldStatus,
486 TestSize.Level1)
487 {
488 SecondaryDisplaySensorFoldStateManager manager;
489 FoldStatus newState = FoldStatus::UNKNOWN;
490 newState = manager.CalculateNewABFoldStatus(0.0f, 1, 0.0f, 0);
491 EXPECT_EQ(FoldStatus::FOLDED, newState);
492
493 newState = manager.CalculateNewABFoldStatus(0.0f, 0, 20.0f, 0);
494 EXPECT_EQ(FoldStatus::HALF_FOLD, newState);
495
496 newState = manager.CalculateNewABFoldStatus(40.0f, 0, 50.0f, 0);
497 EXPECT_EQ(FoldStatus::HALF_FOLD, newState);
498
499 newState = manager.CalculateNewABFoldStatus(40.0f, 0, 150.0f, 0);
500 EXPECT_EQ(FoldStatus::EXPAND, newState);
501 }
502 }
503 }
504 }