1 /*
2 * Copyright (c) 2023 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 <atomic>
17 #include <thread>
18
19 #include <gtest/gtest.h>
20
21 #include "sensor_agent.h"
22 #include "sensor_agent_type.h"
23 #include "sensor_errors.h"
24
25 #undef LOG_TAG
26 #define LOG_TAG "PostureTest"
27
28 namespace OHOS {
29 namespace Sensors {
30 using namespace testing::ext;
31 using namespace OHOS::HiviewDFX;
32
33 namespace {
34 constexpr float ANGLE_MAX = 180.0F;
35 constexpr float ANGLE_MIN = 0.0F;
36 std::atomic_bool g_existPosture = false;
37 } // namespace
38
39 class PostureTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void PostureTest::SetUpTestCase()
48 {
49 SensorInfo *sensorInfo = nullptr;
50 int32_t count = 0;
51 int32_t ret = GetAllSensors(&sensorInfo, &count);
52 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
53 if (sensorInfo == nullptr || count == 0) {
54 SEN_HILOGE("sensorInfo is nullptr or count is 0");
55 return;
56 }
57 for (int32_t i = 0; i < count; ++i) {
58 if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_POSTURE) {
59 g_existPosture = true;
60 SEN_HILOGD("Exist posture sensor");
61 break;
62 }
63 }
64 SEN_HILOGD("Not exist posture sensor");
65 }
66
TearDownTestCase()67 void PostureTest::TearDownTestCase() {}
68
SetUp()69 void PostureTest::SetUp() {}
70
TearDown()71 void PostureTest::TearDown() {}
72
PostureDataCallbackImpl(SensorEvent * event)73 void PostureDataCallbackImpl(SensorEvent *event)
74 {
75 if (event == nullptr) {
76 SEN_HILOGE("event is nullptr");
77 return;
78 }
79 if (event[0].data == nullptr) {
80 SEN_HILOGE("event[0].data is nullptr");
81 return;
82 }
83 if (event[0].dataLen < sizeof(PostureData)) {
84 SEN_HILOGE("Event dataLen less than posture data size, event.dataLen:%{public}u", event[0].dataLen);
85 return;
86 }
87 PostureData *postureData = reinterpret_cast<PostureData *>(event[0].data);
88 float angle = postureData->angle;
89 if ((angle < ANGLE_MIN && std::fabs(angle - ANGLE_MIN) > std::numeric_limits<float>::epsilon())
90 || (angle > ANGLE_MAX && std::fabs(angle - ANGLE_MAX) > std::numeric_limits<float>::epsilon())) {
91 SEN_HILOGE("Invalid posture angle, angle:%{public}f", angle);
92 return;
93 }
94 SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, gxm:%{public}f, "
95 "gym:%{public}f, gzm:%{public}f, gxs:%{public}f, gys:%{public}f, gzs:%{public}f, angle:%{public}f, "
96 "screenAndPostureStatus:%{public}f, gxt:%{public}f, gyt:%{public}f, gzt:%{public}f, "
97 "abAngle:%{public}f, abFoldedState:%{public}f",
98 event[0].sensorTypeId, event[0].version, event[0].dataLen, postureData->gxm, postureData->gym, postureData->gzm,
99 postureData->gxs, postureData->gys, postureData->gzs, postureData->angle, postureData->screenAndPostureStatus,
100 postureData->gxt, postureData->gyt, postureData->gzt, postureData->abAngle, postureData->abFoldedState);
101 }
102
PostureDataCallbackImpl2(SensorEvent * event)103 void PostureDataCallbackImpl2(SensorEvent *event)
104 {
105 if (event == nullptr) {
106 SEN_HILOGE("event is nullptr");
107 return;
108 }
109 if (event[0].data == nullptr) {
110 SEN_HILOGE("event[0].data is nullptr");
111 return;
112 }
113 if (event[0].dataLen < sizeof(PostureData)) {
114 SEN_HILOGE("Event dataLen less than posture data size, event.dataLen:%{public}u", event[0].dataLen);
115 return;
116 }
117 PostureData *postureData = reinterpret_cast<PostureData *>(event[0].data);
118 float angle = postureData->angle;
119 if ((std::fabs(angle - ANGLE_MIN) > std::numeric_limits<float>::epsilon() && angle < ANGLE_MIN)
120 || (std::fabs(angle - ANGLE_MAX) > std::numeric_limits<float>::epsilon() && angle > ANGLE_MAX)) {
121 SEN_HILOGE("Invalid posture angle, angle:%{public}f", angle);
122 return;
123 }
124 SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, gxm:%{public}f, "
125 "gym:%{public}f, gzm:%{public}f, gxs:%{public}f, gys:%{public}f, gzs:%{public}f, angle:%{public}f, "
126 "screenAndPostureStatus:%{public}f, gxt:%{public}f, gyt:%{public}f, gzt:%{public}f, "
127 "abAngle:%{public}f, abFoldedState:%{public}f",
128 event[0].sensorTypeId, event[0].version, event[0].dataLen, postureData->gxm, postureData->gym, postureData->gzm,
129 postureData->gxs, postureData->gys, postureData->gzs, postureData->angle, postureData->screenAndPostureStatus,
130 postureData->gxt, postureData->gyt, postureData->gzt, postureData->abAngle, postureData->abFoldedState);
131 }
132
133 HWTEST_F(PostureTest, PostureTest_001, TestSize.Level1)
134 {
135 SEN_HILOGI("PostureTest_001 enter");
136 if (g_existPosture) {
137 int32_t ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
138 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
139 }
140 }
141
142 HWTEST_F(PostureTest, PostureTest_002, TestSize.Level1)
143 {
144 SEN_HILOGI("PostureTest_002 enter");
145 if (g_existPosture) {
146 SensorUser user;
147 user.callback = PostureDataCallbackImpl;
148 int32_t ret = ActivateSensor(-1, &user);
149 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
150 }
151 }
152
153 HWTEST_F(PostureTest, PostureTest_003, TestSize.Level1)
154 {
155 SEN_HILOGI("PostureTest_003 enter");
156 if (g_existPosture) {
157 SensorUser user;
158 user.callback = nullptr;
159 int32_t ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
160 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
161 }
162 }
163
164 HWTEST_F(PostureTest, PostureTest_004, TestSize.Level1)
165 {
166 SEN_HILOGI("PostureTest_004 enter");
167 if (g_existPosture) {
168 int32_t ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
169 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
170 }
171 }
172
173 HWTEST_F(PostureTest, PostureTest_005, TestSize.Level1)
174 {
175 SEN_HILOGI("PostureTest_005 enter");
176 if (g_existPosture) {
177 SensorUser user;
178 user.callback = PostureDataCallbackImpl;
179 int32_t ret = DeactivateSensor(-1, &user);
180 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
181 }
182 }
183
184 HWTEST_F(PostureTest, PostureTest_006, TestSize.Level1)
185 {
186 SEN_HILOGI("PostureTest_006 enter");
187 if (g_existPosture) {
188 SensorUser user;
189 user.callback = nullptr;
190 int32_t ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
191 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
192 }
193 }
194
195 HWTEST_F(PostureTest, PostureTest_007, TestSize.Level1)
196 {
197 SEN_HILOGI("PostureTest_007 enter");
198 if (g_existPosture) {
199 int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, nullptr, 10000000, 10000000);
200 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
201 }
202 }
203
204 HWTEST_F(PostureTest, PostureTest_008, TestSize.Level1)
205 {
206 SEN_HILOGI("PostureTest_008 enter");
207 if (g_existPosture) {
208 SensorUser user;
209 user.callback = PostureDataCallbackImpl;
210 int32_t ret = SetBatch(-1, &user, 10000000, 10000000);
211 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
212 }
213 }
214
215 HWTEST_F(PostureTest, PostureTest_009, TestSize.Level1)
216 {
217 SEN_HILOGI("PostureTest_009 enter");
218 if (g_existPosture) {
219 SensorUser user;
220 user.callback = nullptr;
221 int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
222 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
223 }
224 }
225
226 HWTEST_F(PostureTest, PostureTest_010, TestSize.Level1)
227 {
228 SEN_HILOGI("PostureTest_010 enter");
229 if (g_existPosture) {
230 SensorUser user;
231 user.callback = PostureDataCallbackImpl;
232 int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, -1, -1);
233 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
234 }
235 }
236
237 HWTEST_F(PostureTest, PostureTest_011, TestSize.Level1)
238 {
239 SEN_HILOGI("PostureTest_011 enter");
240 if (g_existPosture) {
241 int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
242 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
243 }
244 }
245
246 HWTEST_F(PostureTest, PostureTest_012, TestSize.Level1)
247 {
248 SEN_HILOGI("PostureTest_012 enter");
249 if (g_existPosture) {
250 SensorUser user;
251 user.callback = PostureDataCallbackImpl;
252 int32_t ret = SubscribeSensor(-1, &user);
253 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
254 }
255 }
256
257 HWTEST_F(PostureTest, PostureTest_013, TestSize.Level1)
258 {
259 SEN_HILOGI("PostureTest_013 enter");
260 if (g_existPosture) {
261 SensorUser user;
262 user.callback = nullptr;
263 int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
264 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
265 }
266 }
267
268 HWTEST_F(PostureTest, PostureTest_014, TestSize.Level1)
269 {
270 SEN_HILOGI("PostureTest_014 enter");
271 if (g_existPosture) {
272 int32_t ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
273 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
274 }
275 }
276
277 HWTEST_F(PostureTest, PostureTest_015, TestSize.Level1)
278 {
279 SEN_HILOGI("PostureTest_015 enter");
280 if (g_existPosture) {
281 SensorUser user;
282 user.callback = PostureDataCallbackImpl;
283 int32_t ret = UnsubscribeSensor(-1, &user);
284 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
285 }
286 }
287
288 HWTEST_F(PostureTest, PostureTest_016, TestSize.Level1)
289 {
290 SEN_HILOGI("PostureTest_016 enter");
291 if (g_existPosture) {
292 SensorUser user;
293 user.callback = nullptr;
294 int32_t ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
295 ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
296 }
297 }
298
299 HWTEST_F(PostureTest, PostureTest_017, TestSize.Level1)
300 {
301 SEN_HILOGI("PostureTest_017 enter");
302 if (g_existPosture) {
303 SensorUser user;
304 user.callback = PostureDataCallbackImpl;
305 int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
306 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
307 ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
308 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
309 ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
310 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
311 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
312 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
313 ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
314 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
315 ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
316 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
317 }
318 }
319
320 HWTEST_F(PostureTest, PostureTest_018, TestSize.Level1)
321 {
322 SEN_HILOGI("PostureTest_018 enter");
323 if (g_existPosture) {
324 SensorUser user;
325 user.callback = PostureDataCallbackImpl;
326 int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
327 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
328 ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
329 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
330 ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
331 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
332 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
333 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
334 ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
335 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
336 ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
337 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
338
339 SensorUser user2;
340 user2.callback = PostureDataCallbackImpl2;
341 ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user2);
342 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
343 ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user2, 20000000, 20000000);
344 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
345 ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user2);
346 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
347 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
348 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
349 ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user2);
350 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
351 ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user2);
352 ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
353 }
354 }
355 } // namespace Sensors
356 } // namespace OHOS
357