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 <hisysevent.h>
18 #include <parameters.h>
19
20 #include "fold_screen_controller/fold_screen_sensor_manager.h"
21 #include "fold_screen_state_internel.h"
22 #include "window_manager_hilog.h"
23 #include "screen_session_manager.h"
24 #include "scene_board_judgement.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31 namespace {
32 constexpr uint32_t SLEEP_TIME_US = 100000;
33 constexpr float ANGLE_MIN_VAL = 0.0F;
34 }
35
36 class FoldScreenSensorManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void FoldScreenSensorManagerTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void FoldScreenSensorManagerTest::TearDownTestCase()
49 {
50 }
51
SetUp()52 void FoldScreenSensorManagerTest::SetUp()
53 {
54 }
55
TearDown()56 void FoldScreenSensorManagerTest::TearDown()
57 {
58 usleep(SLEEP_TIME_US);
59 }
60
61 namespace {
62 /**
63 * @tc.name: RegisterPostureCallback
64 * @tc.desc: test function : RegisterPostureCallback
65 * @tc.type: FUNC
66 */
67 HWTEST_F(FoldScreenSensorManagerTest, RegisterPostureCallback, TestSize.Level1)
68 {
69 FoldScreenSensorManager mgr = FoldScreenSensorManager();
70 mgr.RegisterPostureCallback();
71 ASSERT_NE(mgr.postureUser.callback, nullptr);
72 }
73
74 /**
75 * @tc.name: UnRegisterPostureCallback
76 * @tc.desc: test function : UnRegisterPostureCallback
77 * @tc.type: FUNC
78 */
79 HWTEST_F(FoldScreenSensorManagerTest, UnRegisterPostureCallback, TestSize.Level1)
80 {
81 FoldScreenSensorManager mgr = FoldScreenSensorManager();
82 mgr.UnRegisterPostureCallback();
83 ASSERT_EQ(mgr.postureUser.callback, nullptr);
84 }
85
86 /**
87 * @tc.name: RegisterHallCallback
88 * @tc.desc: test function : RegisterHallCallback
89 * @tc.type: FUNC
90 */
91 HWTEST_F(FoldScreenSensorManagerTest, RegisterHallCallback, TestSize.Level1)
92 {
93 FoldScreenSensorManager mgr = FoldScreenSensorManager();
94 mgr.RegisterHallCallback();
95 ASSERT_NE(mgr.hallUser.callback, nullptr);
96 }
97
98 /**
99 * @tc.name: UnRegisterHallCallback
100 * @tc.desc: test function : UnRegisterHallCallback
101 * @tc.type: FUNC
102 */
103 HWTEST_F(FoldScreenSensorManagerTest, UnRegisterHallCallback, TestSize.Level1)
104 {
105 FoldScreenSensorManager mgr = FoldScreenSensorManager();
106 mgr.UnRegisterHallCallback();
107 ASSERT_EQ(mgr.hallUser.callback, nullptr);
108 }
109
110 /**
111 * @tc.name: HandlePostureData
112 * @tc.desc: test function : HandlePostureData
113 * @tc.type: FUNC
114 */
115 HWTEST_F(FoldScreenSensorManagerTest, HandlePostureData, TestSize.Level1)
116 {
117 FoldScreenSensorManager mgr = FoldScreenSensorManager();
118 mgr.HandlePostureData(nullptr);
119 EXPECT_EQ(mgr.globalAngle, -1.0F);
120
121 SensorEvent event;
122 PostureData postureData;
123 postureData.angle = 45.0F;
124 mgr.HandlePostureData(&event);
125 EXPECT_EQ(mgr.globalAngle, -1.0F);
126
127 event.data = reinterpret_cast<uint8_t*>(&postureData);
128 event.dataLen = 0;
129 mgr.HandlePostureData(&event);
130 EXPECT_EQ(mgr.globalAngle, -1.0F);
131
132 event.dataLen = sizeof(PostureData);
133 mgr.HandlePostureData(&event);
134 EXPECT_EQ(mgr.globalAngle, 45.0F);
135 }
136
137 /**
138 * @tc.name: NotifyFoldAngleChanged
139 * @tc.desc: test function : NotifyFoldAngleChanged
140 * @tc.type: FUNC
141 */
142 HWTEST_F(FoldScreenSensorManagerTest, NotifyFoldAngleChanged, TestSize.Level1)
143 {
144 FoldScreenSensorManager mgr = FoldScreenSensorManager();
145 float foldAngle = 0.0F;
146 mgr.NotifyFoldAngleChanged(foldAngle);
147 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
148
149 foldAngle = 30.0F;
150 mgr.NotifyFoldAngleChanged(foldAngle);
151 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
152 usleep(SLEEP_TIME_US);
153 }
154
155 /**
156 * @tc.name: HandleHallData
157 * @tc.desc: test function : HandleHallData
158 * @tc.type: FUNC
159 */
160 HWTEST_F(FoldScreenSensorManagerTest, HandleHallData, TestSize.Level1)
161 {
162 FoldScreenSensorManager mgr = FoldScreenSensorManager();
163 mgr.HandleHallData(nullptr);
164 EXPECT_EQ(mgr.globalHall, USHRT_MAX);
165
166 SensorEvent event;
167 mgr.HandleHallData(&event);
168 EXPECT_EQ(mgr.globalHall, USHRT_MAX);
169
170 FoldScreenSensorManager::ExtHallData hallData;
171 event.data = reinterpret_cast<uint8_t*>(&hallData);
172 mgr.HandleHallData(&event);
173 EXPECT_EQ(mgr.globalHall, USHRT_MAX);
174
175 event.dataLen = 0;
176 mgr.HandleHallData(&event);
177 EXPECT_EQ(mgr.globalHall, USHRT_MAX);
178
179 event.dataLen = sizeof(FoldScreenSensorManager::ExtHallData);
180 mgr.HandleHallData(&event);
181 EXPECT_EQ(mgr.globalHall, USHRT_MAX);
182
183 hallData.hall = 10;
184 mgr.HandleHallData(&event);
185 EXPECT_EQ(mgr.globalHall, 65535);
186 }
187
188 /**
189 * @tc.name: TriggerDisplaySwitch
190 * @tc.desc: test function : TriggerDisplaySwitch
191 * @tc.type: FUNC
192 */
193 HWTEST_F(FoldScreenSensorManagerTest, TriggerDisplaySwitch, TestSize.Level1)
194 {
195 FoldScreenSensorManager mgr = FoldScreenSensorManager();
196 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
197 mgr.registerPosture_ = false;
198 mgr.TriggerDisplaySwitch();
199 EXPECT_EQ(mgr.globalAngle, ANGLE_MIN_VAL);
200
201 mgr.registerPosture_ = true;
202 mgr.TriggerDisplaySwitch();
203 if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
204 EXPECT_EQ(mgr.globalAngle, 85);
205 } else if (SceneBoardJudgement::IsSceneBoardEnabled() || FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
206 EXPECT_EQ(mgr.globalAngle, 25);
207 } else {
208 EXPECT_EQ(mgr.globalAngle, 25);
209 }
210 usleep(SLEEP_TIME_US);
211 }
212
213 /**
214 * @tc.name: GetGlobalAngle
215 * @tc.desc: test function : GetGlobalAngle
216 * @tc.type: FUNC
217 */
218 HWTEST_F(FoldScreenSensorManagerTest, GetGlobalAngle, TestSize.Level1)
219 {
220 FoldScreenSensorManager mgr = FoldScreenSensorManager();
221 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
222 mgr.registerPosture_ = false;
223 float angle = 150.0F;
224 mgr.SetGlobalAngle(angle);
225 ASSERT_NO_FATAL_FAILURE({mgr.GetGlobalAngle();});
226 EXPECT_EQ(mgr.GetGlobalAngle(), angle);
227 }
228
229 /**
230 * @tc.name: SetGlobalAngle
231 * @tc.desc: test function : SetGlobalAngle
232 * @tc.type: FUNC
233 */
234 HWTEST_F(FoldScreenSensorManagerTest, SetGlobalAngle, TestSize.Level1)
235 {
236 FoldScreenSensorManager mgr = FoldScreenSensorManager();
237 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
238 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(-10.0f);});
239 EXPECT_NE(mgr.GetGlobalAngle(), -10.0f);
240 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(190.0f);});
241 EXPECT_NE(mgr.GetGlobalAngle(), 190.0f);
242 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(180.0f);});
243 EXPECT_EQ(mgr.GetGlobalAngle(), 180.0f);
244 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(150.0f);});
245 EXPECT_EQ(mgr.GetGlobalAngle(), 150.0f);
246 }
247
248 /**
249 * @tc.name: SetGlobalAngleWhenParamInValid
250 * @tc.desc: test function : SetGlobalAngle
251 * @tc.type: FUNC
252 */
253 HWTEST_F(FoldScreenSensorManagerTest, SetGlobalAngleWhenParamInValid, TestSize.Level1)
254 {
255 FoldScreenSensorManager mgr = FoldScreenSensorManager();
256 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
257 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(150.0f);});
258 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(-10.0f);});
259 EXPECT_NE(mgr.GetGlobalAngle(), -10.0f);
260 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalAngle(190.0f);});
261 EXPECT_NE(mgr.GetGlobalAngle(), 190.0f);
262 }
263
264 /**
265 * @tc.name: GetGlobalHall
266 * @tc.desc: test function : GetGlobalHall
267 * @tc.type: FUNC
268 */
269 HWTEST_F(FoldScreenSensorManagerTest, GetGlobalHall, TestSize.Level1)
270 {
271 FoldScreenSensorManager mgr = FoldScreenSensorManager();
272 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
273 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(0);});
274 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(1);});
275 ASSERT_NO_FATAL_FAILURE({mgr.GetGlobalHall();});
276 EXPECT_EQ(mgr.GetGlobalHall(), 1);
277 }
278
279 /**
280 * @tc.name: SetGlobalHall
281 * @tc.desc: test function : SetGlobalHall
282 * @tc.type: FUNC
283 */
284 HWTEST_F(FoldScreenSensorManagerTest, SetGlobalHall, TestSize.Level1)
285 {
286 FoldScreenSensorManager mgr = FoldScreenSensorManager();
287 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
288 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(0);});
289 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(1);});
290 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(USHRT_MAX);});
291 ASSERT_NO_FATAL_FAILURE({mgr.GetGlobalHall();});
292 EXPECT_EQ(mgr.GetGlobalHall(), 1);
293 }
294
295 /**
296 * @tc.name: SetGlobalHallWhenParamInValid
297 * @tc.desc: test function : SetGlobalHall
298 * @tc.type: FUNC
299 */
300 HWTEST_F(FoldScreenSensorManagerTest, SetGlobalHallWhenParamInValid, TestSize.Level1)
301 {
302 FoldScreenSensorManager mgr = FoldScreenSensorManager();
303 mgr.SetSensorFoldStateManager(new SensorFoldStateManager());
304 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(1);});
305 ASSERT_NO_FATAL_FAILURE({mgr.SetGlobalHall(USHRT_MAX);});
306 ASSERT_NO_FATAL_FAILURE({mgr.GetGlobalHall();});
307 EXPECT_NE(mgr.GetGlobalHall(), USHRT_MAX);
308 }
309 }
310 } // namespace Rosen
311 } // namespace OHOS