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
19 #include "fold_screen_controller/super_fold_sensor_manager.h"
20 #include "fold_screen_state_internel.h"
21 #include "window_manager_hilog.h"
22 #include "screen_session_manager.h"
23 #include "scene_board_judgement.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr uint32_t SLEEP_TIME_US = 100000;
32 constexpr uint16_t VALID_HALL_STATUS = 0;
33 constexpr uint16_t HALL_HAVE_KEYBOARD_THRESHOLD = 0B0100;
34 }
35
36 class SuperFoldSensorManagerTest : 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 SuperFoldSensorManagerTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void SuperFoldSensorManagerTest::TearDownTestCase()
49 {
50 }
51
SetUp()52 void SuperFoldSensorManagerTest::SetUp()
53 {
54 }
55
TearDown()56 void SuperFoldSensorManagerTest::TearDown()
57 {
58 usleep(SLEEP_TIME_US);
59 }
60
61 namespace {
62 /**
63 * @tc.name: RegisterPostureCallback01
64 * @tc.desc: test function : RegisterPostureCallback
65 * @tc.type: FUNC
66 */
67 HWTEST_F(SuperFoldSensorManagerTest, RegisterPostureCallback01, Function | SmallTest | Level3)
68 {
69 SuperFoldSensorManager mgr = SuperFoldSensorManager();
70 mgr.RegisterPostureCallback();
71 ASSERT_NE(mgr.postureUser.callback, nullptr);
72 }
73
74 /**
75 * @tc.name: RegisterPostureCallback01
76 * @tc.desc: test function : RegisterPostureCallback
77 * @tc.type: FUNC
78 */
79 HWTEST_F(SuperFoldSensorManagerTest, RegisterPostureCallback02, Function | SmallTest | Level3)
80 {
81 SuperFoldSensorManager mgr = SuperFoldSensorManager();
82 mgr.RegisterPostureCallback();
83 void (*func)(SensorEvent *event) = nullptr;
84 ASSERT_NE(mgr.postureUser.callback, func);
85 }
86
87 /**
88 * @tc.name: UnregisterPostureCallback01
89 * @tc.desc: test function : UnregisterPostureCallback
90 * @tc.type: FUNC
91 */
92 HWTEST_F(SuperFoldSensorManagerTest, UnregisterPostureCallback01, Function | SmallTest | Level3)
93 {
94 SuperFoldSensorManager mgr = SuperFoldSensorManager();
95 mgr.UnregisterPostureCallback();
96 ASSERT_EQ(mgr.postureUser.callback, nullptr);
97 }
98
99 /**
100 * @tc.name: UnregisterPostureCallback02
101 * @tc.desc: test function : UnregisterPostureCallback
102 * @tc.type: FUNC
103 */
104 HWTEST_F(SuperFoldSensorManagerTest, UnregisterPostureCallback02, Function | SmallTest | Level3)
105 {
106 SuperFoldSensorManager mgr = SuperFoldSensorManager();
107 mgr.UnregisterPostureCallback();
108 void (*func)(SensorEvent *event) = nullptr;
109 ASSERT_EQ(mgr.postureUser.callback, func);
110 }
111
112 /**
113 * @tc.name: RegisterHallCallback01
114 * @tc.desc: test function : RegisterHallCallback
115 * @tc.type: FUNC
116 */
117 HWTEST_F(SuperFoldSensorManagerTest, RegisterHallCallback01, Function | SmallTest | Level3)
118 {
119 SuperFoldSensorManager mgr = SuperFoldSensorManager();
120 mgr.RegisterHallCallback();
121 ASSERT_NE(mgr.hallUser.callback, nullptr);
122 }
123
124 /**
125 * @tc.name: RegisterHallCallback02
126 * @tc.desc: test function : RegisterHallCallback
127 * @tc.type: FUNC
128 */
129 HWTEST_F(SuperFoldSensorManagerTest, RegisterHallCallback02, Function | SmallTest | Level3)
130 {
131 SuperFoldSensorManager mgr = SuperFoldSensorManager();
132 mgr.RegisterHallCallback();
133 void (*func)(SensorEvent *event) = nullptr;
134 ASSERT_NE(mgr.hallUser.callback, func);
135 }
136
137 /**
138 * @tc.name: UnregisterHallCallback01
139 * @tc.desc: test function : UnregisterHallCallback
140 * @tc.type: FUNC
141 */
142 HWTEST_F(SuperFoldSensorManagerTest, UnregisterHallCallback01, Function | SmallTest | Level3)
143 {
144 SuperFoldSensorManager mgr = SuperFoldSensorManager();
145 mgr.UnregisterHallCallback();
146 ASSERT_EQ(mgr.hallUser.callback, nullptr);
147 }
148
149 /**
150 * @tc.name: UnregisterHallCallback02
151 * @tc.desc: test function : UnregisterHallCallback
152 * @tc.type: FUNC
153 */
154 HWTEST_F(SuperFoldSensorManagerTest, UnregisterHallCallback02, Function | SmallTest | Level3)
155 {
156 SuperFoldSensorManager mgr = SuperFoldSensorManager();
157 mgr.UnregisterHallCallback();
158 void (*func)(SensorEvent *event) = nullptr;
159 ASSERT_EQ(mgr.hallUser.callback, func);
160 }
161
162 /**
163 * @tc.name: HandlePostureData01
164 * @tc.desc: test function : HandlePostureData
165 * @tc.type: FUNC
166 */
167 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData01, Function | SmallTest | Level3)
168 {
169 SuperFoldSensorManager mgr = SuperFoldSensorManager();
170 mgr.HandlePostureData(nullptr);
171 ASSERT_EQ(mgr.curAngle_, 170.0F);
172 }
173
174 /**
175 * @tc.name: HandlePostureData02
176 * @tc.desc: test function : HandlePostureData
177 * @tc.type: FUNC
178 */
179 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData02, Function | SmallTest | Level3)
180 {
181 SuperFoldSensorManager mgr = SuperFoldSensorManager();
182 mgr.HandlePostureData(nullptr);
183 EXPECT_EQ(mgr.curAngle_, 170.0F);
184
185 SensorEvent event;
186 PostureData postureData;
187 postureData.angle = 45.0F;
188 mgr.HandlePostureData(&event);
189 ASSERT_EQ(mgr.curAngle_, 170.0F);
190 }
191
192 /**
193 * @tc.name: HandlePostureData03
194 * @tc.desc: test function : HandlePostureData
195 * @tc.type: FUNC
196 */
197 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData03, Function | SmallTest | Level3)
198 {
199 SuperFoldSensorManager mgr = SuperFoldSensorManager();
200 mgr.HandlePostureData(nullptr);
201 ASSERT_EQ(mgr.curAngle_, 170.0F);
202
203 SensorEvent event;
204 PostureData postureData;
205 postureData.angle = 45.0F;
206 mgr.HandlePostureData(&event);
207 EXPECT_EQ(mgr.curAngle_, 170.0F);
208
209 event.data = reinterpret_cast<uint8_t*>(&postureData);
210 event.dataLen = 0;
211 mgr.HandlePostureData(&event);
212 ASSERT_EQ(mgr.curAngle_, 170.0F);
213 }
214
215 /**
216 * @tc.name: HandlePostureData04
217 * @tc.desc: test function : HandlePostureData
218 * @tc.type: FUNC
219 */
220 HWTEST_F(SuperFoldSensorManagerTest, HandlePostureData04, Function | SmallTest | Level3)
221 {
222 SuperFoldSensorManager mgr = SuperFoldSensorManager();
223 mgr.HandlePostureData(nullptr);
224 ASSERT_EQ(mgr.curAngle_, 170.0F);
225
226 SensorEvent event;
227 PostureData postureData;
228 postureData.angle = 45.0F;
229 mgr.HandlePostureData(&event);
230 EXPECT_EQ(mgr.curAngle_, 170.0F);
231
232 event.data = reinterpret_cast<uint8_t*>(&postureData);
233 event.dataLen = 0;
234 mgr.HandlePostureData(&event);
235 EXPECT_EQ(mgr.curAngle_, 170.0F);
236
237 event.dataLen = sizeof(PostureData);
238 mgr.HandlePostureData(&event);
239 ASSERT_EQ(mgr.curAngle_, 45.0F);
240 }
241
242 /**
243 * @tc.name: NotifyFoldAngleChanged01
244 * @tc.desc: test function : NotifyFoldAngleChanged
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged01, Function | SmallTest | Level3)
248 {
249 SuperFoldSensorManager mgr = SuperFoldSensorManager();
250 float foldAngle = 0.0F;
251 mgr.NotifyFoldAngleChanged(foldAngle);
252 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
253 usleep(SLEEP_TIME_US);
254 }
255
256 /**
257 * @tc.name: NotifyFoldAngleChanged02
258 * @tc.desc: test function : NotifyFoldAngleChanged
259 * @tc.type: FUNC
260 */
261 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged02, Function | SmallTest | Level3)
262 {
263 SuperFoldSensorManager mgr = SuperFoldSensorManager();
264 float foldAngle = 30.0F;
265 mgr.NotifyFoldAngleChanged(foldAngle);
266 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
267 usleep(SLEEP_TIME_US);
268 }
269
270 /**
271 * @tc.name: NotifyFoldAngleChanged03
272 * @tc.desc: test function : NotifyFoldAngleChanged
273 * @tc.type: FUNC
274 */
275 HWTEST_F(SuperFoldSensorManagerTest, NotifyFoldAngleChanged03, Function | SmallTest | Level3)
276 {
277 SuperFoldSensorManager mgr = SuperFoldSensorManager();
278 float foldAngle = 165.0F;
279 mgr.NotifyFoldAngleChanged(foldAngle);
280 EXPECT_TRUE(ScreenSessionManager::GetInstance().lastFoldAngles_.empty());
281 usleep(SLEEP_TIME_US);
282 }
283
284 /**
285 * @tc.name: HandleHallData01
286 * @tc.desc: test function : HandleHallData
287 * @tc.type: FUNC
288 */
289 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData01, Function | SmallTest | Level3)
290 {
291 SuperFoldSensorManager mgr = SuperFoldSensorManager();
292 mgr.HandleHallData(nullptr);
293 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
294 }
295
296 /**
297 * @tc.name: HandleHallData02
298 * @tc.desc: test function : HandleHallData
299 * @tc.type: FUNC
300 */
301 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData02, Function | SmallTest | Level3)
302 {
303 SuperFoldSensorManager mgr = SuperFoldSensorManager();
304 mgr.HandleHallData(nullptr);
305 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
306
307 SensorEvent event;
308 mgr.HandleHallData(&event);
309 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
310 }
311
312 /**
313 * @tc.name: HandleHallData03
314 * @tc.desc: test function : HandleHallData
315 * @tc.type: FUNC
316 */
317 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData03, Function | SmallTest | Level3)
318 {
319 SuperFoldSensorManager mgr = SuperFoldSensorManager();
320 mgr.HandleHallData(nullptr);
321 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
322
323 SensorEvent event;
324 mgr.HandleHallData(&event);
325 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
326
327 HallData hallData;
328 event.data = reinterpret_cast<uint8_t*>(&hallData);
329 mgr.HandleHallData(&event);
330 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
331 }
332
333 /**
334 * @tc.name: HandleHallData04
335 * @tc.desc: test function : HandleHallData
336 * @tc.type: FUNC
337 */
338 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData04, Function | SmallTest | Level3)
339 {
340 SuperFoldSensorManager mgr = SuperFoldSensorManager();
341 mgr.HandleHallData(nullptr);
342 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
343
344 SensorEvent event;
345 mgr.HandleHallData(&event);
346 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
347
348 HallData hallData;
349 event.data = reinterpret_cast<uint8_t*>(&hallData);
350 mgr.HandleHallData(&event);
351 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
352
353 event.dataLen = 0;
354 mgr.HandleHallData(&event);
355 ASSERT_EQ(mgr.curHall_, USHRT_MAX);
356 }
357
358 /**
359 * @tc.name: HandleHallData05
360 * @tc.desc: test function : HandleHallData
361 * @tc.type: FUNC
362 */
363 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData05, Function | SmallTest | Level3)
364 {
365 SuperFoldSensorManager mgr = SuperFoldSensorManager();
366 mgr.HandleHallData(nullptr);
367 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
368
369 SensorEvent event;
370 mgr.HandleHallData(&event);
371 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
372
373 HallData hallData;
374 event.data = reinterpret_cast<uint8_t*>(&hallData);
375 mgr.HandleHallData(&event);
376 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
377
378 event.dataLen = 0;
379 mgr.HandleHallData(&event);
380 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
381
382 event.dataLen = sizeof(HallData);
383 mgr.HandleHallData(&event);
384 ASSERT_EQ(mgr.curHall_, VALID_HALL_STATUS);
385 }
386
387 /**
388 * @tc.name: HandleHallData06
389 * @tc.desc: test function : HandleHallData
390 * @tc.type: FUNC
391 */
392 HWTEST_F(SuperFoldSensorManagerTest, HandleHallData06, Function | SmallTest | Level3)
393 {
394 SuperFoldSensorManager mgr = SuperFoldSensorManager();
395 mgr.HandleHallData(nullptr);
396 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
397
398 SensorEvent event;
399 mgr.HandleHallData(&event);
400 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
401
402 HallData hallData;
403 event.data = reinterpret_cast<uint8_t*>(&hallData);
404 mgr.HandleHallData(&event);
405 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
406
407 event.dataLen = 0;
408 mgr.HandleHallData(&event);
409 EXPECT_EQ(mgr.curHall_, USHRT_MAX);
410
411 event.dataLen = sizeof(HallData);
412 mgr.HandleHallData(&event);
413 EXPECT_EQ(mgr.curHall_, VALID_HALL_STATUS);
414
415 hallData.status = 132;
416 mgr.HandleHallData(&event);
417 ASSERT_EQ(mgr.curHall_, HALL_HAVE_KEYBOARD_THRESHOLD);
418 }
419 }
420 } // namespace Rosen
421 } // namespace OHOS