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 "fold_screen_controller/dual_display_fold_policy.h"
19 #include "fold_screen_controller/fold_screen_controller.h"
20 #include "screen_session_manager/include/screen_session_manager.h"
21 #include "fold_screen_state_internel.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 = 500000;
30 const std::string DUAL_DISPLAY_FOLD_POLICY_TEST = "DualDisplayFoldPolicyTest";
31 }
32
33 class DualDisplayFoldPolicyTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 static ScreenSessionManager& ssm_;
40 };
41
42 ScreenSessionManager& DualDisplayFoldPolicyTest::ssm_ = ScreenSessionManager::GetInstance();
43
SetUpTestCase()44 void DualDisplayFoldPolicyTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void DualDisplayFoldPolicyTest::TearDownTestCase()
49 {
50 }
51
SetUp()52 void DualDisplayFoldPolicyTest::SetUp()
53 {
54 }
55
TearDown()56 void DualDisplayFoldPolicyTest::TearDown()
57 {
58 usleep(SLEEP_TIME_US);
59 }
60
61 namespace {
62
63 /**
64 * @tc.name: ChangeScreenDisplayMode
65 * @tc.desc: ChangeScreenDisplayMode
66 * @tc.type: FUNC
67 */
68 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayMode, Function | SmallTest | Level3)
69 {
70 std::recursive_mutex mutex;
71 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
72 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::UNKNOWN);
73 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
74 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
75
76 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::SUB);
77 mode = ssm_.GetFoldDisplayMode();
78 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
79
80 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::MAIN);
81 mode = ssm_.GetFoldDisplayMode();
82 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
83
84 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::COORDINATION);
85 mode = ssm_.GetFoldDisplayMode();
86 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
87 }
88
89 /**
90 * @tc.name: ChangeScreenDisplayMode
91 * @tc.desc: ChangeScreenDisplayMode
92 * @tc.type: FUNC
93 */
94 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayMode02, Function | SmallTest | Level3)
95 {
96 std::recursive_mutex mutex;
97 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
98 sptr<ScreenSession> session = new ScreenSession();
99 ScreenId screenId = 1001;
100 ssm_.screenSessionMap_[screenId] = session;
101 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::UNKNOWN);
102 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
103 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
104
105 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::SUB);
106 mode = ssm_.GetFoldDisplayMode();
107 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
108
109 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::MAIN);
110 mode = ssm_.GetFoldDisplayMode();
111 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
112
113 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::COORDINATION);
114 mode = ssm_.GetFoldDisplayMode();
115 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
116 }
117
118 /**
119 * @tc.name: SendSensorResult
120 * @tc.desc: SendSensorResult
121 * @tc.type: FUNC
122 */
123 HWTEST_F(DualDisplayFoldPolicyTest, SendSensorResult, Function | SmallTest | Level3)
124 {
125 std::recursive_mutex mutex;
126 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
127 dualDisplayFoldPolicy.SendSensorResult(FoldStatus::UNKNOWN);
128 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
129 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
130 }
131
132 /**
133 * @tc.name: SetOnBootAnimation
134 * @tc.desc: SetOnBootAnimation
135 * @tc.type: FUNC
136 */
137 HWTEST_F(DualDisplayFoldPolicyTest, SetOnBootAnimation, Function | SmallTest | Level3)
138 {
139 std::recursive_mutex mutex;
140 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
141 dualDisplayFoldPolicy.SetOnBootAnimation(true);
142 ASSERT_TRUE(dualDisplayFoldPolicy.onBootAnimation_);
143
144 dualDisplayFoldPolicy.SetOnBootAnimation(false);
145 ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
146 }
147
148 /**
149 * @tc.name: GetCurrentFoldCreaseRegion
150 * @tc.desc: GetCurrentFoldCreaseRegion
151 * @tc.type: FUNC
152 */
153 HWTEST_F(DualDisplayFoldPolicyTest, GetCurrentFoldCreaseRegion, Function | SmallTest | Level3)
154 {
155 std::recursive_mutex mutex;
156 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
157 sptr<FoldCreaseRegion> res = dualDisplayFoldPolicy.GetCurrentFoldCreaseRegion();
158 ASSERT_EQ(res, dualDisplayFoldPolicy.currentFoldCreaseRegion_);
159 }
160
161 /**
162 * @tc.name: LockDisplayStatus
163 * @tc.desc: LockDisplayStatus
164 * @tc.type: FUNC
165 */
166 HWTEST_F(DualDisplayFoldPolicyTest, LockDisplayStatus, Function | SmallTest | Level3)
167 {
168 std::recursive_mutex mutex;
169 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
170 bool locked = false;
171 dualDisplayFoldPolicy.LockDisplayStatus(locked);
172 ASSERT_EQ(locked, dualDisplayFoldPolicy.lockDisplayStatus_);
173 }
174
175 /**
176 * @tc.name: RecoverWhenBootAnimationExit0
177 * @tc.desc: RecoverWhenBootAnimationExit0
178 * @tc.type: FUNC
179 */
180 HWTEST_F(DualDisplayFoldPolicyTest, RecoverWhenBootAnimationExit0, Function | SmallTest | Level3)
181 {
182 std::recursive_mutex mutex;
183 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
184 dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::UNKNOWN;
185 dualDisplayFoldPolicy.currentDisplayMode_ = FoldDisplayMode::MAIN;
186 dualDisplayFoldPolicy.RecoverWhenBootAnimationExit();
187 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
188 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
189 }
190
191 /**
192 * @tc.name: UpdateForPhyScreenPropertyChange0
193 * @tc.desc: UpdateForPhyScreenPropertyChange0
194 * @tc.type: FUNC
195 */
196 HWTEST_F(DualDisplayFoldPolicyTest, UpdateForPhyScreenPropertyChange0, Function | SmallTest | Level3)
197 {
198 std::recursive_mutex mutex;
199 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
200 dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::UNKNOWN;
201 dualDisplayFoldPolicy.currentDisplayMode_ = FoldDisplayMode::MAIN;
202 dualDisplayFoldPolicy.UpdateForPhyScreenPropertyChange();
203 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
204 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
205 }
206
207 /**
208 * @tc.name: ChangeScreenDisplayModeInner01
209 * @tc.desc: ChangeScreenDisplayModeInner01
210 * @tc.type: FUNC
211 */
212 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeInner01, Function | SmallTest | Level3)
213 {
214 std::recursive_mutex mutex;
215 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
216 dualDisplayFoldPolicy.onBootAnimation_ = true;
217 sptr<ScreenSession> screenSession = new ScreenSession();
218 ScreenId offScreenId = 0;
219 ScreenId onScreenId = 5;
220 dualDisplayFoldPolicy.ChangeScreenDisplayModeInner(screenSession, offScreenId, onScreenId);
221 int res = 0;
222 ASSERT_EQ(res, 0);
223 }
224
225 /**
226 * @tc.name: ChangeScreenDisplayModeToCoordination
227 * @tc.desc: ChangeScreenDisplayModeToCoordination
228 * @tc.type: FUNC
229 */
230 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeToCoordination, Function | SmallTest | Level3)
231 {
232 if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
233 std::recursive_mutex mutex;
234 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = std::make_shared<TaskScheduler>(
235 DUAL_DISPLAY_FOLD_POLICY_TEST);
236 sptr<DualDisplayFoldPolicy> dualDisplayFoldPolicy = new DualDisplayFoldPolicy(
237 mutex, screenPowerTaskScheduler);
238 dualDisplayFoldPolicy->ChangeScreenDisplayModeToCoordination();
239 ASSERT_FALSE(ssm_.keyguardDrawnDone_);
240 }
241 }
242
243 /**
244 * @tc.name: UpdateForPhyScreenPropertyChange
245 * @tc.desc: UpdateForPhyScreenPropertyChange
246 * @tc.type: FUNC
247 */
248 HWTEST_F(DualDisplayFoldPolicyTest, UpdateForPhyScreenPropertyChange, Function | SmallTest | Level3)
249 {
250 std::recursive_mutex mutex;
251 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
252 dualDisplayFoldPolicy.UpdateForPhyScreenPropertyChange();
253 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
254 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
255 }
256
257 /**
258 * @tc.name: GetModeMatchStatus
259 * @tc.desc: GetModeMatchStatus
260 * @tc.type: FUNC
261 */
262 HWTEST_F(DualDisplayFoldPolicyTest, GetModeMatchStatus, Function | SmallTest | Level3)
263 {
264 std::recursive_mutex mutex;
265 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
266 FoldDisplayMode ret = dualDisplayFoldPolicy.GetModeMatchStatus();
267 ASSERT_EQ(ret, FoldDisplayMode::UNKNOWN);
268
269 dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::EXPAND;
270 ret = dualDisplayFoldPolicy.GetModeMatchStatus();
271 ASSERT_EQ(ret, FoldDisplayMode::MAIN);
272
273 dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::FOLDED;
274 ret = dualDisplayFoldPolicy.GetModeMatchStatus();
275 ASSERT_EQ(ret, FoldDisplayMode::SUB);
276
277 dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::HALF_FOLD;
278 ret = dualDisplayFoldPolicy.GetModeMatchStatus();
279 ASSERT_EQ(ret, FoldDisplayMode::MAIN);
280 }
281
282 /**
283 * @tc.name: ReportFoldDisplayModeChange
284 * @tc.desc: ReportFoldDisplayModeChange
285 * @tc.type: FUNC
286 */
287 HWTEST_F(DualDisplayFoldPolicyTest, ReportFoldDisplayModeChange, Function | SmallTest | Level3)
288 {
289 std::recursive_mutex mutex;
290 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
291 dualDisplayFoldPolicy.ReportFoldDisplayModeChange(FoldDisplayMode::FULL);
292 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
293 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
294 }
295
296 /**
297 * @tc.name: ReportFoldStatusChangeBegin
298 * @tc.desc: ReportFoldStatusChangeBegin
299 * @tc.type: FUNC
300 */
301 HWTEST_F(DualDisplayFoldPolicyTest, ReportFoldStatusChangeBegin, Function | SmallTest | Level3)
302 {
303 std::recursive_mutex mutex;
304 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
305 int32_t offScreen = 0;
306 int32_t onScreen = 1;
307 dualDisplayFoldPolicy.ReportFoldStatusChangeBegin(offScreen, onScreen);
308 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
309 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
310 }
311
312 /**
313 * @tc.name: ChangeScreenDisplayModeOnBootAnimation
314 * @tc.desc: ChangeScreenDisplayModeOnBootAnimation
315 * @tc.type: FUNC
316 */
317 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeOnBootAnimation, Function | SmallTest | Level3)
318 {
319 std::recursive_mutex mutex;
320 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
321 sptr<ScreenSession> screenSession = new ScreenSession();
322 ScreenId screenId = 0;
323 std::string threadName = "test";
324 dualDisplayFoldPolicy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>(threadName);
325 dualDisplayFoldPolicy.ChangeScreenDisplayModeOnBootAnimation(screenSession, screenId);
326 ASSERT_EQ(screenId, dualDisplayFoldPolicy.screenId_);
327 }
328
329 /**
330 * @tc.name: ChangeScreenDisplayModeOnBootAnimation2
331 * @tc.desc: ChangeScreenDisplayModeOnBootAnimation2
332 * @tc.type: FUNC
333 */
334 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeOnBootAnimation2, Function | SmallTest | Level3)
335 {
336 std::recursive_mutex mutex;
337 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
338 sptr<ScreenSession> screenSession = new ScreenSession();
339 ScreenId screenId = 5;
340 std::string threadName = "test";
341 dualDisplayFoldPolicy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>(threadName);
342 dualDisplayFoldPolicy.ChangeScreenDisplayModeOnBootAnimation(screenSession, screenId);
343 ASSERT_EQ(screenId, dualDisplayFoldPolicy.screenId_);
344 }
345
346 /**
347 * @tc.name: AddOrRemoveDisplayNodeToTree
348 * @tc.desc: AddOrRemoveDisplayNodeToTree
349 * @tc.type: FUNC
350 */
351 HWTEST_F(DualDisplayFoldPolicyTest, AddOrRemoveDisplayNodeToTree, Function | SmallTest | Level3)
352 {
353 std::recursive_mutex mutex;
354 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
355 sptr<ScreenSession> screenSession = new ScreenSession();
356 ScreenId screenId = 0;
357 int32_t command = 1;
358 dualDisplayFoldPolicy.AddOrRemoveDisplayNodeToTree(screenId, command);
359 FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
360 ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
361 }
362
363 /**
364 * @tc.name: SetdisplayModeChangeStatus01
365 * @tc.desc: SetdisplayModeChangeStatus
366 * @tc.type: FUNC
367 */
368 HWTEST_F(DualDisplayFoldPolicyTest, SetdisplayModeChangeStatus01, Function | SmallTest | Level3)
369 {
370 std::recursive_mutex mutex;
371 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
372 sptr<ScreenSession> screenSession = new ScreenSession();
373 bool status = true;
374 dualDisplayFoldPolicy.SetdisplayModeChangeStatus(status);
375 ASSERT_EQ(dualDisplayFoldPolicy.pengdingTask_, 3);
376 }
377
378 /**
379 * @tc.name: SetdisplayModeChangeStatus02
380 * @tc.desc: SetdisplayModeChangeStatus
381 * @tc.type: FUNC
382 */
383 HWTEST_F(DualDisplayFoldPolicyTest, SetdisplayModeChangeStatus02, Function | SmallTest | Level3)
384 {
385 std::recursive_mutex mutex;
386 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
387 sptr<ScreenSession> screenSession = new ScreenSession();
388 bool status = false;
389 dualDisplayFoldPolicy.SetdisplayModeChangeStatus(status);
390 ASSERT_NE(dualDisplayFoldPolicy.pengdingTask_, 3);
391 }
392
393 /**
394 * @tc.name: CheckDisplayMode01
395 * @tc.desc: CheckDisplayMode
396 * @tc.type: FUNC
397 */
398 HWTEST_F(DualDisplayFoldPolicyTest, CheckDisplayMode01, Function | SmallTest | Level3)
399 {
400 std::recursive_mutex mutex;
401 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
402 sptr<ScreenSession> screenSession = new ScreenSession();
403 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
404 auto ret = dualDisplayFoldPolicy.CheckDisplayMode(displayMode);
405 ASSERT_EQ(ret, false);
406 }
407
408 /**
409 * @tc.name: CheckDisplayMode02
410 * @tc.desc: CheckDisplayMode
411 * @tc.type: FUNC
412 */
413 HWTEST_F(DualDisplayFoldPolicyTest, CheckDisplayMode02, Function | SmallTest | Level3)
414 {
415 std::recursive_mutex mutex;
416 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
417 sptr<ScreenSession> screenSession = new ScreenSession();
418 FoldDisplayMode displayMode = FoldDisplayMode::COORDINATION;
419 auto ret = dualDisplayFoldPolicy.CheckDisplayMode(displayMode);
420 ASSERT_EQ(ret, false);
421 }
422
423 /**
424 * @tc.name: CheckDisplayMode03
425 * @tc.desc: CheckDisplayMode
426 * @tc.type: FUNC
427 */
428 HWTEST_F(DualDisplayFoldPolicyTest, CheckDisplayMode03, Function | SmallTest | Level3)
429 {
430 std::recursive_mutex mutex;
431 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
432 sptr<ScreenSession> screenSession = new ScreenSession();
433 FoldDisplayMode displayMode = FoldDisplayMode::FULL;
434 auto ret = dualDisplayFoldPolicy.CheckDisplayMode(displayMode);
435 ASSERT_EQ(ret, true);
436 }
437
438 /**
439 * @tc.name: ChangeScreenDisplayMode03
440 * @tc.desc: ChangeScreenDisplayMode
441 * @tc.type: FUNC
442 */
443 HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayMode03, Function | SmallTest | Level3)
444 {
445 std::recursive_mutex mutex;
446 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
447 sptr<ScreenSession> screenSession = new ScreenSession();
448 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::UNKNOWN);
449 ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
450
451 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::SUB);
452 ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
453
454 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::MAIN);
455 ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
456
457 dualDisplayFoldPolicy.ChangeScreenDisplayMode(FoldDisplayMode::COORDINATION);
458 ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
459 }
460 }
461 } // namespace Rosen
462 } // namespace OHOS