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