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         event[0].sensorTypeId, event[0].version, event[0].dataLen, postureData->gxm, postureData->gym,
97         postureData->gzm, postureData->gxs, postureData->gys, postureData->gzs, postureData->angle);
98 }
99 
PostureDataCallbackImpl2(SensorEvent * event)100 void PostureDataCallbackImpl2(SensorEvent *event)
101 {
102     if (event == nullptr) {
103         SEN_HILOGE("event is nullptr");
104         return;
105     }
106     if (event[0].data == nullptr) {
107         SEN_HILOGE("event[0].data is nullptr");
108         return;
109     }
110     if (event[0].dataLen < sizeof(PostureData)) {
111         SEN_HILOGE("Event dataLen less than posture data size, event.dataLen:%{public}u", event[0].dataLen);
112         return;
113     }
114     PostureData *postureData = reinterpret_cast<PostureData *>(event[0].data);
115     float angle = postureData->angle;
116     if ((std::fabs(angle - ANGLE_MIN) > std::numeric_limits<float>::epsilon() && angle < ANGLE_MIN)
117         || (std::fabs(angle - ANGLE_MAX) > std::numeric_limits<float>::epsilon() && angle > ANGLE_MAX)) {
118         SEN_HILOGE("Invalid posture angle, angle:%{public}f", angle);
119         return;
120     }
121     SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, gxm:%{public}f, "
122         "gym:%{public}f, gzm:%{public}f, gxs:%{public}f, gys:%{public}f, gzs:%{public}f, angle:%{public}f",
123         event[0].sensorTypeId, event[0].version, event[0].dataLen, postureData->gxm, postureData->gym,
124         postureData->gzm, postureData->gxs, postureData->gys, postureData->gzs, postureData->angle);
125 }
126 
127 HWTEST_F(PostureTest, PostureTest_001, TestSize.Level1)
128 {
129     SEN_HILOGI("PostureTest_001 enter");
130     if (g_existPosture) {
131         int32_t ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
132         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
133     }
134 }
135 
136 HWTEST_F(PostureTest, PostureTest_002, TestSize.Level1)
137 {
138     SEN_HILOGI("PostureTest_002 enter");
139     if (g_existPosture) {
140         SensorUser user;
141         user.callback = PostureDataCallbackImpl;
142         int32_t ret = ActivateSensor(-1, &user);
143         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
144     }
145 }
146 
147 HWTEST_F(PostureTest, PostureTest_003, TestSize.Level1)
148 {
149     SEN_HILOGI("PostureTest_003 enter");
150     if (g_existPosture) {
151         SensorUser user;
152         user.callback = nullptr;
153         int32_t ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
154         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
155     }
156 }
157 
158 HWTEST_F(PostureTest, PostureTest_004, TestSize.Level1)
159 {
160     SEN_HILOGI("PostureTest_004 enter");
161     if (g_existPosture) {
162         int32_t ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
163         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
164     }
165 }
166 
167 HWTEST_F(PostureTest, PostureTest_005, TestSize.Level1)
168 {
169     SEN_HILOGI("PostureTest_005 enter");
170     if (g_existPosture) {
171         SensorUser user;
172         user.callback = PostureDataCallbackImpl;
173         int32_t ret = DeactivateSensor(-1, &user);
174         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
175     }
176 }
177 
178 HWTEST_F(PostureTest, PostureTest_006, TestSize.Level1)
179 {
180     SEN_HILOGI("PostureTest_006 enter");
181     if (g_existPosture) {
182         SensorUser user;
183         user.callback = nullptr;
184         int32_t ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
185         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
186     }
187 }
188 
189 HWTEST_F(PostureTest, PostureTest_007, TestSize.Level1)
190 {
191     SEN_HILOGI("PostureTest_007 enter");
192     if (g_existPosture) {
193         int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, nullptr, 10000000, 10000000);
194         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
195     }
196 }
197 
198 HWTEST_F(PostureTest, PostureTest_008, TestSize.Level1)
199 {
200     SEN_HILOGI("PostureTest_008 enter");
201     if (g_existPosture) {
202         SensorUser user;
203         user.callback = PostureDataCallbackImpl;
204         int32_t ret = SetBatch(-1, &user, 10000000, 10000000);
205         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
206     }
207 }
208 
209 HWTEST_F(PostureTest, PostureTest_009, TestSize.Level1)
210 {
211     SEN_HILOGI("PostureTest_009 enter");
212     if (g_existPosture) {
213         SensorUser user;
214         user.callback = nullptr;
215         int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
216         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
217     }
218 }
219 
220 HWTEST_F(PostureTest, PostureTest_010, TestSize.Level1)
221 {
222     SEN_HILOGI("PostureTest_010 enter");
223     if (g_existPosture) {
224         SensorUser user;
225         user.callback = PostureDataCallbackImpl;
226         int32_t ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, -1, -1);
227         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
228     }
229 }
230 
231 HWTEST_F(PostureTest, PostureTest_011, TestSize.Level1)
232 {
233     SEN_HILOGI("PostureTest_011 enter");
234     if (g_existPosture) {
235         int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
236         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
237     }
238 }
239 
240 HWTEST_F(PostureTest, PostureTest_012, TestSize.Level1)
241 {
242     SEN_HILOGI("PostureTest_012 enter");
243     if (g_existPosture) {
244         SensorUser user;
245         user.callback = PostureDataCallbackImpl;
246         int32_t ret = SubscribeSensor(-1, &user);
247         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
248     }
249 }
250 
251 HWTEST_F(PostureTest, PostureTest_013, TestSize.Level1)
252 {
253     SEN_HILOGI("PostureTest_013 enter");
254     if (g_existPosture) {
255         SensorUser user;
256         user.callback = nullptr;
257         int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
258         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
259     }
260 }
261 
262 HWTEST_F(PostureTest, PostureTest_014, TestSize.Level1)
263 {
264     SEN_HILOGI("PostureTest_014 enter");
265     if (g_existPosture) {
266         int32_t ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, nullptr);
267         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
268     }
269 }
270 
271 HWTEST_F(PostureTest, PostureTest_015, TestSize.Level1)
272 {
273     SEN_HILOGI("PostureTest_015 enter");
274     if (g_existPosture) {
275         SensorUser user;
276         user.callback = PostureDataCallbackImpl;
277         int32_t ret = UnsubscribeSensor(-1, &user);
278         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
279     }
280 }
281 
282 HWTEST_F(PostureTest, PostureTest_016, TestSize.Level1)
283 {
284     SEN_HILOGI("PostureTest_016 enter");
285     if (g_existPosture) {
286         SensorUser user;
287         user.callback = nullptr;
288         int32_t ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
289         ASSERT_NE(ret, OHOS::Sensors::SUCCESS);
290     }
291 }
292 
293 HWTEST_F(PostureTest, PostureTest_017, TestSize.Level1)
294 {
295     SEN_HILOGI("PostureTest_017 enter");
296     if (g_existPosture) {
297         SensorUser user;
298         user.callback = PostureDataCallbackImpl;
299         int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
300         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
301         ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
302         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
303         ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
304         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
305         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
306         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
307         ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
308         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
309         ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
310         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
311     }
312 }
313 
314 HWTEST_F(PostureTest, PostureTest_018, TestSize.Level1)
315 {
316     SEN_HILOGI("PostureTest_018 enter");
317     if (g_existPosture) {
318         SensorUser user;
319         user.callback = PostureDataCallbackImpl;
320         int32_t ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
321         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
322         ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, 10000000, 10000000);
323         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
324         ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
325         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
326         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
327         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
328         ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
329         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
330         ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
331         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
332 
333         SensorUser user2;
334         user2.callback = PostureDataCallbackImpl2;
335         ret = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user2);
336         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
337         ret = SetBatch(SENSOR_TYPE_ID_POSTURE, &user2, 20000000, 20000000);
338         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
339         ret = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user2);
340         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
341         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
342         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
343         ret = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user2);
344         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
345         ret = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user2);
346         ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
347     }
348 }
349 } // namespace Sensors
350 } // namespace OHOS
351