1 /*
2 * Copyright (c) 2021 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 <cmath>
17 #include <cstdio>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include "hdf_base.h"
22 #include "osal_time.h"
23 #include "v1_0/sensor_interface_proxy.h"
24 #include "sensor_type.h"
25 #include "sensor_callback_impl.h"
26
27 using namespace OHOS::HDI::Sensor::V1_0;
28 using namespace testing::ext;
29
30 namespace {
31 sptr<ISensorInterface> g_sensorInterface = nullptr;
32 sptr<ISensorCallback> g_traditionalCallback = new SensorCallbackImpl();
33 sptr<ISensorCallback> g_medicalCallback = new SensorCallbackImpl();
34 std::vector<HdfSensorInformation> g_info;
35 struct SensorValueRange {
36 float highThreshold;
37 float lowThreshold;
38 };
39
40 struct SensorDevelopmentList {
41 int32_t sensorTypeId;
42 char sensorName[SENSOR_NAME_MAX_LEN];
43 int32_t dataForm; // 0: fixed, 1: range
44 int32_t dataDimension;
45 struct SensorValueRange *valueRange;
46 };
47
48 struct SensorValueRange g_testRange[] = {{1e5, 0}};
49 struct SensorValueRange g_accelRange[] = {{78, -78}, {78, -78}, {78, -78}};
50 struct SensorValueRange g_alsRange[] = {{10000, 0}};
51 struct SensorValueRange g_pedometerRange[] = {{10000, 0}};
52 struct SensorValueRange g_proximityRange[] = {{5, 0}};
53 struct SensorValueRange g_hallRange[] = {{1, 0}};
54 struct SensorValueRange g_barometerRange[] = {{1100, -1100}, {1100, -1100}};
55 struct SensorValueRange g_magneticRange[] = {{2000, -2000}, {2000, -2000}, {2000, -2000}};
56 struct SensorValueRange g_gyroscopeRange[] = {{35, -35}, {35, -35}, {35, -35}};
57 struct SensorValueRange g_gravityRange[] = {{78, -78}, {78, -78}, {78, -78}};
58
59 struct SensorDevelopmentList g_sensorList[] = {
60 {SENSOR_TYPE_NONE, "sensor_test", 1, 1, g_testRange},
61 {SENSOR_TYPE_ACCELEROMETER, "accelerometer", 1, 3, g_accelRange},
62 {SENSOR_TYPE_PEDOMETER, "pedometer", 1, 1, g_pedometerRange},
63 {SENSOR_TYPE_PROXIMITY, "proximity", 0, 1, g_proximityRange},
64 {SENSOR_TYPE_HALL, "hallrometer", 0, 1, g_hallRange},
65 {SENSOR_TYPE_BAROMETER, "barometer", 1, 2, g_barometerRange},
66 {SENSOR_TYPE_AMBIENT_LIGHT, "als", 1, 1, g_alsRange},
67 {SENSOR_TYPE_MAGNETIC_FIELD, "magnetometer", 1, 3, g_magneticRange},
68 {SENSOR_TYPE_GYROSCOPE, "gyroscope", 1, 3, g_gyroscopeRange},
69 {SENSOR_TYPE_GRAVITY, "gravity", 1, 3, g_gravityRange}
70 };
71
72 constexpr int g_listNum = sizeof(g_sensorList) / sizeof(g_sensorList[0]);
73 constexpr int32_t SENSOR_INTERVAL1 = 200000000;
74 constexpr int32_t SENSOR_INTERVAL2 = 20000000;
75 constexpr int32_t SENSOR_POLL_TIME = 1;
76 constexpr int32_t SENSOR_WAIT_TIME = 100;
77 constexpr int32_t ABNORMAL_SENSORID = -1;
78 }
79
80 class HdfSensorHdiTest : public testing::Test {
81 public:
82 static void SetUpTestCase();
83 static void TearDownTestCase();
84 void SetUp();
85 void TearDown();
86 };
87
SetUpTestCase()88 void HdfSensorHdiTest::SetUpTestCase()
89 {
90 g_sensorInterface = ISensorInterface::Get();
91 }
92
TearDownTestCase()93 void HdfSensorHdiTest::TearDownTestCase()
94 {
95 }
96
SetUp()97 void HdfSensorHdiTest::SetUp()
98 {
99 }
100
TearDown()101 void HdfSensorHdiTest::TearDown()
102 {
103 }
104
105 /**
106 * @tc.name: GetSensorClient0001
107 * @tc.desc: Get a client and check whether the client is empty.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(HdfSensorHdiTest, GetSensorClient0001, TestSize.Level1)
111 {
112 ASSERT_NE(nullptr, g_sensorInterface);
113 }
114
115 /**
116 * @tc.name: GetSensorList0001
117 * @tc.desc: Obtains information about all sensors in the system.
118 * @tc.type: FUNC
119 */
120 HWTEST_F(HdfSensorHdiTest, GetSensorList0001, TestSize.Level1)
121 {
122 if (g_sensorInterface == nullptr) {
123 ASSERT_NE(nullptr, g_sensorInterface);
124 return;
125 }
126 int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info);
127 EXPECT_EQ(SENSOR_SUCCESS, ret);
128 EXPECT_GT(g_info.size(), 0);
129 printf("get sensor list num[%zu]\n\r", g_info.size());
130
131 for (auto iter : g_info) {
132 printf("get sensoriId[%d], info name[%s], power[%f]\n\r", iter.sensorId, iter.sensorName.c_str(), iter.power);
133 for (int j =0; j < g_listNum; ++j) {
134 if (iter.sensorId == g_sensorList[j].sensorTypeId) {
135 EXPECT_GT(iter.sensorName.size(), 0);
136 break;
137 }
138 }
139 }
140 }
141
142 /**
143 * @tc.name: RegisterSensorDataCb0001
144 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
145 * @tc.type: FUNC
146 */
147 HWTEST_F(HdfSensorHdiTest, RegisterSensorDataCb0001, TestSize.Level1)
148 {
149 if (g_sensorInterface == nullptr) {
150 ASSERT_NE(nullptr, g_sensorInterface);
151 return;
152 }
153 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_medicalCallback);
154 EXPECT_EQ(SENSOR_SUCCESS, ret);
155 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_medicalCallback);
156 EXPECT_EQ(SENSOR_SUCCESS, ret);
157 }
158
159 /**
160 * @tc.name: RegisterSensorDataCb0002
161 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
162 * @tc.type: FUNC
163 */
164 HWTEST_F(HdfSensorHdiTest, RegisterSensorDataCb0002, TestSize.Level1)
165 {
166 if (g_sensorInterface == nullptr) {
167 ASSERT_NE(nullptr, g_sensorInterface);
168 return;
169 }
170 int32_t ret = g_sensorInterface->Register(MEDICAL_SENSOR_TYPE, g_medicalCallback);
171 EXPECT_EQ(SENSOR_SUCCESS, ret);
172 ret = g_sensorInterface->Unregister(MEDICAL_SENSOR_TYPE, g_medicalCallback);
173 EXPECT_EQ(SENSOR_SUCCESS, ret);
174 }
175
176 /**
177 * @tc.name: RegisterDataCb001
178 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
179 * @tc.type: FUNC
180 */
181 HWTEST_F(HdfSensorHdiTest, RegisterSensorDataCb0003, TestSize.Level1)
182 {
183 if (g_sensorInterface == nullptr) {
184 ASSERT_NE(nullptr, g_sensorInterface);
185 return;
186 }
187 int32_t ret = g_sensorInterface->Register(SENSOR_GROUP_TYPE_MAX, g_medicalCallback);
188 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
189 ret = g_sensorInterface->Unregister(SENSOR_GROUP_TYPE_MAX, g_medicalCallback);
190 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
191 }
192
193 /**
194 * @tc.name: EnableSensor0001
195 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(HdfSensorHdiTest, EnableSensor0001, TestSize.Level1)
199 {
200 if (g_sensorInterface == nullptr) {
201 ASSERT_NE(nullptr, g_sensorInterface);
202 return;
203 }
204 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
205 EXPECT_EQ(SENSOR_SUCCESS, ret);
206
207 EXPECT_GT(g_info.size(), 0);
208
209 for (auto iter : g_info) {
210 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
211 EXPECT_EQ(SENSOR_SUCCESS, ret);
212 ret = g_sensorInterface->Enable(iter.sensorId);
213 EXPECT_EQ(SENSOR_SUCCESS, ret);
214 OsalSleep(SENSOR_POLL_TIME);
215 ret = g_sensorInterface->Disable(iter.sensorId);
216 EXPECT_EQ(SENSOR_SUCCESS, ret);
217 }
218 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
219 EXPECT_EQ(0, ret);
220 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
221 SensorCallbackImpl::sensorDataFlag = 1;
222 }
223
224 /**
225 * @tc.name: EnableSensor0002
226 * @tc.desc: Enables the sensor available in the sensor list based on the specified sensor ID.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(HdfSensorHdiTest, EnableSensor0002, TestSize.Level1)
230 {
231 if (g_sensorInterface == nullptr) {
232 ASSERT_NE(nullptr, g_sensorInterface);
233 return;
234 }
235 int32_t ret = g_sensorInterface->Enable(ABNORMAL_SENSORID);
236 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
237 ret = g_sensorInterface->Disable(ABNORMAL_SENSORID);
238 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
239 }
240
241 /**
242 * @tc.name: SetSensorBatch0001
243 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0001, TestSize.Level1)
247 {
248 if (g_sensorInterface == nullptr) {
249 ASSERT_NE(nullptr, g_sensorInterface);
250 return;
251 }
252 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
253 EXPECT_EQ(SENSOR_SUCCESS, ret);
254
255 for (auto iter : g_info) {
256 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL2, SENSOR_POLL_TIME);
257 EXPECT_EQ(SENSOR_SUCCESS, ret);
258 ret = g_sensorInterface->Enable(iter.sensorId);
259 EXPECT_EQ(SENSOR_SUCCESS, ret);
260 OsalMSleep(SENSOR_WAIT_TIME);
261 ret = g_sensorInterface->Disable(iter.sensorId);
262 EXPECT_EQ(SENSOR_SUCCESS, ret);
263 }
264
265 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
266 EXPECT_EQ(SENSOR_SUCCESS, ret);
267 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
268 SensorCallbackImpl::sensorDataFlag = 1;
269 }
270
271 /** @tc.name: SetSensorBatch0002
272 @tc.desc: Sets the sampling time and data report interval for sensors in batches.
273 @tc.type: FUNC
274 */
275 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0002, TestSize.Level1)
276 {
277 if (g_sensorInterface == nullptr) {
278 ASSERT_NE(nullptr, g_sensorInterface);
279 return;
280 }
281 int32_t ret = g_sensorInterface->SetBatch(ABNORMAL_SENSORID, 0, 0);
282 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
283 }
284
285 /**
286 * @tc.name: SetSensorBatch0003
287 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
288 * @tc.type: FUNC
289 */
290 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0003, TestSize.Level1)
291 {
292 if (g_sensorInterface == nullptr) {
293 ASSERT_NE(nullptr, g_sensorInterface);
294 return;
295 }
296 for (auto iter : g_info) {
297 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, -1, SENSOR_POLL_TIME);
298 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
299 }
300 }
301
302 /**
303 * @tc.name: SetSensorMode0001
304 * @tc.desc: Sets the data reporting mode for the specified sensor.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(HdfSensorHdiTest, SetSensorMode0001, TestSize.Level1)
308 {
309 if (g_sensorInterface == nullptr) {
310 ASSERT_NE(nullptr, g_sensorInterface);
311 return;
312 }
313 EXPECT_GT(g_info.size(), 0);
314 for (auto iter : g_info) {
315 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
316 EXPECT_EQ(SENSOR_SUCCESS, ret);
317 if (iter.sensorId == SENSOR_TYPE_HALL) {
318 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_ON_CHANGE);
319 EXPECT_EQ(SENSOR_SUCCESS, ret);
320 } else {
321 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_REALTIME);
322 EXPECT_EQ(SENSOR_SUCCESS, ret);
323 }
324 ret = g_sensorInterface->Enable(iter.sensorId);
325 EXPECT_EQ(SENSOR_SUCCESS, ret);
326 OsalMSleep(SENSOR_WAIT_TIME);
327 ret = g_sensorInterface->Disable(iter.sensorId);
328 EXPECT_EQ(SENSOR_SUCCESS, ret);
329 }
330 }
331
332 /**
333 * @tc.name: SetSensorMode0002
334 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
335 * Other values are invalid.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(HdfSensorHdiTest, SetSensorMode0002, TestSize.Level1)
339 {
340 if (g_sensorInterface == nullptr) {
341 ASSERT_NE(nullptr, g_sensorInterface);
342 return;
343 }
344 int32_t ret = g_sensorInterface->SetMode(ABNORMAL_SENSORID, SENSOR_MODE_REALTIME);
345 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
346 }
347
348 /**
349 * @tc.name: SetSensorMode0003
350 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
351 * Other values are invalid.
352 * @tc.type: FUNC
353 */
354 HWTEST_F(HdfSensorHdiTest, SetSensorMode0003, TestSize.Level1)
355 {
356 if (g_sensorInterface == nullptr) {
357 ASSERT_NE(nullptr, g_sensorInterface);
358 return;
359 }
360 EXPECT_GT(g_info.size(), 0);
361 for (auto iter : g_info) {
362 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
363 EXPECT_EQ(SENSOR_SUCCESS, ret);
364 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_DEFAULT);
365 EXPECT_EQ(SENSOR_FAILURE, ret);
366 ret = g_sensorInterface->Enable(iter.sensorId);
367 EXPECT_EQ(SENSOR_SUCCESS, ret);
368 OsalMSleep(SENSOR_WAIT_TIME);
369 ret = g_sensorInterface->Disable(iter.sensorId);
370 EXPECT_EQ(SENSOR_SUCCESS, ret);
371 }
372 }
373
374 /**
375 * @tc.name: SetSensorOption0001
376 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
377 * @tc.type: FUNC
378 */
379 HWTEST_F(HdfSensorHdiTest, SetSensorOption0001, TestSize.Level1)
380 {
381 if (g_sensorInterface == nullptr) {
382 ASSERT_NE(nullptr, g_sensorInterface);
383 return;
384 }
385 EXPECT_GT(g_info.size(), 0);
386 for (auto iter : g_info) {
387 int32_t ret = g_sensorInterface->SetOption(iter.sensorId, 0);
388 EXPECT_EQ(SENSOR_SUCCESS, ret);
389 }
390 }
391
392 /**
393 * @tc.name: SetSensorOption0002
394 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
395 * @tc.type: FUNC
396 */
397 HWTEST_F(HdfSensorHdiTest, SetSensorOption0002, TestSize.Level1)
398 {
399 if (g_sensorInterface == nullptr) {
400 ASSERT_NE(nullptr, g_sensorInterface);
401 return;
402 }
403 int32_t ret = g_sensorInterface->SetOption(ABNORMAL_SENSORID, 0);
404 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
405 }
406