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 "HeadPostureTest"
27 
28 namespace OHOS {
29 namespace Sensors {
30 using namespace testing::ext;
31 using namespace OHOS::HiviewDFX;
32 
33 namespace {
34 std::atomic_bool g_existHeadPosture = false;
35 } // namespace
36 
37 class HeadPostureTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase()45 void HeadPostureTest::SetUpTestCase()
46 {
47     SensorInfo *sensorInfo = nullptr;
48     int32_t count = 0;
49     int32_t ret = GetAllSensors(&sensorInfo, &count);
50     ASSERT_EQ(ret, OHOS::Sensors::SUCCESS);
51     if (sensorInfo == nullptr || count == 0) {
52         SEN_HILOGE("sensorInfo is nullptr or count is 0");
53         return;
54     }
55     for (int32_t i = 0; i < count; ++i) {
56         if (sensorInfo[i].sensorId == SENSOR_TYPE_ID_HEADPOSTURE) {
57             g_existHeadPosture = true;
58             SEN_HILOGD("Exist head posture sensor");
59             break;
60         }
61     }
62     SEN_HILOGD("Not exist head posture sensor");
63 }
64 
TearDownTestCase()65 void HeadPostureTest::TearDownTestCase() {}
66 
SetUp()67 void HeadPostureTest::SetUp() {}
68 
TearDown()69 void HeadPostureTest::TearDown() {}
70 
HeadPostureDataCallbackImpl(SensorEvent * event)71 void HeadPostureDataCallbackImpl(SensorEvent *event)
72 {
73     if (event == nullptr) {
74         SEN_HILOGE("event is nullptr");
75         return;
76     }
77     if (event[0].data == nullptr) {
78         SEN_HILOGE("event[0].data is nullptr");
79         return;
80     }
81     if (event[0].dataLen < sizeof(HeadPostureData)) {
82         SEN_HILOGE("Event dataLen less than head posture data size, event.dataLen:%{public}u", event[0].dataLen);
83         return;
84     }
85     HeadPostureData *headPostureData = reinterpret_cast<HeadPostureData *>(event[0].data);
86     if (headPostureData == nullptr) {
87         SEN_HILOGE("headPostureData is nullptr");
88         return;
89     }
90     SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, "
91         "w:%{public}f, x:%{public}f, y:%{public}f, z:%{public}f", event[0].sensorTypeId, event[0].version,
92         event[0].dataLen, headPostureData->w, headPostureData->x, headPostureData->y, headPostureData->z);
93 }
94 
HeadPostureDataCallbackImpl2(SensorEvent * event)95 void HeadPostureDataCallbackImpl2(SensorEvent *event)
96 {
97     if (event == nullptr) {
98         SEN_HILOGE("event is nullptr");
99         return;
100     }
101     if (event[0].data == nullptr) {
102         SEN_HILOGE("event[0].data is nullptr");
103         return;
104     }
105     if (event[0].dataLen < sizeof(HeadPostureData)) {
106         SEN_HILOGE("Event dataLen less than head posture data size, event.dataLen:%{public}u", event[0].dataLen);
107         return;
108     }
109     HeadPostureData *headPostureData = reinterpret_cast<HeadPostureData *>(event[0].data);
110     if (headPostureData == nullptr) {
111         SEN_HILOGE("headPostureData is nullptr");
112         return;
113     }
114     SEN_HILOGD("sensorId:%{public}d, version:%{public}d, dataLen:%{public}u, "
115         "w:%{public}f, x:%{public}f, y:%{public}f, z:%{public}f", event[0].sensorTypeId, event[0].version,
116         event[0].dataLen, headPostureData->w, headPostureData->x, headPostureData->y, headPostureData->z);
117 }
118 
119 HWTEST_F(HeadPostureTest, HeadPostureTest_001, TestSize.Level1)
120 {
121     SEN_HILOGI("HeadPostureTest_001 enter");
122     if (g_existHeadPosture) {
123         ASSERT_NE(ActivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, nullptr), OHOS::Sensors::SUCCESS);
124     }
125 }
126 
127 HWTEST_F(HeadPostureTest, HeadPostureTest_002, TestSize.Level1)
128 {
129     SEN_HILOGI("HeadPostureTest_002 enter");
130     if (g_existHeadPosture) {
131         SensorUser user;
132         user.callback = HeadPostureDataCallbackImpl;
133         ASSERT_NE(ActivateSensor(-1, &user), OHOS::Sensors::SUCCESS);
134     }
135 }
136 
137 HWTEST_F(HeadPostureTest, HeadPostureTest_003, TestSize.Level1)
138 {
139     SEN_HILOGI("HeadPostureTest_003 enter");
140     if (g_existHeadPosture) {
141         SensorUser user;
142         user.callback = nullptr;
143         ASSERT_NE(ActivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
144     }
145 }
146 
147 HWTEST_F(HeadPostureTest, HeadPostureTest_004, TestSize.Level1)
148 {
149     SEN_HILOGI("HeadPostureTest_004 enter");
150     if (g_existHeadPosture) {
151         ASSERT_NE(DeactivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, nullptr), OHOS::Sensors::SUCCESS);
152     }
153 }
154 
155 HWTEST_F(HeadPostureTest, HeadPostureTest_005, TestSize.Level1)
156 {
157     SEN_HILOGI("HeadPostureTest_005 enter");
158     if (g_existHeadPosture) {
159         SensorUser user;
160         user.callback = HeadPostureDataCallbackImpl;
161         ASSERT_NE(DeactivateSensor(-1, &user), OHOS::Sensors::SUCCESS);
162     }
163 }
164 
165 HWTEST_F(HeadPostureTest, HeadPostureTest_006, TestSize.Level1)
166 {
167     SEN_HILOGI("HeadPostureTest_006 enter");
168     if (g_existHeadPosture) {
169         SensorUser user;
170         user.callback = nullptr;
171         ASSERT_NE(DeactivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
172     }
173 }
174 
175 HWTEST_F(HeadPostureTest, HeadPostureTest_007, TestSize.Level1)
176 {
177     SEN_HILOGI("HeadPostureTest_007 enter");
178     if (g_existHeadPosture) {
179         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, nullptr, 10000000, 10000000), OHOS::Sensors::SUCCESS);
180     }
181 }
182 
183 HWTEST_F(HeadPostureTest, HeadPostureTest_008, TestSize.Level1)
184 {
185     SEN_HILOGI("HeadPostureTest_008 enter");
186     if (g_existHeadPosture) {
187         SensorUser user;
188         user.callback = HeadPostureDataCallbackImpl;
189         ASSERT_NE(SetBatch(-1, &user, 10000000, 10000000), OHOS::Sensors::SUCCESS);
190     }
191 }
192 
193 HWTEST_F(HeadPostureTest, HeadPostureTest_009, TestSize.Level1)
194 {
195     SEN_HILOGI("HeadPostureTest_009 enter");
196     if (g_existHeadPosture) {
197         SensorUser user;
198         user.callback = nullptr;
199         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, &user, 10000000, 10000000), OHOS::Sensors::SUCCESS);
200     }
201 }
202 
203 HWTEST_F(HeadPostureTest, HeadPostureTest_010, TestSize.Level1)
204 {
205     SEN_HILOGI("HeadPostureTest_010 enter");
206     if (g_existHeadPosture) {
207         SensorUser user;
208         user.callback = HeadPostureDataCallbackImpl;
209         ASSERT_NE(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, &user, -1, -1), OHOS::Sensors::SUCCESS);
210     }
211 }
212 
213 HWTEST_F(HeadPostureTest, HeadPostureTest_011, TestSize.Level1)
214 {
215     SEN_HILOGI("HeadPostureTest_011 enter");
216     if (g_existHeadPosture) {
217         ASSERT_NE(SubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, nullptr), OHOS::Sensors::SUCCESS);
218     }
219 }
220 
221 HWTEST_F(HeadPostureTest, HeadPostureTest_012, TestSize.Level1)
222 {
223     SEN_HILOGI("HeadPostureTest_012 enter");
224     if (g_existHeadPosture) {
225         SensorUser user;
226         user.callback = HeadPostureDataCallbackImpl;
227         ASSERT_NE(SubscribeSensor(-1, &user), OHOS::Sensors::SUCCESS);
228     }
229 }
230 
231 HWTEST_F(HeadPostureTest, HeadPostureTest_013, TestSize.Level1)
232 {
233     SEN_HILOGI("HeadPostureTest_013 enter");
234     if (g_existHeadPosture) {
235         SensorUser user;
236         user.callback = nullptr;
237         ASSERT_NE(SubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
238     }
239 }
240 
241 HWTEST_F(HeadPostureTest, HeadPostureTest_014, TestSize.Level1)
242 {
243     SEN_HILOGI("HeadPostureTest_014 enter");
244     if (g_existHeadPosture) {
245         ASSERT_NE(UnsubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, nullptr), OHOS::Sensors::SUCCESS);
246     }
247 }
248 
249 HWTEST_F(HeadPostureTest, HeadPostureTest_015, TestSize.Level1)
250 {
251     SEN_HILOGI("HeadPostureTest_015 enter");
252     if (g_existHeadPosture) {
253         SensorUser user;
254         user.callback = HeadPostureDataCallbackImpl;
255         ASSERT_NE(UnsubscribeSensor(-1, &user), OHOS::Sensors::SUCCESS);
256     }
257 }
258 
259 HWTEST_F(HeadPostureTest, HeadPostureTest_016, TestSize.Level1)
260 {
261     SEN_HILOGI("HeadPostureTest_016 enter");
262     if (g_existHeadPosture) {
263         SensorUser user;
264         user.callback = nullptr;
265         ASSERT_NE(UnsubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
266     }
267 }
268 
269 HWTEST_F(HeadPostureTest, HeadPostureTest_017, TestSize.Level1)
270 {
271     SEN_HILOGI("HeadPostureTest_017 enter");
272     if (g_existHeadPosture) {
273         SensorUser user;
274         user.callback = HeadPostureDataCallbackImpl;
275         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
276         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, &user, 10000000, 10000000), OHOS::Sensors::SUCCESS);
277         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
278         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
279         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
280         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
281     }
282 }
283 
284 HWTEST_F(HeadPostureTest, HeadPostureTest_018, TestSize.Level1)
285 {
286     SEN_HILOGI("HeadPostureTest_018 enter");
287     if (g_existHeadPosture) {
288         SensorUser user;
289         user.callback = HeadPostureDataCallbackImpl;
290         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
291         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, &user, 10000000, 10000000), OHOS::Sensors::SUCCESS);
292         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
293         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
294         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
295         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user), OHOS::Sensors::SUCCESS);
296 
297         SensorUser user2;
298         user2.callback = HeadPostureDataCallbackImpl2;
299         ASSERT_EQ(SubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user2), OHOS::Sensors::SUCCESS);
300         ASSERT_EQ(SetBatch(SENSOR_TYPE_ID_HEADPOSTURE, &user2, 20000000, 20000000), OHOS::Sensors::SUCCESS);
301         ASSERT_EQ(ActivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user2), OHOS::Sensors::SUCCESS);
302         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
303         ASSERT_EQ(DeactivateSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user2), OHOS::Sensors::SUCCESS);
304         ASSERT_EQ(UnsubscribeSensor(SENSOR_TYPE_ID_HEADPOSTURE, &user2), OHOS::Sensors::SUCCESS);
305     }
306 }
307 } // namespace Sensors
308 } // namespace OHOS
309