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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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 EXPECT_TRUE(ssm_.keyguardDrawnDone_);
240 }
241 }
242
243 /**
244 * @tc.name: UpdateForPhyScreenPropertyChange
245 * @tc.desc: UpdateForPhyScreenPropertyChange
246 * @tc.type: FUNC
247 */
248 HWTEST_F(DualDisplayFoldPolicyTest, UpdateForPhyScreenPropertyChange, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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 /**
462 * @tc.name: TriggerSensorInSubWhenSessionNull
463 * @tc.desc: TriggerSensorInSub
464 * @tc.type: FUNC
465 */
466 HWTEST_F(DualDisplayFoldPolicyTest, TriggerSensorInSubWhenSessionNull, TestSize.Level1)
467 {
468 std::recursive_mutex mutex;
469 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
470 sptr<ScreenSession> screenSession = new ScreenSession();
471 screenSession->SetScreenId(0);
472 dualDisplayFoldPolicy.TriggerSensorInSub(screenSession);
473 screenSession->SetScreenId(5);
474 dualDisplayFoldPolicy.TriggerSensorInSub(screenSession);
475 EXPECT_EQ(screenSession->GetScreenId(), 5);
476 }
477
478 /**
479 * @tc.name: TriggerSensorInSubWhenSessionNotNull
480 * @tc.desc: TriggerSensorInSub
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DualDisplayFoldPolicyTest, TriggerSensorInSubWhenSessionNotNull, TestSize.Level1)
484 {
485 std::recursive_mutex mutex;
486 auto screenSessionMapMainIter = ScreenSessionManager::GetInstance().screenSessionMap_.find(0);
487 DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
488 sptr<ScreenSession> screenSession = new ScreenSession();
489 screenSession->SetScreenId(5);
490 ScreenSessionConfig config;
491 sptr<ScreenSession> screenSessionMain =
492 new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_REAL);
493 screenSessionMain->SensorRotationChange(0.0F);
494 ScreenSessionManager::GetInstance().screenSessionMap_[0] = screenSessionMain;
495 dualDisplayFoldPolicy.TriggerSensorInSub(screenSession);
496 screenSessionMain->SensorRotationChange(180.0F);
497 ScreenSessionManager::GetInstance().screenSessionMap_[0] = screenSessionMain;
498 dualDisplayFoldPolicy.TriggerSensorInSub(screenSession);
499 EXPECT_EQ(screenSessionMain->GetSensorRotation(), 180.0F);
500 if (screenSessionMapMainIter != ScreenSessionManager::GetInstance().screenSessionMap_.end()) {
501 ScreenSessionManager::GetInstance().screenSessionMap_[0] = screenSessionMapMainIter->second;
502 }
503 }
504 }
505 } // namespace Rosen
506 } // namespace OHOS