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_mem.h"
23 #include "osal_time.h"
24 #include "sensor_if.h"
25 #include "sensor_type.h"
26
27 using namespace testing::ext;
28
29 namespace {
30 struct SensorValueRange {
31 float highThreshold;
32 float lowThreshold;
33 };
34
35 struct SensorDevelopmentList {
36 int32_t sensorTypeId;
37 char sensorName[SENSOR_NAME_MAX_LEN];
38 int32_t dataForm; // 0: fixed, 1: range
39 int32_t dataDimension;
40 struct SensorValueRange *valueRange;
41 };
42
43 struct SensorValueRange g_testRange[] = {{1e5, 0.0}};
44 struct SensorValueRange g_accelRange[] = {{78.0, -78.0}, {78.0, -78.0}, {78.0, -78.0}};
45 struct SensorValueRange g_alsRange[] = {{10000000, 0}};
46 struct SensorValueRange g_pedometerRange[] = {{10000.0, 0.0}};
47 struct SensorValueRange g_proximityRange[] = {{5.0, 0.0}};
48 struct SensorValueRange g_hallRange[] = {{2.0, 0.0}};
49 struct SensorValueRange g_barometerRange[] = {{1100.0, -1100.0}, {1100.0, -1100.0}};
50 struct SensorValueRange g_magneticRange[] = {{2000.0, -2000.0}, {2000.0, -2000.0}, {2000.0, -2000.0}};
51 struct SensorValueRange g_gyroscopeRange[] = {{35.0, -35.0}, {35.0, -35.0}, {35.0, -35.0}};
52 struct SensorValueRange g_gravityRange[] = {{78.0, -78.0}, {78.0, -78.0}, {78.0, -78.0}};
53
54 struct SensorDevelopmentList g_sensorList[] = {
55 {SENSOR_TYPE_NONE, "sensor_test", 1, 1, g_testRange},
56 {SENSOR_TYPE_ACCELEROMETER, "accelerometer", 1, 3, g_accelRange},
57 {SENSOR_TYPE_PEDOMETER, "pedometer", 1, 1, g_pedometerRange},
58 {SENSOR_TYPE_PROXIMITY, "proximity", 0, 1, g_proximityRange},
59 {SENSOR_TYPE_HALL, "hallrometer", 1, 1, g_hallRange},
60 {SENSOR_TYPE_BAROMETER, "barometer", 1, 2, g_barometerRange},
61 {SENSOR_TYPE_AMBIENT_LIGHT, "als", 1, 1, g_alsRange},
62 {SENSOR_TYPE_MAGNETIC_FIELD, "magnetometer", 1, 3, g_magneticRange},
63 {SENSOR_TYPE_GYROSCOPE, "gyroscope", 1, 3, g_gyroscopeRange},
64 {SENSOR_TYPE_GRAVITY, "gravity", 1, 3, g_gravityRange}
65 };
66
67 constexpr int32_t g_listNum = sizeof(g_sensorList) / sizeof(g_sensorList[0]);
68 uint32_t g_sensorDataFlag = 1;
69 constexpr int32_t SENSOR_INTERVAL1 = 200000000;
70 constexpr int32_t SENSOR_INTERVAL2 = 20000000;
71 constexpr int32_t SENSOR_POLL_TIME = 1;
72 constexpr int32_t SENSOR_WAIT_TIME = 100;
73 constexpr float EPSINON = 1e-6;
74 constexpr int32_t ABNORMAL_SENSORID = -1;
75 const struct SensorInterface *g_sensorDev = nullptr;
76 int32_t g_count = 0;
77 struct SensorInformation *g_sensorInfo = nullptr;
78 struct SensorEvents *g_sensorEvents = nullptr;
79 constexpr uint32_t SENSOR_DATA_LEN = 100;
80
SensorDataVerification(const float & data,const struct SensorDevelopmentList & sensorNode)81 void SensorDataVerification(const float &data, const struct SensorDevelopmentList &sensorNode)
82 {
83 for (int32_t j = 0; j < sensorNode.dataDimension; ++j) {
84 printf("sensor id :[%d], data[%d]: %f\n\r", sensorNode.sensorTypeId, j + 1, *(&data + j));
85 if (sensorNode.dataForm == 0) {
86 if (std::abs(*(&data + j) - sensorNode.valueRange[j].highThreshold) < EPSINON ||
87 std::abs(*(&data + j) - sensorNode.valueRange[j].lowThreshold) < EPSINON) {
88 g_sensorDataFlag &= 1;
89 } else {
90 g_sensorDataFlag = 0;
91 printf("%s: %s Not expected\n\r", __func__, sensorNode.sensorName);
92 }
93 }
94
95 if (sensorNode.dataForm == 1) {
96 if (*(&data + j) > sensorNode.valueRange[j].lowThreshold &&
97 *(&data + j) < sensorNode.valueRange[j].highThreshold) {
98 g_sensorDataFlag &= 1;
99 } else {
100 g_sensorDataFlag = 0;
101 printf("%s: %s Not expected\n\r", __func__, sensorNode.sensorName);
102 }
103 }
104 }
105 }
106
TraditionalSensorTestDataCallback(const struct SensorEvents * event)107 int32_t TraditionalSensorTestDataCallback(const struct SensorEvents *event)
108 {
109 if (event == nullptr || event->data == nullptr) {
110 return SENSOR_FAILURE;
111 }
112
113 for (int32_t i = 0; i < g_listNum; ++i) {
114 if (event->sensorId == g_sensorList[i].sensorTypeId) {
115 float *data = reinterpret_cast<float*>(event->data);
116 SensorDataVerification(*data, g_sensorList[i]);
117 }
118 }
119 return SENSOR_SUCCESS;
120 }
121
MedicalSensorTestDataCallback(const struct SensorEvents * event)122 int32_t MedicalSensorTestDataCallback(const struct SensorEvents *event)
123 {
124 (void)event;
125
126 return SENSOR_SUCCESS;
127 }
128 }
129
130 class HdfSensorTest : public testing::Test {
131 public:
132 static void SetUpTestCase();
133 static void TearDownTestCase();
134 void SetUp();
135 void TearDown();
136 };
137
SetUpTestCase()138 void HdfSensorTest::SetUpTestCase()
139 {
140 g_sensorDev = NewSensorInterfaceInstance();
141 if (g_sensorDev == nullptr) {
142 printf("test sensorHdi get Module instance failed\n\r");
143 return;
144 }
145 int32_t ret = g_sensorDev->GetAllSensors(&g_sensorInfo, &g_count);
146 if (ret == SENSOR_FAILURE) {
147 printf("get sensor information failed\n\r");
148 }
149 }
150
TearDownTestCase()151 void HdfSensorTest::TearDownTestCase()
152 {
153 if (g_sensorDev != nullptr) {
154 FreeSensorInterfaceInstance();
155 g_sensorDev = nullptr;
156 }
157 }
158
SetUp()159 void HdfSensorTest::SetUp()
160 {
161 }
162
TearDown()163 void HdfSensorTest::TearDown()
164 {
165 }
166
167 /**
168 * @tc.name: GetSensorInstance001
169 * @tc.desc: Create a sensor instance and check whether the instance is empty.
170 * @tc.type: FUNC
171 * @tc.require: SR000F869M, AR000F869N, AR000F8QNL
172 */
173 HWTEST_F(HdfSensorTest, GetSensorInstance001, TestSize.Level1)
174 {
175 ASSERT_NE(nullptr, g_sensorDev);
176
177 const struct SensorInterface *sensorDev = NewSensorInterfaceInstance();
178 EXPECT_EQ(sensorDev, g_sensorDev);
179 }
180
181 /**
182 * @tc.name: RemoveSensorInstance001
183 * @tc.desc: The sensor instance is successfully removed.
184 * @tc.type: FUNC
185 * @tc.require: SR000F869M, AR000F869O, AR000F8QNL
186 */
187 HWTEST_F(HdfSensorTest, RemoveSensorInstance001, TestSize.Level1)
188 {
189 int32_t ret = FreeSensorInterfaceInstance();
190 ASSERT_EQ(SENSOR_SUCCESS, ret);
191 g_sensorDev = NewSensorInterfaceInstance();
192 ASSERT_NE(nullptr, g_sensorDev);
193 ret = g_sensorDev->GetAllSensors(&g_sensorInfo, &g_count);
194 EXPECT_EQ(SENSOR_SUCCESS, ret);
195 }
196
197 /**
198 * @tc.name: RegisterSensorDataCb001
199 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
200 * @tc.type: FUNC
201 * @tc.require: SR000F869M, AR000F869P, AR000F8QNL
202 */
203 HWTEST_F(HdfSensorTest, RegisterSensorDataCb001, TestSize.Level1)
204 {
205 ASSERT_NE(nullptr, g_sensorDev);
206
207 int32_t ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
208 EXPECT_EQ(SENSOR_SUCCESS, ret);
209 ret = g_sensorDev->Unregister(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
210 EXPECT_EQ(SENSOR_SUCCESS, ret);
211 }
212
213 /**
214 * @tc.name: RegisterSensorDataCb002
215 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
216 * @tc.type: FUNC
217 * @tc.require: SR000F869M, AR000F869P
218 */
219 HWTEST_F(HdfSensorTest, RegisterSensorDataCb002, TestSize.Level1)
220 {
221 ASSERT_NE(nullptr, g_sensorDev);
222
223 int32_t ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, nullptr);
224 EXPECT_EQ(SENSOR_NULL_PTR, ret);
225 ret = g_sensorDev->Unregister(0, nullptr);
226 EXPECT_EQ(SENSOR_NULL_PTR, ret);
227 }
228
229 /**
230 * @tc.name: RegisterSensorDataCb003
231 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
232 * @tc.type: FUNC
233 * @tc.require: SR000F869M, AR000F869P, AR000F8QNL
234 */
235 HWTEST_F(HdfSensorTest, RegisterSensorDataCb003, TestSize.Level1)
236 {
237 ASSERT_NE(nullptr, g_sensorDev);
238
239 int32_t ret = g_sensorDev->Register(MEDICAL_SENSOR_TYPE, MedicalSensorTestDataCallback);
240 EXPECT_EQ(SENSOR_SUCCESS, ret);
241 ret = g_sensorDev->Unregister(MEDICAL_SENSOR_TYPE, MedicalSensorTestDataCallback);
242 EXPECT_EQ(SENSOR_SUCCESS, ret);
243 }
244
245 /**
246 * @tc.name: RegisterSensorDataCb004
247 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
248 * @tc.type: FUNC
249 * @tc.require: SR000F869M, AR000F869P
250 */
251 HWTEST_F(HdfSensorTest, RegisterSensorDataCb004, TestSize.Level1)
252 {
253 ASSERT_NE(nullptr, g_sensorDev);
254
255 int32_t ret = g_sensorDev->Register(MEDICAL_SENSOR_TYPE, nullptr);
256 EXPECT_EQ(SENSOR_NULL_PTR, ret);
257 ret = g_sensorDev->Unregister(MEDICAL_SENSOR_TYPE, nullptr);
258 EXPECT_EQ(SENSOR_NULL_PTR, ret);
259 }
260
261 /**
262 * @tc.name: RegisterSensorDataCb005
263 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
264 * @tc.type: FUNC
265 * @tc.require: SR000F869M, AR000F869P
266 */
267 HWTEST_F(HdfSensorTest, RegisterSensorDataCb005, TestSize.Level1)
268 {
269 ASSERT_NE(nullptr, g_sensorDev);
270
271 int32_t ret = g_sensorDev->Register(SENSOR_TYPE_MAX, nullptr);
272 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
273 ret = g_sensorDev->Unregister(SENSOR_TYPE_MAX, nullptr);
274 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
275 }
276
277 /**
278 * @tc.name: GetSensorList001
279 * @tc.desc: Obtains information about all sensors in the system. Validity check of input parameters.
280 * @tc.type: FUNC
281 * @tc.require: SR000F869M, AR000F869Q
282 */
283 HWTEST_F(HdfSensorTest, GetSensorList001, TestSize.Level1)
284 {
285 ASSERT_NE(nullptr, g_sensorInfo);
286 EXPECT_GT(g_count, 0);
287 }
288
289 /**
290 * @tc.name: GetSensorList002
291 * @tc.desc: Obtains information about all sensors in the system. Validity check of input parameters.
292 * @tc.type: FUNC
293 * @tc.require: SR000F869M, AR000F869Q
294 */
295 HWTEST_F(HdfSensorTest, GetSensorList002, TestSize.Level1)
296 {
297 struct SensorInformation *info = nullptr;
298 int32_t j;
299
300 ASSERT_NE(nullptr, g_sensorInfo);
301 EXPECT_GT(g_count, 0);
302 printf("get sensor list num[%d]\n\r", g_count);
303
304 info = g_sensorInfo;
305 for (int32_t i = 0; i < g_count; ++i) {
306 printf("get sensoriId[%d], info name[%s], power[%f]\n\r", info->sensorId, info->sensorName, info->power);
307 for (j = 0; j < g_listNum; ++j) {
308 if (info->sensorId == g_sensorList[j].sensorTypeId) {
309 EXPECT_STRNE("", info->sensorName);
310 break;
311 }
312 }
313 info++;
314 }
315 }
316
317 /**
318 * @tc.name: GetSensorList003
319 * @tc.desc: Obtains information about all sensors in the system. The operations include obtaining sensor information,
320 * subscribing to or unsubscribing from sensor data, enabling or disabling a sensor,
321 * setting the sensor data reporting mode, and setting sensor options such as the accuracy and measurement range.
322 * @tc.type: FUNC
323 * @tc.require: SR000F869M, AR000F869Q
324 */
325 HWTEST_F(HdfSensorTest, GetSensorList003, TestSize.Level1)
326 {
327 ASSERT_NE(nullptr, g_sensorDev);
328
329 int32_t ret = g_sensorDev->GetAllSensors(nullptr, &g_count);
330 EXPECT_EQ(SENSOR_NULL_PTR, ret);
331 ret = g_sensorDev->GetAllSensors(&g_sensorInfo, nullptr);
332 EXPECT_EQ(SENSOR_NULL_PTR, ret);
333 ret = g_sensorDev->GetAllSensors(nullptr, nullptr);
334 EXPECT_EQ(SENSOR_NULL_PTR, ret);
335 }
336
337 /**
338 * @tc.name: EnableSensor001
339 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
340 * @tc.type: FUNC
341 * @tc.require: SR000F869M, AR000F869R, AR000F8QNL
342 */
343 HWTEST_F(HdfSensorTest, EnableSensor001, TestSize.Level1)
344 {
345 ASSERT_NE(nullptr, g_sensorDev);
346
347 int32_t ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
348 EXPECT_EQ(SENSOR_SUCCESS, ret);
349
350 struct SensorInformation *info = nullptr;
351
352 ASSERT_NE(nullptr, g_sensorInfo);
353 info = g_sensorInfo;
354 for (int32_t i = 0; i < g_count; i++) {
355 ret = g_sensorDev->SetBatch(info->sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
356 EXPECT_EQ(SENSOR_SUCCESS, ret);
357 ret = g_sensorDev->Enable(info->sensorId);
358 EXPECT_EQ(SENSOR_SUCCESS, ret);
359 OsalSleep(SENSOR_POLL_TIME);
360 ret = g_sensorDev->Disable(info->sensorId);
361 EXPECT_EQ(SENSOR_SUCCESS, ret);
362 info++;
363 }
364
365 ret = g_sensorDev->Unregister(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
366 EXPECT_EQ(SENSOR_SUCCESS, ret);
367
368 EXPECT_EQ(g_sensorDataFlag, 1);
369 g_sensorDataFlag = 1;
370 }
371
372 /**
373 * @tc.name: EnableSensor002
374 * @tc.desc: Enables the sensor available in the sensor list based on the specified sensor ID.
375 * @tc.type: FUNC
376 * @tc.require: SR000F869M, AR000F869R
377 */
378 HWTEST_F(HdfSensorTest, EnableSensor002, TestSize.Level1)
379 {
380 ASSERT_NE(nullptr, g_sensorDev);
381 ASSERT_NE(nullptr, g_sensorInfo);
382
383 int32_t ret = g_sensorDev->Enable(ABNORMAL_SENSORID);
384 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
385 ret = g_sensorDev->Disable(ABNORMAL_SENSORID);
386 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
387 }
388
389 /**
390 * @tc.name: SetSensorBatch001
391 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
392 * @tc.type: FUNC
393 * @tc.require: SR000F869M, AR000F869T
394 */
395 HWTEST_F(HdfSensorTest, SetSensorBatch001, TestSize.Level1)
396 {
397 ASSERT_NE(nullptr, g_sensorDev);
398
399 struct SensorInformation *info = nullptr;
400
401 int32_t ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
402 EXPECT_EQ(SENSOR_SUCCESS, ret);
403
404 ASSERT_NE(nullptr, g_sensorInfo);
405 info = g_sensorInfo;
406 for (int32_t i = 0; i < g_count; i++) {
407 ret = g_sensorDev->SetBatch(info->sensorId, SENSOR_INTERVAL2, SENSOR_POLL_TIME);
408 EXPECT_EQ(SENSOR_SUCCESS, ret);
409 ret = g_sensorDev->Enable(info->sensorId);
410 EXPECT_EQ(SENSOR_SUCCESS, ret);
411 OsalMSleep(SENSOR_WAIT_TIME);
412 ret = g_sensorDev->Disable(info->sensorId);
413 EXPECT_EQ(SENSOR_SUCCESS, ret);
414 info++;
415 }
416
417 ret = g_sensorDev->Unregister(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
418 EXPECT_EQ(SENSOR_SUCCESS, ret);
419 EXPECT_EQ(g_sensorDataFlag, 1);
420 g_sensorDataFlag = 1;
421 }
422
423 /** @tc.name: SetSensorBatch002
424 @tc.desc: Sets the sampling time and data report interval for sensors in batches.
425 @tc.type: FUNC
426 @tc.requrire: SR000F869M, AR000F869U
427 */
428 HWTEST_F(HdfSensorTest, SetSensorBatch002, TestSize.Level1)
429 {
430 ASSERT_NE(nullptr, g_sensorDev);
431
432 int32_t ret = g_sensorDev->SetBatch(ABNORMAL_SENSORID, 0, 0);
433 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
434 }
435
436 /** @tc.name: SetSensorBatch003
437 @tc.desc: Sets the sampling time and data report interval for sensors in batches.
438 @tc.type: FUNC
439 @tc.requrire: SR000F869M, AR000F869U
440 */
441 HWTEST_F(HdfSensorTest, SetSensorBatch003, TestSize.Level1)
442 {
443 ASSERT_NE(nullptr, g_sensorDev);
444
445 struct SensorInformation *info = nullptr;
446
447 ASSERT_NE(nullptr, g_sensorInfo);
448 info = g_sensorInfo;
449 for (int32_t i = 0; i < g_count; i++) {
450 int32_t ret = g_sensorDev->SetBatch(info->sensorId, -1, SENSOR_POLL_TIME);
451 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
452 info++;
453 }
454 }
455 /**
456 * @tc.name: SetSensorMode001
457 * @tc.desc: Sets the data reporting mode for the specified sensor.
458 * @tc.type: FUNC
459 * @tc.require: SR000F869M, AR000F869U, AR000F8QNL
460 */
461 HWTEST_F(HdfSensorTest, SetSensorMode001, TestSize.Level1)
462 {
463 ASSERT_NE(nullptr, g_sensorDev);
464
465 struct SensorInformation *info = nullptr;
466
467 int32_t ret = g_sensorDev->Register(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
468 EXPECT_EQ(SENSOR_SUCCESS, ret);
469
470 ASSERT_NE(nullptr, g_sensorInfo);
471 info = g_sensorInfo;
472 for (int32_t i = 0; i < g_count; i++) {
473 ret = g_sensorDev->SetBatch(info->sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
474 EXPECT_EQ(SENSOR_SUCCESS, ret);
475 if (info->sensorId == SENSOR_TYPE_HALL) {
476 ret = g_sensorDev->SetMode(info->sensorId, SENSOR_MODE_ON_CHANGE);
477 EXPECT_EQ(SENSOR_SUCCESS, ret);
478 } else {
479 ret = g_sensorDev->SetMode(info->sensorId, SENSOR_MODE_REALTIME);
480 EXPECT_EQ(SENSOR_SUCCESS, ret);
481 }
482
483 ret = g_sensorDev->Enable(info->sensorId);
484 EXPECT_EQ(SENSOR_SUCCESS, ret);
485 OsalMSleep(SENSOR_WAIT_TIME);
486 ret = g_sensorDev->Disable(info->sensorId);
487 EXPECT_EQ(SENSOR_SUCCESS, ret);
488 info++;
489 }
490
491 ret = g_sensorDev->Unregister(TRADITIONAL_SENSOR_TYPE, TraditionalSensorTestDataCallback);
492 EXPECT_EQ(SENSOR_SUCCESS, ret);
493 EXPECT_EQ(1, g_sensorDataFlag);
494 g_sensorDataFlag = 1;
495 }
496
497 /**
498 * @tc.name: SetSensorMode002
499 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
500 * Other values are invalid.
501 * @tc.type: FUNC
502 * @tc.require: SR000F869M, AR000F869U
503 */
504 HWTEST_F(HdfSensorTest, SetSensorMode002, TestSize.Level1)
505 {
506 ASSERT_NE(nullptr, g_sensorDev);
507
508 int32_t ret = g_sensorDev->SetBatch(ABNORMAL_SENSORID, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
509 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
510 }
511
512 /**
513 * @tc.name: SetSensorMode002
514 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
515 * Other values are invalid.
516 * @tc.type: FUNC
517 * @tc.require: SR000F869M, AR000F869U
518 */
519 HWTEST_F(HdfSensorTest, SetSensorMode003, TestSize.Level1)
520 {
521 ASSERT_NE(nullptr, g_sensorDev);
522
523 struct SensorInformation *info = nullptr;
524
525 ASSERT_NE(nullptr, g_sensorInfo);
526 info = g_sensorInfo;
527 for (int32_t i = 0; i < g_count; i++) {
528 int32_t ret = g_sensorDev->SetBatch(info->sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
529 EXPECT_EQ(SENSOR_SUCCESS, ret);
530 ret = g_sensorDev->SetMode(info->sensorId, SENSOR_MODE_DEFAULT);
531 EXPECT_EQ(SENSOR_FAILURE, ret);
532 ret = g_sensorDev->Enable(info->sensorId);
533 EXPECT_EQ(SENSOR_SUCCESS, ret);
534 OsalMSleep(SENSOR_WAIT_TIME);
535 ret = g_sensorDev->Disable(info->sensorId);
536 EXPECT_EQ(SENSOR_SUCCESS, ret);
537 info++;
538 }
539 }
540
541 /**
542 * @tc.name: SetSensorOption001
543 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
544 * @tc.type: FUNC
545 * @tc.require: SR000F869M, AR000F869U
546 */
547 HWTEST_F(HdfSensorTest, SetSensorOption001, TestSize.Level1)
548 {
549 ASSERT_NE(nullptr, g_sensorDev);
550
551 struct SensorInformation *info = nullptr;
552
553 ASSERT_NE(nullptr, g_sensorInfo);
554 info = g_sensorInfo;
555 for (int32_t i = 0; i < g_count; i++) {
556 int32_t ret = g_sensorDev->SetOption(info->sensorId, 0);
557 EXPECT_EQ(SENSOR_SUCCESS, ret);
558 info++;
559 }
560 }
561
562 /**
563 * @tc.name: SetSensorOption001
564 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
565 * @tc.type: FUNC
566 * @tc.require: SR000F869M, AR000F869U
567 */
568 HWTEST_F(HdfSensorTest, SetSensorOption002, TestSize.Level1)
569 {
570 ASSERT_NE(nullptr, g_sensorDev);
571
572 int32_t ret = g_sensorDev->SetOption(ABNORMAL_SENSORID, 0);
573 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
574 }
575
576 /**
577 * @tc.name: ReadSensorData001
578 * @tc.desc: Read event data for the specified sensor.
579 * @tc.type: FUNC
580 * @tc.require: AR000HQ6N4
581 */
582 HWTEST_F(HdfSensorTest, ReadSensorData001, TestSize.Level1)
583 {
584 ASSERT_NE(nullptr, g_sensorDev);
585
586 g_sensorEvents = (struct SensorEvents*)OsalMemCalloc(sizeof(*g_sensorEvents));
587 ASSERT_NE(nullptr, g_sensorEvents);
588 g_sensorEvents->data = (uint8_t *)OsalMemCalloc(SENSOR_DATA_LEN);
589 ASSERT_NE(nullptr, g_sensorEvents->data);
590 g_sensorEvents->dataLen = SENSOR_DATA_LEN;
591
592 int32_t ret = g_sensorDev->Enable(SENSOR_TYPE_AMBIENT_LIGHT);
593 EXPECT_EQ(SENSOR_SUCCESS, ret);
594 ret = g_sensorDev->ReadData(SENSOR_TYPE_AMBIENT_LIGHT, g_sensorEvents);
595 EXPECT_EQ(SENSOR_SUCCESS, ret);
596
597 printf("sensorId[%d], mode[%d], option[%u]\n\r",
598 g_sensorEvents->sensorId, g_sensorEvents->mode, g_sensorEvents->option);
599 for (int32_t i = 0; i < g_listNum; i++) {
600 if (g_sensorEvents->sensorId == g_sensorList[i].sensorTypeId) {
601 float *data = reinterpret_cast<float*>(g_sensorEvents->data);
602 SensorDataVerification(*data, g_sensorList[i]);
603 }
604 }
605
606 ret = g_sensorDev->Disable(SENSOR_TYPE_AMBIENT_LIGHT);
607 EXPECT_EQ(SENSOR_SUCCESS, ret);
608
609 OsalMemFree(g_sensorEvents->data);
610 OsalMemFree(g_sensorEvents);
611 }
612
613 /**
614 * @tc.name: ReadSensorData002
615 * @tc.desc: Read event data for the specified sensor.
616 * @tc.type: FUNC
617 * @tc.require: AR000HQ6N4
618 */
619 HWTEST_F(HdfSensorTest, ReadSensorData002, TestSize.Level1)
620 {
621 ASSERT_NE(nullptr, g_sensorDev);
622
623 int32_t ret = g_sensorDev->ReadData(SENSOR_TYPE_AMBIENT_LIGHT, nullptr);
624 EXPECT_EQ(SENSOR_NULL_PTR, ret);
625 }
626
627 /**
628 * @tc.name: ReadSensorData003
629 * @tc.desc: Read event data for the specified sensor.
630 * @tc.type: FUNC
631 * @tc.require: AR000HQ6N4
632 */
633 HWTEST_F(HdfSensorTest, ReadSensorData003, TestSize.Level1)
634 {
635 ASSERT_NE(nullptr, g_sensorDev);
636
637 g_sensorEvents = (struct SensorEvents*)OsalMemCalloc(sizeof(*g_sensorEvents));
638 ASSERT_NE(nullptr, g_sensorEvents);
639 g_sensorEvents->data = (uint8_t *)OsalMemCalloc(SENSOR_DATA_LEN);
640 ASSERT_NE(nullptr, g_sensorEvents->data);
641 g_sensorEvents->dataLen = SENSOR_DATA_LEN;
642
643 int32_t ret = g_sensorDev->ReadData(ABNORMAL_SENSORID, g_sensorEvents);
644 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
645
646 OsalMemFree(g_sensorEvents->data);
647 OsalMemFree(g_sensorEvents);
648 }
649