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 <hisysevent.h>
19 #include <parameter.h>
20 #include <parameters.h>
21 #include "fold_screen_controller/single_display_pocket_fold_policy.h"
22 #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h"
23 #include "session/screen/include/screen_session.h"
24 #include "screen_session_manager.h"
25 #include "fold_screen_state_internel.h"
26
27 #include "window_manager_hilog.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 namespace {
35 constexpr uint32_t SLEEP_TIME_US = 100000;
36 }
37
38 class SingleDisplayPocketFoldPolicyTest : 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 SingleDisplayPocketFoldPolicyTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void SingleDisplayPocketFoldPolicyTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void SingleDisplayPocketFoldPolicyTest::SetUp()
55 {
56 }
57
TearDown()58 void SingleDisplayPocketFoldPolicyTest::TearDown()
59 {
60 usleep(SLEEP_TIME_US);
61 }
62
63 namespace {
64 /**
65 * @tc.name: ChangeScreenDisplayMode
66 * @tc.desc: test function : ChangeScreenDisplayMode
67 * @tc.type: FUNC
68 */
69 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayMode, TestSize.Level1)
70 {
71 std::recursive_mutex displayInfoMutex;
72 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
73 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
74
75 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
76 policy.ChangeScreenDisplayMode(displayMode);
77 EXPECT_FALSE(policy.onBootAnimation_);
78
79 displayMode = FoldDisplayMode::MAIN;
80 policy.ChangeScreenDisplayMode(displayMode);
81 EXPECT_FALSE(policy.onBootAnimation_);
82
83 displayMode = FoldDisplayMode::FULL;
84 policy.ChangeScreenDisplayMode(displayMode);
85 EXPECT_FALSE(policy.onBootAnimation_);
86
87 displayMode = FoldDisplayMode::SUB;
88 policy.ChangeScreenDisplayMode(displayMode);
89 EXPECT_FALSE(policy.onBootAnimation_);
90
91 ScreenId screenId = 0;
92 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
93 if (nullptr == screenSession) {
94 return;
95 }
96 SensorFoldStateManager mgr = SensorFoldStateManager();
97 mgr.SetTentMode(0);
98 displayMode = FoldDisplayMode::FULL;
99 policy.ChangeScreenDisplayMode(displayMode);
100 EXPECT_EQ(OHOS::system::GetParameter("persist.dms.device.status", "0"), "0");
101
102 displayMode = FoldDisplayMode::MAIN;
103 policy.ChangeScreenDisplayMode(displayMode);
104 EXPECT_EQ(OHOS::system::GetParameter("persist.dms.device.status", "0"), "1");
105 }
106
107 /**
108 * @tc.name: SendSensorResult
109 * @tc.desc: test function : SendSensorResult
110 * @tc.type: FUNC
111 */
112 HWTEST_F(SingleDisplayPocketFoldPolicyTest, SendSensorResult, TestSize.Level1)
113 {
114 std::recursive_mutex displayInfoMutex;
115 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
116 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
117
118 FoldStatus foldStatus = FoldStatus::UNKNOWN;
119 policy.SendSensorResult(foldStatus);
120 EXPECT_FALSE(policy.onBootAnimation_);
121 }
122
123 /**
124 * @tc.name: GetCurrentFoldCreaseRegion
125 * @tc.desc: test function : GetCurrentFoldCreaseRegion
126 * @tc.type: FUNC
127 */
128 HWTEST_F(SingleDisplayPocketFoldPolicyTest, GetCurrentFoldCreaseRegion, TestSize.Level1)
129 {
130 std::recursive_mutex displayInfoMutex;
131 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
132 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
133
134 sptr<FoldCreaseRegion> foldCreaseRegion;
135 foldCreaseRegion = policy.GetCurrentFoldCreaseRegion();
136 EXPECT_EQ(policy.currentFoldCreaseRegion_, foldCreaseRegion);
137 }
138
139 /**
140 * @tc.name: LockDisplayStatus
141 * @tc.desc: test function : LockDisplayStatus
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SingleDisplayPocketFoldPolicyTest, LockDisplayStatus, TestSize.Level1)
145 {
146 std::recursive_mutex displayInfoMutex;
147 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
148 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
149
150 policy.LockDisplayStatus(false);
151 EXPECT_EQ(policy.lockDisplayStatus_, false);
152 }
153
154 /**
155 * @tc.name: SetOnBootAnimation
156 * @tc.desc: test function : SetOnBootAnimation
157 * @tc.type: FUNC
158 */
159 HWTEST_F(SingleDisplayPocketFoldPolicyTest, SetOnBootAnimation, TestSize.Level1)
160 {
161 std::recursive_mutex displayInfoMutex;
162 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
163 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
164
165 policy.SetOnBootAnimation(false);
166 EXPECT_FALSE(policy.onBootAnimation_);
167
168 policy.SetOnBootAnimation(true);
169 EXPECT_TRUE(policy.onBootAnimation_);
170 }
171
172 /**
173 * @tc.name: RecoverWhenBootAnimationExit
174 * @tc.desc: test function : RecoverWhenBootAnimationExit
175 * @tc.type: FUNC
176 */
177 HWTEST_F(SingleDisplayPocketFoldPolicyTest, RecoverWhenBootAnimationExit, TestSize.Level1)
178 {
179 std::recursive_mutex displayInfoMutex;
180 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
181 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
182
183 policy.currentDisplayMode_ = FoldDisplayMode::UNKNOWN;
184 policy.RecoverWhenBootAnimationExit();
185 EXPECT_FALSE(policy.onBootAnimation_);
186
187 policy.currentDisplayMode_ = FoldDisplayMode::SUB;
188 policy.RecoverWhenBootAnimationExit();
189 EXPECT_FALSE(policy.onBootAnimation_);
190
191 policy.currentDisplayMode_ = FoldDisplayMode::FULL;
192 policy.RecoverWhenBootAnimationExit();
193 EXPECT_FALSE(policy.onBootAnimation_);
194
195 policy.currentDisplayMode_ = FoldDisplayMode::MAIN;
196 policy.RecoverWhenBootAnimationExit();
197 EXPECT_FALSE(policy.onBootAnimation_);
198
199 policy.currentDisplayMode_ = FoldDisplayMode::COORDINATION;
200 policy.RecoverWhenBootAnimationExit();
201 EXPECT_FALSE(policy.onBootAnimation_);
202 }
203
204 /**
205 * @tc.name: UpdateForPhyScreenPropertyChange
206 * @tc.desc: test function : UpdateForPhyScreenPropertyChange
207 * @tc.type: FUNC
208 */
209 HWTEST_F(SingleDisplayPocketFoldPolicyTest, UpdateForPhyScreenPropertyChange, TestSize.Level1)
210 {
211 std::recursive_mutex displayInfoMutex;
212 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
213 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
214
215 policy.currentDisplayMode_ = FoldDisplayMode::UNKNOWN;
216 policy.UpdateForPhyScreenPropertyChange();
217 EXPECT_FALSE(policy.onBootAnimation_);
218
219 policy.currentDisplayMode_ = FoldDisplayMode::SUB;
220 policy.UpdateForPhyScreenPropertyChange();
221 EXPECT_FALSE(policy.onBootAnimation_);
222
223 policy.currentDisplayMode_ = FoldDisplayMode::FULL;
224 policy.UpdateForPhyScreenPropertyChange();
225 EXPECT_FALSE(policy.onBootAnimation_);
226
227 policy.currentDisplayMode_ = FoldDisplayMode::MAIN;
228 policy.UpdateForPhyScreenPropertyChange();
229 EXPECT_FALSE(policy.onBootAnimation_);
230
231 policy.currentDisplayMode_ = FoldDisplayMode::COORDINATION;
232 policy.UpdateForPhyScreenPropertyChange();
233 EXPECT_FALSE(policy.onBootAnimation_);
234 }
235
236 /**
237 * @tc.name: GetModeMatchStatus
238 * @tc.desc: test function : GetModeMatchStatus
239 * @tc.type: FUNC
240 */
241 HWTEST_F(SingleDisplayPocketFoldPolicyTest, GetModeMatchStatus, TestSize.Level1)
242 {
243 std::recursive_mutex displayInfoMutex;
244 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
245 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
246 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
247
248 policy.currentFoldStatus_ = FoldStatus::EXPAND;
249 displayMode = policy.GetModeMatchStatus();
250 EXPECT_EQ(FoldDisplayMode::FULL, displayMode);
251
252 policy.currentFoldStatus_ = FoldStatus::FOLDED;
253 displayMode = policy.GetModeMatchStatus();
254 EXPECT_EQ(FoldDisplayMode::MAIN, displayMode);
255
256 policy.currentFoldStatus_ = FoldStatus::HALF_FOLD;
257 displayMode = policy.GetModeMatchStatus();
258 EXPECT_EQ(FoldDisplayMode::FULL, displayMode);
259
260 policy.currentFoldStatus_ = FoldStatus::UNKNOWN;
261 displayMode = policy.GetModeMatchStatus();
262 EXPECT_EQ(FoldDisplayMode::UNKNOWN, displayMode);
263 }
264
265 /**
266 * @tc.name: ReportFoldDisplayModeChange
267 * @tc.desc: test function : ReportFoldDisplayModeChange
268 * @tc.type: FUNC
269 */
270 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ReportFoldDisplayModeChange, TestSize.Level1)
271 {
272 std::recursive_mutex displayInfoMutex;
273 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
274 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
275
276 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
277 policy.ReportFoldDisplayModeChange(displayMode);
278 EXPECT_EQ(FoldDisplayMode::UNKNOWN, displayMode);
279
280 displayMode = FoldDisplayMode::FULL;
281 policy.ReportFoldDisplayModeChange(displayMode);
282 EXPECT_NE(FoldDisplayMode::UNKNOWN, displayMode);
283 }
284
285 /**
286 * @tc.name: ReportFoldStatusChangeBegin
287 * @tc.desc: test function : ReportFoldStatusChangeBegin
288 * @tc.type: FUNC
289 */
290 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ReportFoldStatusChangeBegin, TestSize.Level1)
291 {
292 std::recursive_mutex displayInfoMutex;
293 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
294 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
295
296 int32_t offScreen = 0;
297 int32_t onScreen = 1;
298 policy.ReportFoldStatusChangeBegin(offScreen, onScreen);
299 EXPECT_TRUE(onScreen);
300
301 policy.ReportFoldStatusChangeBegin(offScreen, onScreen);
302 EXPECT_TRUE(onScreen);
303 }
304
305 /**
306 * @tc.name: ChangeScreenDisplayModeToMain
307 * @tc.desc: test function : ChangeScreenDisplayModeToMain
308 * @tc.type: FUNC
309 */
310 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModeToMain, TestSize.Level1)
311 {
312 std::recursive_mutex displayInfoMutex;
313 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
314 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
315 sptr<ScreenSession> screenSession = new ScreenSession;
316
317 policy.onBootAnimation_ = true;
318 policy.ChangeScreenDisplayModeToMain(screenSession);
319 EXPECT_TRUE(policy.onBootAnimation_);
320
321 policy.ChangeScreenDisplayModeToMain(screenSession);
322 EXPECT_TRUE(policy.onBootAnimation_);
323 }
324
325 /**
326 * @tc.name: ChangeScreenDisplayModeToFull
327 * @tc.desc: test function : ChangeScreenDisplayModeToFull
328 * @tc.type: FUNC
329 */
330 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModeToFull, TestSize.Level1)
331 {
332 std::recursive_mutex displayInfoMutex;
333 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
334 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
335 sptr<ScreenSession> screenSession = new ScreenSession;
336
337 policy.onBootAnimation_ = true;
338 policy.ChangeScreenDisplayModeToFull(screenSession);
339 EXPECT_TRUE(policy.onBootAnimation_);
340
341 policy.ChangeScreenDisplayModeToFull(screenSession);
342 EXPECT_TRUE(policy.onBootAnimation_);
343 }
344
345 /**
346 * @tc.name: ChangeScreenDisplayModePower
347 * @tc.desc: test function : ChangeScreenDisplayModePower
348 * @tc.type: FUNC
349 */
350 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModePower, TestSize.Level1)
351 {
352 std::recursive_mutex displayInfoMutex;
353 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
354 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
355 EXPECT_TRUE(1);
356 }
357
358 /**
359 * @tc.name: SendPropertyChangeResult
360 * @tc.desc: test function : SendPropertyChangeResult
361 * @tc.type: FUNC
362 */
363 HWTEST_F(SingleDisplayPocketFoldPolicyTest, SendPropertyChangeResult, TestSize.Level1)
364 {
365 std::recursive_mutex displayInfoMutex;
366 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
367 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
368 sptr<ScreenSession> screenSession = new ScreenSession;
369 ScreenId screenId = 0;
370 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
371
372 policy.SendPropertyChangeResult(screenSession, screenId, reason);
373 EXPECT_FALSE(policy.onBootAnimation_);
374 }
375
376 /**
377 * @tc.name: ChangeScreenDisplayModeToMainOnBootAnimation
378 * @tc.desc: test function : ChangeScreenDisplayModeToMainOnBootAnimation
379 * @tc.type: FUNC
380 */
381 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModeToMainOnBootAnimation, TestSize.Level1)
382 {
383 std::recursive_mutex displayInfoMutex;
384 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
385 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
386 sptr<ScreenSession> screenSession = new ScreenSession;
387
388 policy.ChangeScreenDisplayModeToMainOnBootAnimation(screenSession);
389 EXPECT_FALSE(policy.onBootAnimation_);
390 }
391
392 /**
393 * @tc.name: ChangeScreenDisplayModeToFullOnBootAnimation
394 * @tc.desc: test function : ChangeScreenDisplayModeToFullOnBootAnimation
395 * @tc.type: FUNC
396 */
397 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModeToFullOnBootAnimation, TestSize.Level1)
398 {
399 std::recursive_mutex displayInfoMutex;
400 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
401 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
402 sptr<ScreenSession> screenSession = new ScreenSession;
403
404 policy.ChangeScreenDisplayModeToFullOnBootAnimation(screenSession);
405 EXPECT_FALSE(policy.onBootAnimation_);
406 }
407
408 /**
409 * @tc.name: SetdisplayModeChangeStatus01
410 * @tc.desc: test function : SetdisplayModeChangeStatus
411 * @tc.type: FUNC
412 */
413 HWTEST_F(SingleDisplayPocketFoldPolicyTest, SetdisplayModeChangeStatus01, TestSize.Level1)
414 {
415 std::recursive_mutex displayInfoMutex;
416 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
417 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
418
419 bool status = true;
420 policy.SetdisplayModeChangeStatus(status);
421 EXPECT_EQ(policy.pengdingTask_, 3);
422 }
423
424 /**
425 * @tc.name: SetdisplayModeChangeStatus02
426 * @tc.desc: test function : SetdisplayModeChangeStatus
427 * @tc.type: FUNC
428 */
429 HWTEST_F(SingleDisplayPocketFoldPolicyTest, SetdisplayModeChangeStatus02, TestSize.Level1)
430 {
431 std::recursive_mutex displayInfoMutex;
432 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
433 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
434
435 bool status = false;
436 policy.SetdisplayModeChangeStatus(status);
437 EXPECT_NE(policy.pengdingTask_, 3);
438 }
439
440 /**
441 * @tc.name: ChangeScreenDisplayMode02
442 * @tc.desc: test function : ChangeScreenDisplayMode02
443 * @tc.type: FUNC
444 */
445 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayMode02, TestSize.Level1)
446 {
447 std::recursive_mutex displayInfoMutex;
448 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
449 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
450 sptr<ScreenSession> screenSession = new ScreenSession;
451
452 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
453 policy.ChangeScreenDisplayMode(displayMode);
454 EXPECT_FALSE(policy.onBootAnimation_);
455
456 displayMode = FoldDisplayMode::MAIN;
457 policy.ChangeScreenDisplayMode(displayMode);
458 EXPECT_FALSE(policy.onBootAnimation_);
459
460 displayMode = FoldDisplayMode::FULL;
461 policy.ChangeScreenDisplayMode(displayMode);
462 EXPECT_FALSE(policy.onBootAnimation_);
463
464 displayMode = FoldDisplayMode::SUB;
465 policy.ChangeScreenDisplayMode(displayMode);
466 EXPECT_FALSE(policy.onBootAnimation_);
467
468 displayMode = FoldDisplayMode::COORDINATION;
469 policy.ChangeScreenDisplayMode(displayMode);
470 EXPECT_FALSE(policy.onBootAnimation_);
471 }
472
473 /**
474 * @tc.name: ChangeScreenDisplayModeToCoordination
475 * @tc.desc: test function : ChangeScreenDisplayModeToCoordination
476 * @tc.type: FUNC
477 */
478 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeScreenDisplayModeToCoordination, TestSize.Level1)
479 {
480 std::recursive_mutex displayInfoMutex;
481 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
482 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
483
484 policy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>("Test");
485 policy.ChangeScreenDisplayModeToCoordination();
486 EXPECT_EQ(ScreenSessionManager::GetInstance().isCoordinationFlag_, true);
487 }
488
489 /**
490 * @tc.name: CloseCoordinationScreen
491 * @tc.desc: test function : CloseCoordinationScreen
492 * @tc.type: FUNC
493 */
494 HWTEST_F(SingleDisplayPocketFoldPolicyTest, CloseCoordinationScreen, TestSize.Level1)
495 {
496 if (!FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice()) {
497 GTEST_SKIP();
498 }
499 std::recursive_mutex displayInfoMutex;
500 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
501 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
502
503 policy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>("Test");
504 policy.CloseCoordinationScreen();
505 EXPECT_EQ(ScreenSessionManager::GetInstance().isCoordinationFlag_, false);
506 }
507
508 /**
509 * @tc.name: ExitCoordination
510 * @tc.desc: test function : ExitCoordination
511 * @tc.type: FUNC
512 */
513 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ExitCoordination, TestSize.Level1)
514 {
515 if (!FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice()) {
516 GTEST_SKIP();
517 }
518 std::recursive_mutex displayInfoMutex;
519 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
520 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
521
522 policy.currentFoldStatus_ = FoldStatus::EXPAND;
523 policy.ExitCoordination();
524 EXPECT_EQ(policy.currentDisplayMode_, FoldDisplayMode::FULL);
525 EXPECT_EQ(policy.lastDisplayMode_, FoldDisplayMode::FULL);
526 }
527
528 /**
529 * @tc.name: ChangeOnTentMode
530 * @tc.desc: test function : ChangeOnTentMode
531 * @tc.type: FUNC
532 */
533 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeOnTentMode, TestSize.Level1)
534 {
535 std::recursive_mutex displayInfoMutex;
536 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
537 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
538
539 FoldStatus currentState = FoldStatus::EXPAND;
540 policy.ChangeOnTentMode(currentState);
541 EXPECT_EQ(policy.lastCachedisplayMode_, FoldDisplayMode::MAIN);
542
543 currentState = FoldStatus::HALF_FOLD;
544 policy.ChangeOnTentMode(currentState);
545 EXPECT_EQ(policy.lastCachedisplayMode_, FoldDisplayMode::MAIN);
546
547 currentState = FoldStatus::FOLDED;
548 policy.ChangeOnTentMode(currentState);
549 EXPECT_EQ(policy.lastCachedisplayMode_, FoldDisplayMode::MAIN);
550
551 currentState = FoldStatus::UNKNOWN;
552 policy.ChangeOnTentMode(currentState);
553 EXPECT_EQ(policy.lastCachedisplayMode_, FoldDisplayMode::MAIN);
554 }
555
556 /**
557 * @tc.name: ChangeOffTentMode
558 * @tc.desc: test function : ChangeOffTentMode
559 * @tc.type: FUNC
560 */
561 HWTEST_F(SingleDisplayPocketFoldPolicyTest, ChangeOffTentMode, TestSize.Level1)
562 {
563 std::recursive_mutex displayInfoMutex;
564 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
565 SingleDisplayPocketFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler);
566
567 policy.ChangeOffTentMode();
568 FoldDisplayMode displayMode = policy.GetModeMatchStatus();
569 EXPECT_EQ(policy.lastCachedisplayMode_, displayMode);
570 }
571 }
572 } // namespace Rosen
573 } // namespace OHOS