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 "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: SendSensorResult
91      * @tc.desc: SendSensorResult
92      * @tc.type: FUNC
93      */
94     HWTEST_F(DualDisplayFoldPolicyTest, SendSensorResult, Function | SmallTest | Level3)
95     {
96         std::recursive_mutex mutex;
97         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
98         dualDisplayFoldPolicy.SendSensorResult(FoldStatus::UNKNOWN);
99         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
100         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
101     }
102 
103     /**
104      * @tc.name: SetOnBootAnimation
105      * @tc.desc: SetOnBootAnimation
106      * @tc.type: FUNC
107      */
108     HWTEST_F(DualDisplayFoldPolicyTest, SetOnBootAnimation, Function | SmallTest | Level3)
109     {
110         std::recursive_mutex mutex;
111         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
112         dualDisplayFoldPolicy.SetOnBootAnimation(true);
113         ASSERT_TRUE(dualDisplayFoldPolicy.onBootAnimation_);
114 
115         dualDisplayFoldPolicy.SetOnBootAnimation(false);
116         ASSERT_FALSE(dualDisplayFoldPolicy.onBootAnimation_);
117     }
118 
119     /**
120      * @tc.name: GetCurrentFoldCreaseRegion
121      * @tc.desc: GetCurrentFoldCreaseRegion
122      * @tc.type: FUNC
123      */
124     HWTEST_F(DualDisplayFoldPolicyTest, GetCurrentFoldCreaseRegion, Function | SmallTest | Level3)
125     {
126         std::recursive_mutex mutex;
127         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
128         sptr<FoldCreaseRegion> res = dualDisplayFoldPolicy.GetCurrentFoldCreaseRegion();
129         ASSERT_EQ(res, dualDisplayFoldPolicy.currentFoldCreaseRegion_);
130     }
131 
132     /**
133      * @tc.name: LockDisplayStatus
134      * @tc.desc: LockDisplayStatus
135      * @tc.type: FUNC
136      */
137     HWTEST_F(DualDisplayFoldPolicyTest, LockDisplayStatus, Function | SmallTest | Level3)
138     {
139         std::recursive_mutex mutex;
140         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
141         bool locked = false;
142         dualDisplayFoldPolicy.LockDisplayStatus(locked);
143         ASSERT_EQ(locked, dualDisplayFoldPolicy.lockDisplayStatus_);
144     }
145 
146     /**
147      * @tc.name: RecoverWhenBootAnimationExit0
148      * @tc.desc: RecoverWhenBootAnimationExit0
149      * @tc.type: FUNC
150      */
151     HWTEST_F(DualDisplayFoldPolicyTest, RecoverWhenBootAnimationExit0, Function | SmallTest | Level3)
152     {
153         std::recursive_mutex mutex;
154         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
155         dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::UNKNOWN;
156         dualDisplayFoldPolicy.currentDisplayMode_ = FoldDisplayMode::MAIN;
157         dualDisplayFoldPolicy.RecoverWhenBootAnimationExit();
158         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
159         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
160     }
161 
162     /**
163      * @tc.name: UpdateForPhyScreenPropertyChange0
164      * @tc.desc: UpdateForPhyScreenPropertyChange0
165      * @tc.type: FUNC
166      */
167     HWTEST_F(DualDisplayFoldPolicyTest, UpdateForPhyScreenPropertyChange0, Function | SmallTest | Level3)
168     {
169         std::recursive_mutex mutex;
170         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
171         dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::UNKNOWN;
172         dualDisplayFoldPolicy.currentDisplayMode_ = FoldDisplayMode::MAIN;
173         dualDisplayFoldPolicy.UpdateForPhyScreenPropertyChange();
174         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
175         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
176     }
177 
178     /**
179      * @tc.name: ChangeScreenDisplayModeInner01
180      * @tc.desc: ChangeScreenDisplayModeInner01
181      * @tc.type: FUNC
182      */
183     HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeInner01, Function | SmallTest | Level3)
184     {
185         std::recursive_mutex mutex;
186         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
187         dualDisplayFoldPolicy.onBootAnimation_ = true;
188         sptr<ScreenSession> screenSession = new ScreenSession();
189         ScreenId offScreenId = 0;
190         ScreenId onScreenId = 5;
191         dualDisplayFoldPolicy.ChangeScreenDisplayModeInner(screenSession, offScreenId, onScreenId);
192         int res = 0;
193         ASSERT_EQ(res, 0);
194     }
195 
196     /**
197      * @tc.name: ChangeScreenDisplayModeToCoordination
198      * @tc.desc: ChangeScreenDisplayModeToCoordination
199      * @tc.type: FUNC
200      */
201     HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeToCoordination, Function | SmallTest | Level3)
202     {
203         if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
204             std::recursive_mutex mutex;
205             std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = std::make_shared<TaskScheduler>(
206             DUAL_DISPLAY_FOLD_POLICY_TEST);
207             sptr<DualDisplayFoldPolicy> dualDisplayFoldPolicy = new DualDisplayFoldPolicy(
208                 mutex, screenPowerTaskScheduler);
209             dualDisplayFoldPolicy->ChangeScreenDisplayModeToCoordination();
210             ASSERT_FALSE(ssm_.keyguardDrawnDone_);
211         }
212     }
213 
214     /**
215      * @tc.name: RecoverWhenBootAnimationExit
216      * @tc.desc: RecoverWhenBootAnimationExit
217      * @tc.type: FUNC
218      */
219     HWTEST_F(DualDisplayFoldPolicyTest, RecoverWhenBootAnimationExit, Function | SmallTest | Level3)
220     {
221         std::recursive_mutex mutex;
222         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
223         dualDisplayFoldPolicy.RecoverWhenBootAnimationExit();
224         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
225         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
226     }
227 
228     /**
229      * @tc.name: UpdateForPhyScreenPropertyChange
230      * @tc.desc: UpdateForPhyScreenPropertyChange
231      * @tc.type: FUNC
232      */
233     HWTEST_F(DualDisplayFoldPolicyTest, UpdateForPhyScreenPropertyChange, Function | SmallTest | Level3)
234     {
235         std::recursive_mutex mutex;
236         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
237         dualDisplayFoldPolicy.UpdateForPhyScreenPropertyChange();
238         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
239         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
240     }
241 
242     /**
243      * @tc.name: GetModeMatchStatus
244      * @tc.desc: GetModeMatchStatus
245      * @tc.type: FUNC
246      */
247     HWTEST_F(DualDisplayFoldPolicyTest, GetModeMatchStatus, Function | SmallTest | Level3)
248     {
249         std::recursive_mutex mutex;
250         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
251         FoldDisplayMode ret = dualDisplayFoldPolicy.GetModeMatchStatus();
252         ASSERT_EQ(ret, FoldDisplayMode::UNKNOWN);
253 
254         dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::EXPAND;
255         ret = dualDisplayFoldPolicy.GetModeMatchStatus();
256         ASSERT_EQ(ret, FoldDisplayMode::MAIN);
257 
258         dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::FOLDED;
259         ret = dualDisplayFoldPolicy.GetModeMatchStatus();
260         ASSERT_EQ(ret, FoldDisplayMode::SUB);
261 
262         dualDisplayFoldPolicy.currentFoldStatus_ = FoldStatus::HALF_FOLD;
263         ret = dualDisplayFoldPolicy.GetModeMatchStatus();
264         ASSERT_EQ(ret, FoldDisplayMode::MAIN);
265     }
266 
267     /**
268      * @tc.name: ReportFoldDisplayModeChange
269      * @tc.desc: ReportFoldDisplayModeChange
270      * @tc.type: FUNC
271      */
272     HWTEST_F(DualDisplayFoldPolicyTest, ReportFoldDisplayModeChange, Function | SmallTest | Level3)
273     {
274         std::recursive_mutex mutex;
275         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
276         dualDisplayFoldPolicy.ReportFoldDisplayModeChange(FoldDisplayMode::FULL);
277         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
278         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
279     }
280 
281     /**
282      * @tc.name: ReportFoldStatusChangeBegin
283      * @tc.desc: ReportFoldStatusChangeBegin
284      * @tc.type: FUNC
285      */
286     HWTEST_F(DualDisplayFoldPolicyTest, ReportFoldStatusChangeBegin, Function | SmallTest | Level3)
287     {
288         std::recursive_mutex mutex;
289         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
290         int32_t offScreen = 0;
291         int32_t onScreen = 1;
292         dualDisplayFoldPolicy.ReportFoldStatusChangeBegin(offScreen, onScreen);
293         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
294         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
295     }
296 
297     /**
298      * @tc.name: ChangeScreenDisplayModeOnBootAnimation
299      * @tc.desc: ChangeScreenDisplayModeOnBootAnimation
300      * @tc.type: FUNC
301      */
302     HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeOnBootAnimation, Function | SmallTest | Level3)
303     {
304         std::recursive_mutex mutex;
305         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
306         sptr<ScreenSession> screenSession = new ScreenSession();
307         ScreenId screenId = 0;
308         std::string threadName = "test";
309         dualDisplayFoldPolicy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>(threadName);
310         dualDisplayFoldPolicy.ChangeScreenDisplayModeOnBootAnimation(screenSession, screenId);
311         ASSERT_EQ(screenId, dualDisplayFoldPolicy.screenId_);
312     }
313 
314     /**
315      * @tc.name: ChangeScreenDisplayModeOnBootAnimation2
316      * @tc.desc: ChangeScreenDisplayModeOnBootAnimation2
317      * @tc.type: FUNC
318      */
319     HWTEST_F(DualDisplayFoldPolicyTest, ChangeScreenDisplayModeOnBootAnimation2, Function | SmallTest | Level3)
320     {
321         std::recursive_mutex mutex;
322         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
323         sptr<ScreenSession> screenSession = new ScreenSession();
324         ScreenId screenId = 5;
325         std::string threadName = "test";
326         dualDisplayFoldPolicy.screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>(threadName);
327         dualDisplayFoldPolicy.ChangeScreenDisplayModeOnBootAnimation(screenSession, screenId);
328         ASSERT_EQ(screenId, dualDisplayFoldPolicy.screenId_);
329     }
330 
331     /**
332      * @tc.name: AddOrRemoveDisplayNodeToTree
333      * @tc.desc: AddOrRemoveDisplayNodeToTree
334      * @tc.type: FUNC
335      */
336     HWTEST_F(DualDisplayFoldPolicyTest, AddOrRemoveDisplayNodeToTree, Function | SmallTest | Level3)
337     {
338         std::recursive_mutex mutex;
339         DualDisplayFoldPolicy dualDisplayFoldPolicy(mutex, std::shared_ptr<TaskScheduler>());
340         sptr<ScreenSession> screenSession = new ScreenSession();
341         ScreenId screenId = 0;
342         int32_t command = 1;
343         dualDisplayFoldPolicy.AddOrRemoveDisplayNodeToTree(screenId, command);
344         FoldDisplayMode mode = ssm_.GetFoldDisplayMode();
345         ASSERT_EQ(mode, ssm_.GetFoldDisplayMode());
346     }
347 }
348 } // namespace Rosen
349 } // namespace OHOS