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 "screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h"
19 #include "screen_session_manager/include/fold_screen_controller/secondary_fold_sensor_manager.h"
20 #include "screen_session_manager/include/fold_screen_controller/fold_screen_sensor_manager.h"
21 #include "screen_session_manager/include/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.h"
22 #include "fold_screen_state_internel.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
31 std::recursive_mutex g_displayInfoMutex;
32 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler_ = std::make_shared<TaskScheduler>("test");
33 sptr<SecondaryDisplayFoldPolicy> g_policy;
34 sptr<SecondaryDisplaySensorFoldStateManager> g_stateManager = new SecondaryDisplaySensorFoldStateManager();
35 constexpr size_t SECONDARY_POSTURE_SIZE = 3;
36 constexpr size_t SECONDARY_HALL_SIZE = 2;
37 constexpr float CORRECT_POSTURE_BC = 90.0F;
38 constexpr float CORRECT_POSTURE_AB = 160.0F;
39 constexpr float CORRECT_POSTURE_AB_ANTI = 5.0F;
40 constexpr uint16_t CORRECT_HALL_BC = 0;
41 constexpr uint16_t CORRECT_HALL_AB = 0;
42 constexpr uint16_t FIRST_DATA = 0;
43 constexpr uint16_t SECOND_DATA = 1;
44 constexpr uint16_t THIRD_DATA = 2;
45 #define ONLY_FOR_SECONDARY_DISPLAY_FOLD if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {return;}
46 }
47 class SecondaryFoldSensorManagerTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp() override;
52 void TearDown() override;
53 };
54
SetUpTestCase()55 void SecondaryFoldSensorManagerTest::SetUpTestCase()
56 {
57 ONLY_FOR_SECONDARY_DISPLAY_FOLD
58 g_policy = new SecondaryDisplayFoldPolicy(g_displayInfoMutex, screenPowerTaskScheduler_);
59 SecondaryFoldSensorManager::GetInstance().SetFoldScreenPolicy(g_policy);
60 SecondaryFoldSensorManager::GetInstance().SetSensorFoldStateManager(g_stateManager);
61 }
62
TearDownTestCase()63 void SecondaryFoldSensorManagerTest::TearDownTestCase()
64 {
65 usleep(SLEEP_TIME_IN_US);
66 }
67
SetUp()68 void SecondaryFoldSensorManagerTest::SetUp()
69 {
70 }
71
TearDown()72 void SecondaryFoldSensorManagerTest::TearDown()
73 {
74 }
75
76 namespace {
77 /**
78 * @tc.name: RegisterPostureCallback01
79 * @tc.desc: test function : RegisterPostureCallback
80 * @tc.type: FUNC
81 */
82 HWTEST_F(SecondaryFoldSensorManagerTest, RegisterPostureCallback01, TestSize.Level1)
83 {
84 ONLY_FOR_SECONDARY_DISPLAY_FOLD
85 SecondaryFoldSensorManager::GetInstance().RegisterPostureCallback();
86 EXPECT_FALSE(SecondaryFoldSensorManager::GetInstance().IsPostureUserCallbackInvalid());
87 }
88
89 /**
90 * @tc.name: UnRegisterPostureCallback01
91 * @tc.desc: test function : UnRegisterPostureCallback
92 * @tc.type: FUNC
93 */
94 HWTEST_F(SecondaryFoldSensorManagerTest, UnRegisterPostureCallback01, TestSize.Level1)
95 {
96 ONLY_FOR_SECONDARY_DISPLAY_FOLD
97 SecondaryFoldSensorManager::GetInstance().UnRegisterPostureCallback();
98 EXPECT_FALSE(SecondaryFoldSensorManager::GetInstance().IsPostureUserCallbackInvalid());
99 }
100
101 /**
102 * @tc.name: RegisterHallCallback01
103 * @tc.desc: test function : RegisterHallCallback
104 * @tc.type: FUNC
105 */
106 HWTEST_F(SecondaryFoldSensorManagerTest, RegisterHallCallback01, TestSize.Level1)
107 {
108 ONLY_FOR_SECONDARY_DISPLAY_FOLD
109 SecondaryFoldSensorManager::GetInstance().RegisterHallCallback();
110 EXPECT_FALSE(SecondaryFoldSensorManager::GetInstance().IsHallUserCallbackInvalid());
111 }
112
113 /**
114 * @tc.name: UnRegisterHallCallback01
115 * @tc.desc: test function : UnRegisterHallCallback
116 * @tc.type: FUNC
117 */
118 HWTEST_F(SecondaryFoldSensorManagerTest, UnRegisterHallCallback01, TestSize.Level1)
119 {
120 ONLY_FOR_SECONDARY_DISPLAY_FOLD
121 SecondaryFoldSensorManager::GetInstance().UnRegisterHallCallback();
122 EXPECT_FALSE(SecondaryFoldSensorManager::GetInstance().IsHallUserCallbackInvalid());
123 }
124
HandlePostureData(float postureBc,float postureAb,float postureAbAnti)125 static std::vector<float> HandlePostureData(float postureBc, float postureAb, float postureAbAnti)
126 {
127 FoldScreenSensorManager::PostureDataSecondary postureData = {
128 .postureBc = postureBc,
129 .postureAb = postureAb,
130 .postureAbAnti = postureAbAnti,
131 };
132 SensorEvent postureEvent = {
133 .dataLen = sizeof(FoldScreenSensorManager::PostureDataSecondary),
134 .data = reinterpret_cast<uint8_t *>(&postureData),
135 };
136 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandlePostureData(&postureEvent);
137 std::vector<float> postures = SecondaryFoldSensorManager::GetInstance().GetGlobalAngle();
138 return postures;
139 }
140
141 /**
142 * @tc.name: HandlePostureData01
143 * @tc.desc: test function : HandlePostureData
144 * @tc.type: FUNC
145 */
146 HWTEST_F(SecondaryFoldSensorManagerTest, HandlePostureData01, TestSize.Level1)
147 {
148 ONLY_FOR_SECONDARY_DISPLAY_FOLD
149 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandlePostureData(nullptr);
150 std::vector<float> postures = SecondaryFoldSensorManager::GetInstance().GetGlobalAngle();
151 EXPECT_EQ(postures.size(), SECONDARY_POSTURE_SIZE);
152 EXPECT_EQ(postures[FIRST_DATA], -1.0F);
153 EXPECT_EQ(postures[SECOND_DATA], -1.0F);
154 EXPECT_EQ(postures[THIRD_DATA], -1.0F);
155 }
156
157 /**
158 * @tc.name: HandlePostureData02
159 * @tc.desc: test function : HandlePostureData
160 * @tc.type: FUNC
161 */
162 HWTEST_F(SecondaryFoldSensorManagerTest, HandlePostureData02, TestSize.Level1)
163 {
164 ONLY_FOR_SECONDARY_DISPLAY_FOLD
165 SensorEvent postureEvent = {
166 .dataLen = sizeof(PostureData),
167 .data = nullptr,
168 };
169 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandlePostureData(&postureEvent);
170 std::vector<float> postures = SecondaryFoldSensorManager::GetInstance().GetGlobalAngle();
171 EXPECT_EQ(postures.size(), SECONDARY_POSTURE_SIZE);
172 EXPECT_EQ(postures[FIRST_DATA], -1.0F);
173 EXPECT_EQ(postures[SECOND_DATA], -1.0F);
174 EXPECT_EQ(postures[THIRD_DATA], -1.0F);
175 }
176
177 /**
178 * @tc.name: HandlePostureData03
179 * @tc.desc: test function : HandlePostureData
180 * @tc.type: FUNC
181 */
182 HWTEST_F(SecondaryFoldSensorManagerTest, HandlePostureData03, TestSize.Level1)
183 {
184 ONLY_FOR_SECONDARY_DISPLAY_FOLD
185 float postureBc = 181.0F;
186 float postureAb = 160.0F;
187 float postureAbAnti = -1.0F;
188 std::vector<float> postures = HandlePostureData(postureBc, postureAb, postureAbAnti);
189 EXPECT_EQ(postures.size(), SECONDARY_POSTURE_SIZE);
190 EXPECT_EQ(postures[FIRST_DATA], postureBc);
191 EXPECT_EQ(postures[SECOND_DATA], postureAb);
192 EXPECT_EQ(postures[THIRD_DATA], postureAbAnti);
193 }
194
195 /**
196 * @tc.name: HandlePostureData04
197 * @tc.desc: test function : HandlePostureData
198 * @tc.type: FUNC
199 */
200 HWTEST_F(SecondaryFoldSensorManagerTest, HandlePostureData04, TestSize.Level1)
201 {
202 ONLY_FOR_SECONDARY_DISPLAY_FOLD
203 std::vector<float> postures = HandlePostureData(CORRECT_POSTURE_BC, CORRECT_POSTURE_AB, CORRECT_POSTURE_AB_ANTI);
204 EXPECT_EQ(postures.size(), SECONDARY_POSTURE_SIZE);
205 EXPECT_EQ(postures[FIRST_DATA], CORRECT_POSTURE_BC);
206 EXPECT_EQ(postures[SECOND_DATA], CORRECT_POSTURE_AB);
207 EXPECT_EQ(postures[THIRD_DATA], CORRECT_POSTURE_AB_ANTI);
208 }
209
HandleHallDataExt(uint16_t hallBc,uint16_t hallAb)210 static std::vector<uint16_t> HandleHallDataExt(uint16_t hallBc, uint16_t hallAb)
211 {
212 FoldScreenSensorManager::EXTHALLData hallData = {
213 .flag = 26,
214 .hall = hallBc,
215 .hallAb = hallAb,
216 };
217 SensorEvent hallEvent = {
218 .dataLen = sizeof(FoldScreenSensorManager::EXTHALLData),
219 .data = reinterpret_cast<uint8_t *>(&hallData),
220 };
221 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandleHallDataExt(&hallEvent);
222 std::vector<uint16_t> halls = SecondaryFoldSensorManager::GetInstance().GetGlobalHall();
223 return halls;
224 }
225
226 /**
227 * @tc.name: HandleHallDataExt01
228 * @tc.desc: test function : HandleHallDataExt
229 * @tc.type: FUNC
230 */
231 HWTEST_F(SecondaryFoldSensorManagerTest, HandleHallDataExt01, TestSize.Level1)
232 {
233 ONLY_FOR_SECONDARY_DISPLAY_FOLD
234 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandleHallDataExt(nullptr);
235 std::vector<uint16_t> halls = SecondaryFoldSensorManager::GetInstance().GetGlobalHall();
236 EXPECT_EQ(halls.size(), SECONDARY_HALL_SIZE);
237 EXPECT_EQ(halls[FIRST_DATA], USHRT_MAX);
238 EXPECT_EQ(halls[SECOND_DATA], USHRT_MAX);
239 }
240
241 /**
242 * @tc.name: HandleHallDataExt02
243 * @tc.desc: test function : HandleHallDataExt
244 * @tc.type: FUNC
245 */
246 HWTEST_F(SecondaryFoldSensorManagerTest, HandleHallDataExt02, TestSize.Level1)
247 {
248 ONLY_FOR_SECONDARY_DISPLAY_FOLD
249 SensorEvent hallEvent = {
250 .dataLen = sizeof(FoldScreenSensorManager::EXTHALLData),
251 .data = nullptr,
252 };
253 OHOS::Rosen::SecondaryFoldSensorManager::GetInstance().HandleHallDataExt(&hallEvent);
254 std::vector<uint16_t> halls = SecondaryFoldSensorManager::GetInstance().GetGlobalHall();
255 EXPECT_EQ(halls.size(), SECONDARY_HALL_SIZE);
256 EXPECT_EQ(halls[FIRST_DATA], USHRT_MAX);
257 EXPECT_EQ(halls[SECOND_DATA], USHRT_MAX);
258 }
259
260 /**
261 * @tc.name: HandleHallDataExt03
262 * @tc.desc: test function : HandleHallDataExt
263 * @tc.type: FUNC
264 */
265 HWTEST_F(SecondaryFoldSensorManagerTest, HandleHallDataExt03, TestSize.Level1)
266 {
267 ONLY_FOR_SECONDARY_DISPLAY_FOLD
268 uint16_t hallBc = 2;
269 uint16_t hallAb = 0;
270 std::vector<uint16_t> halls = HandleHallDataExt(hallBc, hallAb);
271 EXPECT_EQ(halls.size(), SECONDARY_HALL_SIZE);
272 EXPECT_EQ(halls[FIRST_DATA], hallBc);
273 EXPECT_EQ(halls[SECOND_DATA], hallAb);
274 }
275
276 /**
277 * @tc.name: HandleHallDataExt04
278 * @tc.desc: test function : HandleHallDataExt
279 * @tc.type: FUNC
280 */
281 HWTEST_F(SecondaryFoldSensorManagerTest, HandleHallDataExt04, TestSize.Level1)
282 {
283 ONLY_FOR_SECONDARY_DISPLAY_FOLD
284 std::vector<uint16_t> halls = HandleHallDataExt(CORRECT_HALL_BC, CORRECT_HALL_AB);
285 EXPECT_EQ(halls.size(), SECONDARY_HALL_SIZE);
286 EXPECT_EQ(halls[FIRST_DATA], CORRECT_HALL_BC);
287 EXPECT_EQ(halls[SECOND_DATA], CORRECT_HALL_AB);
288 }
289 }
290 }
291 }