1 /*
2 * Copyright (c) 2021-2025 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 "v2_0/isensor_interface.h"
24 #include "sensor_type.h"
25 #include "sensor_callback_impl.h"
26 using namespace OHOS::HDI::Sensor::V2_0;
27 using namespace testing::ext;
28
29 namespace {
30 sptr<ISensorInterface> g_sensorInterface = nullptr;
31 sptr<ISensorCallback> g_traditionalCallback = new SensorCallbackImpl();
32 sptr<ISensorCallback> g_medicalCallback = new SensorCallbackImpl();
33 std::vector<HdfSensorInformation> g_info;
34 std::vector<HdfSensorEvents> g_events;
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[] = {{10000000, 0}};
51 struct SensorValueRange g_pedometerRange[] = {{10000, 0}};
52 struct SensorValueRange g_proximityRange[] = {{5, 0}};
53 struct SensorValueRange g_hallRange[] = {{4294967295, 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 struct SensorValueRange g_humidityRange[] = {{100, 0}};
59 struct SensorValueRange g_temperatureRange[] = {{125, -40}};
60
61 struct SensorDevelopmentList g_sensorList[] = {
62 {SENSOR_TYPE_NONE, "sensor_test", 1, 1, g_testRange},
63 {SENSOR_TYPE_ACCELEROMETER, "accelerometer", 1, 3, g_accelRange},
64 {SENSOR_TYPE_PEDOMETER, "pedometer", 1, 1, g_pedometerRange},
65 {SENSOR_TYPE_PROXIMITY, "proximity", 0, 1, g_proximityRange},
66 {SENSOR_TYPE_HALL, "hallrometer", 1, 1, g_hallRange},
67 {SENSOR_TYPE_BAROMETER, "barometer", 1, 2, g_barometerRange},
68 {SENSOR_TYPE_AMBIENT_LIGHT, "als", 1, 1, g_alsRange},
69 {SENSOR_TYPE_MAGNETIC_FIELD, "magnetometer", 1, 3, g_magneticRange},
70 {SENSOR_TYPE_GYROSCOPE, "gyroscope", 1, 3, g_gyroscopeRange},
71 {SENSOR_TYPE_GRAVITY, "gravity", 1, 3, g_gravityRange},
72 {SENSOR_TYPE_HUMIDITY, "humidity", 1, 1, g_humidityRange},
73 {SENSOR_TYPE_TEMPERATURE, "tenperature", 1, 1, g_temperatureRange}
74 };
75
IsSuppprtedSensorId(int32_t sensorTypeId)76 int32_t IsSuppprtedSensorId(int32_t sensorTypeId)
77 {
78 EXPECT_GT(g_info.size(),0);
79 for (auto iter : g_info){
80 if (iter.sensorId == sensorTypeId)
81 {
82 return SENSOR_SUCCESS;
83 }
84 }
85 return SENSOR_NOT_SUPPORT;
86 }
87
88 constexpr int g_listNum = sizeof(g_sensorList) / sizeof(g_sensorList[0]);
89 constexpr int64_t SENSOR_INTERVAL1 = 200000000;
90 constexpr int64_t SENSOR_INTERVAL2 = 20000000;
91 constexpr int64_t SENSOR_INTERVAL3 = 40000000;
92 constexpr int64_t SENSOR_INTERVAL4 = 20000000;
93 constexpr int32_t SENSOR_POLL_TIME = 1;
94 constexpr int32_t SENSOR_WAIT_TIME = 100;
95 constexpr int32_t SENSOR_WAIT_TIME2 = 20000;
96 constexpr int32_t SENSOR_WAIT_TIME3 = 2000;
97 constexpr int32_t ABNORMAL_SENSORID = -1;
98 constexpr int32_t RATE_LEVEL = 50;
99 }
100
101 class HdfSensorHdiTest : public testing::Test {
102 public:
103 static void SetUpTestCase();
104 static void TearDownTestCase();
105 void SetUp();
106 void TearDown();
107 };
108
SetUpTestCase()109 void HdfSensorHdiTest::SetUpTestCase()
110 {
111 OsalMSleep(SENSOR_WAIT_TIME3);
112 g_sensorInterface = ISensorInterface::Get();
113 if (g_sensorInterface == nullptr) {
114 g_sensorInterface->GetAllSensorInfo(g_info);
115 }
116 }
117
TearDownTestCase()118 void HdfSensorHdiTest::TearDownTestCase()
119 {
120 }
121
SetUp()122 void HdfSensorHdiTest::SetUp()
123 {
124 if (g_sensorInterface == nullptr) {
125 printf("Sensor list is empty");
126 GTEST_SKIP() << "Device not exist" << std::endl;
127 return;
128 }
129 }
130
TearDown()131 void HdfSensorHdiTest::TearDown()
132 {
133 }
134
135 /**
136 * @tc.name: GetSensorClient0001
137 * @tc.desc: Get a client and check whether the client is empty.
138 * @tc.type: FUNC
139 */
140 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0100, TestSize.Level1)
141 {
142 ASSERT_NE(nullptr, g_sensorInterface);
143 }
144
145 /**
146 * @tc.name: GetSensorList0001
147 * @tc.desc: Obtains information about all sensors in the system.
148 * @tc.type: FUNC
149 */
150 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0200, TestSize.Level1)
151 {
152 if (g_sensorInterface == nullptr) {
153 ASSERT_NE(nullptr, g_sensorInterface);
154 return;
155 }
156 int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info);
157 EXPECT_EQ(SENSOR_SUCCESS, ret);
158 EXPECT_GT(g_info.size(), 0);
159 printf("get sensor list num[%zu]\n\r", g_info.size());
160
161 for (auto iter : g_info) {
162 printf("get sensoriId[%d], info name[%s], power[%f]\n\r", iter.sensorId, iter.sensorName.c_str(), iter.power);
163 for (int j =0; j < g_listNum; ++j) {
164 if (iter.sensorId == g_sensorList[j].sensorTypeId) {
165 EXPECT_GT(iter.sensorName.size(), 0);
166 break;
167 }
168 }
169 }
170 }
171
172 /**
173 * @tc.name: RegisterSensorDataCb0001
174 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0300, TestSize.Level1)
178 {
179 if (g_sensorInterface == nullptr) {
180 ASSERT_NE(nullptr, g_sensorInterface);
181 return;
182 }
183 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
184 EXPECT_EQ(SENSOR_SUCCESS, ret);
185 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
186 EXPECT_EQ(SENSOR_SUCCESS, ret);
187 }
188
189 /**
190 * @tc.name: RegisterSensorDataCb0002
191 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
192 * @tc.type: FUNC
193 */
194 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0400, TestSize.Level1)
195 {
196 if (g_sensorInterface == nullptr) {
197 ASSERT_NE(nullptr, g_sensorInterface);
198 return;
199 }
200 int32_t ret = g_sensorInterface->Register(MEDICAL_SENSOR_TYPE, g_medicalCallback);
201 EXPECT_EQ(SENSOR_SUCCESS, ret);
202 ret = g_sensorInterface->Unregister(MEDICAL_SENSOR_TYPE, g_medicalCallback);
203 EXPECT_EQ(SENSOR_SUCCESS, ret);
204 }
205
206 /**
207 * @tc.name: RegisterDataCb001
208 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0500, TestSize.Level1)
212 {
213 if (g_sensorInterface == nullptr) {
214 ASSERT_NE(nullptr, g_sensorInterface);
215 return;
216 }
217 int32_t ret = g_sensorInterface->Register(SENSOR_GROUP_TYPE_MAX, g_medicalCallback);
218 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
219 ret = g_sensorInterface->Unregister(SENSOR_GROUP_TYPE_MAX, g_medicalCallback);
220 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
221 }
222
223 /**
224 * @tc.name: EnableSensor0001
225 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
226 * @tc.type: FUNC
227 */
228 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0700, TestSize.Level1)
229 {
230 if (g_sensorInterface == nullptr) {
231 ASSERT_NE(nullptr, g_sensorInterface);
232 return;
233 }
234 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
235 EXPECT_EQ(SENSOR_SUCCESS, ret);
236
237 EXPECT_GT(g_info.size(), 0);
238
239 for (auto iter : g_info) {
240 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
241 EXPECT_EQ(SENSOR_SUCCESS, ret);
242 ret = g_sensorInterface->Enable(iter.sensorId);
243 EXPECT_EQ(SENSOR_SUCCESS, ret);
244 OsalSleep(SENSOR_POLL_TIME);
245 ret = g_sensorInterface->Disable(iter.sensorId);
246 EXPECT_EQ(SENSOR_SUCCESS, ret);
247 }
248 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
249 EXPECT_EQ(0, ret);
250 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
251 SensorCallbackImpl::sensorDataFlag = 1;
252 }
253
254 /**
255 * @tc.name: SetSensorBatch0001
256 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0800, TestSize.Level1)
260 {
261 if (g_sensorInterface == nullptr) {
262 ASSERT_NE(nullptr, g_sensorInterface);
263 return;
264 }
265 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
266 EXPECT_EQ(SENSOR_SUCCESS, ret);
267
268 for (auto iter : g_info) {
269 ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL2, SENSOR_POLL_TIME);
270 EXPECT_EQ(SENSOR_SUCCESS, ret);
271 ret = g_sensorInterface->Enable(iter.sensorId);
272 EXPECT_EQ(SENSOR_SUCCESS, ret);
273 OsalMSleep(SENSOR_WAIT_TIME3);
274 ret = g_sensorInterface->Disable(iter.sensorId);
275 EXPECT_EQ(SENSOR_SUCCESS, ret);
276 }
277
278 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
279 EXPECT_EQ(SENSOR_SUCCESS, ret);
280 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
281 SensorCallbackImpl::sensorDataFlag = 1;
282 }
283
284 /** @tc.name: SetSensorBatch0002
285 @tc.desc: Sets the sampling time and data report interval for sensors in batches.
286 @tc.type: FUNC
287 */
288 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_0900, TestSize.Level1)
289 {
290 if (g_sensorInterface == nullptr) {
291 ASSERT_NE(nullptr, g_sensorInterface);
292 return;
293 }
294 int32_t ret = g_sensorInterface->SetBatch(ABNORMAL_SENSORID, 0, 0);
295 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
296 }
297
298 /**
299 * @tc.name: SetSensorBatch0003
300 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1000, TestSize.Level1)
304 {
305 if (g_sensorInterface == nullptr) {
306 ASSERT_NE(nullptr, g_sensorInterface);
307 return;
308 }
309 for (auto iter : g_info) {
310 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, -1, SENSOR_POLL_TIME);
311 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
312 }
313 }
314
315 /**
316 * @tc.name: SetSensorBatch0004
317 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1100, TestSize.Level1)
321 {
322 if (g_sensorInterface == nullptr) {
323 ASSERT_NE(nullptr, g_sensorInterface);
324 return;
325 }
326 for (auto iter : g_info) {
327 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, -1, -1);
328 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
329 }
330 }
331
332 /**
333 * @tc.name: SetSensorBatch0005
334 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
335 * @tc.type: FUNC
336 */
337 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1200, TestSize.Level1)
338 {
339 if (g_sensorInterface == nullptr) {
340 ASSERT_NE(nullptr, g_sensorInterface);
341 return;
342 }
343 for (auto iter : g_info) {
344 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL2, -1);
345 EXPECT_EQ(SENSOR_INVALID_PARAM, ret);
346 }
347 }
348
349 /**
350 * @tc.name: SetSensorMode0001
351 * @tc.desc: Sets the data reporting mode for the specified sensor.
352 * @tc.type: FUNC
353 */
354 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1400, 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 if (iter.sensorId == SENSOR_TYPE_HALL) {
365 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_ON_CHANGE);
366 EXPECT_EQ(SENSOR_SUCCESS, ret);
367 } else {
368 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_REALTIME);
369 EXPECT_EQ(SENSOR_SUCCESS, ret);
370 }
371 ret = g_sensorInterface->Enable(iter.sensorId);
372 EXPECT_EQ(SENSOR_SUCCESS, ret);
373 OsalMSleep(SENSOR_WAIT_TIME3);
374 ret = g_sensorInterface->Disable(iter.sensorId);
375 EXPECT_EQ(SENSOR_SUCCESS, ret);
376 }
377 }
378
379 /**
380 * @tc.name: SetSensorMode0001
381 * @tc.desc: Sets the data reporting mode for the specified sensor.
382 * @tc.type: FUNC
383 */
384 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1500, TestSize.Level1)
385 {
386 if (g_sensorInterface == nullptr) {
387 ASSERT_NE(nullptr, g_sensorInterface);
388 return;
389 }
390 EXPECT_GT(g_info.size(), 0);
391 for (auto iter : g_info) {
392 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
393 EXPECT_EQ(SENSOR_SUCCESS, ret);
394 if (iter.sensorId == SENSOR_TYPE_HALL) {
395 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_ONE_SHOT);
396 EXPECT_EQ(SENSOR_SUCCESS, ret);
397 } else {
398 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_REALTIME);
399 EXPECT_EQ(SENSOR_SUCCESS, ret);
400 }
401 ret = g_sensorInterface->Enable(iter.sensorId);
402 EXPECT_EQ(SENSOR_SUCCESS, ret);
403 OsalMSleep(SENSOR_WAIT_TIME3);
404 ret = g_sensorInterface->Disable(iter.sensorId);
405 EXPECT_EQ(SENSOR_SUCCESS, ret);
406 }
407 }
408
409 /**
410 * @tc.name: SetSensorMode0001
411 * @tc.desc: Sets the data reporting mode for the specified sensor.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1600, TestSize.Level1)
415 {
416 if (g_sensorInterface == nullptr) {
417 ASSERT_NE(nullptr, g_sensorInterface);
418 return;
419 }
420 EXPECT_GT(g_info.size(), 0);
421 for (auto iter : g_info) {
422 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
423 EXPECT_EQ(SENSOR_SUCCESS, ret);
424 if (iter.sensorId == SENSOR_TYPE_HALL) {
425 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_FIFO_MODE);
426 EXPECT_EQ(SENSOR_SUCCESS, ret);
427 } else {
428 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_REALTIME);
429 EXPECT_EQ(SENSOR_SUCCESS, ret);
430 }
431 ret = g_sensorInterface->Enable(iter.sensorId);
432 EXPECT_EQ(SENSOR_SUCCESS, ret);
433 OsalMSleep(SENSOR_WAIT_TIME3);
434 ret = g_sensorInterface->Disable(iter.sensorId);
435 EXPECT_EQ(SENSOR_SUCCESS, ret);
436 }
437 }
438
439
440 /**
441 * @tc.name: SetSensorMode0002
442 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
443 * Other values are invalid.
444 * @tc.type: FUNC
445 */
446 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1700, TestSize.Level1)
447 {
448 if (g_sensorInterface == nullptr) {
449 ASSERT_NE(nullptr, g_sensorInterface);
450 return;
451 }
452 int32_t ret = g_sensorInterface->SetMode(ABNORMAL_SENSORID, SENSOR_MODE_REALTIME);
453 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
454 }
455
456 /**
457 * @tc.name: SetSensorMode0003
458 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid.
459 * Other values are invalid.
460 * @tc.type: FUNC
461 */
462 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1800, TestSize.Level1)
463 {
464 if (g_sensorInterface == nullptr) {
465 ASSERT_NE(nullptr, g_sensorInterface);
466 return;
467 }
468 EXPECT_GT(g_info.size(), 0);
469 for (auto iter : g_info) {
470 int32_t ret = g_sensorInterface->SetBatch(iter.sensorId, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
471 EXPECT_EQ(SENSOR_SUCCESS, ret);
472 ret = g_sensorInterface->SetMode(iter.sensorId, SENSOR_MODE_DEFAULT);
473 EXPECT_EQ(SENSOR_FAILURE, ret);
474 ret = g_sensorInterface->Enable(iter.sensorId);
475 EXPECT_EQ(SENSOR_SUCCESS, ret);
476 OsalMSleep(SENSOR_WAIT_TIME3);
477 ret = g_sensorInterface->Disable(iter.sensorId);
478 EXPECT_EQ(SENSOR_SUCCESS, ret);
479 }
480 }
481
482 /**
483 * @tc.name: SetSensorOption0001
484 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
485 * @tc.type: FUNC
486 */
487 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_1900, TestSize.Level1)
488 {
489 if (g_sensorInterface == nullptr) {
490 ASSERT_NE(nullptr, g_sensorInterface);
491 return;
492 }
493 EXPECT_GT(g_info.size(), 0);
494 for (auto iter : g_info) {
495 int32_t ret = g_sensorInterface->SetOption(iter.sensorId, 0);
496 EXPECT_EQ(SENSOR_SUCCESS, ret);
497 }
498 }
499
500 /**
501 * @tc.name: SetSensorOption0002
502 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2300, TestSize.Level1)
506 {
507 if (g_sensorInterface == nullptr) {
508 ASSERT_NE(nullptr, g_sensorInterface);
509 return;
510 }
511 int32_t ret = g_sensorInterface->SetOption(ABNORMAL_SENSORID, 0);
512 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret);
513 }
514
515 /**
516 * @tc.name: EnableSensor0002
517 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2400, TestSize.Level1)
521 {
522 if (g_sensorInterface == nullptr) {
523 ASSERT_NE(nullptr, g_sensorInterface);
524 return;
525 }
526
527 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_NONE);
528 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_NONE);
529 EXPECT_EQ(status,ret);
530 OsalMSleep(SENSOR_WAIT_TIME3);
531 ret = g_sensorInterface->Disable(SENSOR_TYPE_NONE);
532 EXPECT_EQ(status,ret);
533 }
534
535 /**
536 * @tc.name: EnableSensor0003
537 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2500, TestSize.Level1)
541 {
542 if (g_sensorInterface == nullptr) {
543 ASSERT_NE(nullptr, g_sensorInterface);
544 return;
545 }
546
547 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ACCELEROMETER);
548 int32_t ret = g_sensorInterface->SetBatch(SENSOR_TYPE_ACCELEROMETER, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
549 EXPECT_EQ(status,ret);
550 ret = g_sensorInterface->Enable(SENSOR_TYPE_ACCELEROMETER);
551 EXPECT_EQ(status,ret);
552 OsalMSleep(SENSOR_WAIT_TIME3);
553 ret = g_sensorInterface->Disable(SENSOR_TYPE_ACCELEROMETER);
554 EXPECT_EQ(status,ret);
555 }
556
557 /**
558 * @tc.name: EnableSensor0004
559 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
560 * @tc.type: FUNC
561 */
562 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2600, TestSize.Level1)
563 {
564 if (g_sensorInterface == nullptr) {
565 ASSERT_NE(nullptr, g_sensorInterface);
566 return;
567 }
568
569 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GYROSCOPE);
570 int32_t ret = g_sensorInterface->SetBatch(SENSOR_TYPE_GYROSCOPE, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
571 EXPECT_EQ(status,ret);
572 ret = g_sensorInterface->Enable(SENSOR_TYPE_GYROSCOPE);
573 EXPECT_EQ(status,ret);
574 OsalMSleep(SENSOR_WAIT_TIME3);
575 ret = g_sensorInterface->Disable(SENSOR_TYPE_GYROSCOPE);
576 EXPECT_EQ(status,ret);
577 }
578
579 /**
580 * @tc.name: EnableSensor0005
581 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2700, TestSize.Level1)
585 {
586 if (g_sensorInterface == nullptr) {
587 ASSERT_NE(nullptr, g_sensorInterface);
588 return;
589 }
590
591 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_PHOTOPLETHYSMOGRAPH);
592 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_PHOTOPLETHYSMOGRAPH);
593 EXPECT_EQ(status,ret);
594 OsalMSleep(SENSOR_WAIT_TIME3);
595 ret = g_sensorInterface->Disable(SENSOR_TYPE_PHOTOPLETHYSMOGRAPH);
596 EXPECT_EQ(status,ret);
597 }
598
599 /**
600 * @tc.name: EnableSensor0006
601 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
602 * @tc.type: FUNC
603 */
604 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2800, TestSize.Level1)
605 {
606 if (g_sensorInterface == nullptr) {
607 ASSERT_NE(nullptr, g_sensorInterface);
608 return;
609 }
610
611 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ELECTROCARDIOGRAPH);
612 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_ELECTROCARDIOGRAPH);
613 EXPECT_EQ(status,ret);
614 OsalMSleep(SENSOR_WAIT_TIME3);
615 ret = g_sensorInterface->Disable(SENSOR_TYPE_ELECTROCARDIOGRAPH);
616 EXPECT_EQ(status,ret);
617 }
618
619 /**
620 * @tc.name: EnableSensor0007
621 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_2900, TestSize.Level1)
625 {
626 if (g_sensorInterface == nullptr) {
627 ASSERT_NE(nullptr, g_sensorInterface);
628 return;
629 }
630
631 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_AMBIENT_LIGHT);
632 int32_t ret = g_sensorInterface->SetBatch(SENSOR_TYPE_AMBIENT_LIGHT, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
633 EXPECT_EQ(status,ret);
634 ret = g_sensorInterface->Enable(SENSOR_TYPE_AMBIENT_LIGHT);
635 EXPECT_EQ(status,ret);
636 OsalMSleep(SENSOR_WAIT_TIME3);
637 ret = g_sensorInterface->Disable(SENSOR_TYPE_AMBIENT_LIGHT);
638 EXPECT_EQ(status,ret);
639 }
640
641 /**
642 * @tc.name: EnableSensor0008
643 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
644 * @tc.type: FUNC
645 */
646 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3100, TestSize.Level1)
647 {
648 if (g_sensorInterface == nullptr) {
649 ASSERT_NE(nullptr, g_sensorInterface);
650 return;
651 }
652
653 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MAGNETIC_FIELD);
654 int32_t ret = g_sensorInterface->SetBatch(SENSOR_TYPE_MAGNETIC_FIELD, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
655 EXPECT_EQ(status,ret);
656 ret = g_sensorInterface->Enable(SENSOR_TYPE_MAGNETIC_FIELD);
657 EXPECT_EQ(status,ret);
658 OsalMSleep(SENSOR_WAIT_TIME3);
659 ret = g_sensorInterface->Disable(SENSOR_TYPE_MAGNETIC_FIELD);
660 EXPECT_EQ(status,ret);
661 }
662
663 /**
664 * @tc.name: EnableSensor0009
665 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
666 * @tc.type: FUNC
667 */
668 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3200, TestSize.Level1)
669 {
670 if (g_sensorInterface == nullptr) {
671 ASSERT_NE(nullptr, g_sensorInterface);
672 return;
673 }
674
675 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_CAPACITIVE);
676 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_CAPACITIVE);
677 EXPECT_EQ(status,ret);
678 OsalMSleep(SENSOR_WAIT_TIME3);
679 ret = g_sensorInterface->Disable(SENSOR_TYPE_CAPACITIVE);
680 EXPECT_EQ(status,ret);
681 }
682
683 /**
684 * @tc.name: EnableSensor0010
685 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
686 * @tc.type: FUNC
687 */
688 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3300, TestSize.Level1)
689 {
690 if (g_sensorInterface == nullptr) {
691 ASSERT_NE(nullptr, g_sensorInterface);
692 return;
693 }
694
695 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_BAROMETER);
696 int32_t ret = g_sensorInterface->SetBatch(SENSOR_TYPE_BAROMETER, SENSOR_INTERVAL1, SENSOR_POLL_TIME);
697 EXPECT_EQ(status,ret);
698 ret = g_sensorInterface->Enable(SENSOR_TYPE_BAROMETER);
699 EXPECT_EQ(status,ret);
700 OsalMSleep(SENSOR_WAIT_TIME3);
701 ret = g_sensorInterface->Disable(SENSOR_TYPE_BAROMETER);
702 EXPECT_EQ(status,ret);
703 }
704
705 /**
706 * @tc.name: EnableSensor0011
707 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
708 * @tc.type: FUNC
709 */
710 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3400, TestSize.Level1)
711 {
712 if (g_sensorInterface == nullptr) {
713 ASSERT_NE(nullptr, g_sensorInterface);
714 return;
715 }
716
717 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_TEMPERATURE);
718 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_TEMPERATURE);
719 EXPECT_EQ(status,ret);
720 OsalMSleep(SENSOR_WAIT_TIME3);
721 ret = g_sensorInterface->Disable(SENSOR_TYPE_TEMPERATURE);
722 EXPECT_EQ(status,ret);
723 }
724
725 /**
726 * @tc.name: EnableSensor0012
727 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
728 * @tc.type: FUNC
729 */
730 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3500, TestSize.Level1)
731 {
732 if (g_sensorInterface == nullptr) {
733 ASSERT_NE(nullptr, g_sensorInterface);
734 return;
735 }
736
737 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_HALL);
738 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_HALL);
739 EXPECT_EQ(status,ret);
740 OsalMSleep(SENSOR_WAIT_TIME3);
741 ret = g_sensorInterface->Disable(SENSOR_TYPE_HALL);
742 EXPECT_EQ(status,ret);
743 }
744
745 /**
746 * @tc.name: EnableSensor0013
747 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
748 * @tc.type: FUNC
749 */
750 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3600, TestSize.Level1)
751 {
752 if (g_sensorInterface == nullptr) {
753 ASSERT_NE(nullptr, g_sensorInterface);
754 return;
755 }
756
757 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GESTURE);
758 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_GESTURE);
759 EXPECT_EQ(status,ret);
760 OsalMSleep(SENSOR_WAIT_TIME3);
761 ret = g_sensorInterface->Disable(SENSOR_TYPE_GESTURE);
762 EXPECT_EQ(status,ret);
763 }
764
765 /**
766 * @tc.name: EnableSensor0014
767 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
768 * @tc.type: FUNC
769 */
770 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3700, TestSize.Level1)
771 {
772 if (g_sensorInterface == nullptr) {
773 ASSERT_NE(nullptr, g_sensorInterface);
774 return;
775 }
776
777 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_PROXIMITY);
778 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_PROXIMITY);
779 EXPECT_EQ(status,ret);
780 OsalMSleep(SENSOR_WAIT_TIME3);
781 ret = g_sensorInterface->Disable(SENSOR_TYPE_PROXIMITY);
782 EXPECT_EQ(status,ret);
783 }
784
785 /**
786 * @tc.name: EnableSensor0015
787 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
788 * @tc.type: FUNC
789 */
790 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_3800, TestSize.Level1)
791 {
792 if (g_sensorInterface == nullptr) {
793 ASSERT_NE(nullptr, g_sensorInterface);
794 return;
795 }
796
797 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_HUMIDITY);
798 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_HUMIDITY);
799 EXPECT_EQ(status,ret);
800 OsalMSleep(SENSOR_WAIT_TIME3);
801 ret = g_sensorInterface->Disable(SENSOR_TYPE_HUMIDITY);
802 EXPECT_EQ(status,ret);
803 }
804
805 /**
806 * @tc.name: EnableSensor0016
807 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
808 * @tc.type: FUNC
809 */
810 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5100, TestSize.Level1)
811 {
812 if (g_sensorInterface == nullptr) {
813 ASSERT_NE(nullptr, g_sensorInterface);
814 return;
815 }
816
817 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MEDICAL_BEGIN);
818 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_MEDICAL_BEGIN);
819 EXPECT_EQ(status,ret);
820 OsalMSleep(SENSOR_WAIT_TIME3);
821 ret = g_sensorInterface->Disable(SENSOR_TYPE_MEDICAL_BEGIN);
822 EXPECT_EQ(status,ret);
823 }
824
825 /**
826 * @tc.name: EnableSensor0017
827 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
828 * @tc.type: FUNC
829 */
830 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5200, TestSize.Level1)
831 {
832 if (g_sensorInterface == nullptr) {
833 ASSERT_NE(nullptr, g_sensorInterface);
834 return;
835 }
836
837 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MEDICAL_END);
838 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_MEDICAL_END);
839 EXPECT_EQ(status,ret);
840 OsalMSleep(SENSOR_WAIT_TIME3);
841 ret = g_sensorInterface->Disable(SENSOR_TYPE_MEDICAL_END);
842 EXPECT_EQ(status,ret);
843 }
844
845 /**
846 * @tc.name: EnableSensor0018
847 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5300, TestSize.Level1)
851 {
852 if (g_sensorInterface == nullptr) {
853 ASSERT_NE(nullptr, g_sensorInterface);
854 return;
855 }
856
857 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_PHYSICAL_MAX);
858 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_PHYSICAL_MAX);
859 EXPECT_EQ(status,ret);
860 OsalMSleep(SENSOR_WAIT_TIME3);
861 ret = g_sensorInterface->Disable(SENSOR_TYPE_PHYSICAL_MAX);
862 EXPECT_EQ(status,ret);
863 }
864
865 /**
866 * @tc.name: EnableSensor0019
867 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
868 * @tc.type: FUNC
869 */
870 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5400, TestSize.Level1)
871 {
872 if (g_sensorInterface == nullptr) {
873 ASSERT_NE(nullptr, g_sensorInterface);
874 return;
875 }
876
877 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ORIENTATION);
878 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_ORIENTATION);
879 EXPECT_EQ(status,ret);
880 OsalMSleep(SENSOR_WAIT_TIME3);
881 ret = g_sensorInterface->Disable(SENSOR_TYPE_ORIENTATION);
882 EXPECT_EQ(status,ret);
883 }
884
885 /**
886 * @tc.name: EnableSensor0020
887 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
888 * @tc.type: FUNC
889 */
890 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5500, TestSize.Level1)
891 {
892 if (g_sensorInterface == nullptr) {
893 ASSERT_NE(nullptr, g_sensorInterface);
894 return;
895 }
896
897 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GRAVITY);
898 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_GRAVITY);
899 EXPECT_EQ(status,ret);
900 OsalMSleep(SENSOR_WAIT_TIME3);
901 ret = g_sensorInterface->Disable(SENSOR_TYPE_GRAVITY);
902 EXPECT_EQ(status,ret);
903 }
904
905 /**
906 * @tc.name: EnableSensor0021
907 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
908 * @tc.type: FUNC
909 */
910 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5600, TestSize.Level1)
911 {
912 if (g_sensorInterface == nullptr) {
913 ASSERT_NE(nullptr, g_sensorInterface);
914 return;
915 }
916
917 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_LINEAR_ACCELERATION);
918 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_LINEAR_ACCELERATION);
919 EXPECT_EQ(status,ret);
920 OsalMSleep(SENSOR_WAIT_TIME3);
921 ret = g_sensorInterface->Disable(SENSOR_TYPE_LINEAR_ACCELERATION);
922 EXPECT_EQ(status,ret);
923 }
924
925 /**
926 * @tc.name: EnableSensor0022
927 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
928 * @tc.type: FUNC
929 */
930 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5700, TestSize.Level1)
931 {
932 if (g_sensorInterface == nullptr) {
933 ASSERT_NE(nullptr, g_sensorInterface);
934 return;
935 }
936
937 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ROTATION_VECTOR);
938 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_ROTATION_VECTOR);
939 EXPECT_EQ(status,ret);
940 OsalMSleep(SENSOR_WAIT_TIME3);
941 ret = g_sensorInterface->Disable(SENSOR_TYPE_ROTATION_VECTOR);
942 EXPECT_EQ(status,ret);
943 }
944
945 /**
946 * @tc.name: EnableSensor0023
947 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
948 * @tc.type: FUNC
949 */
950 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5800, TestSize.Level1)
951 {
952 if (g_sensorInterface == nullptr) {
953 ASSERT_NE(nullptr, g_sensorInterface);
954 return;
955 }
956
957 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_AMBIENT_TEMPERATURE);
958 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_AMBIENT_TEMPERATURE);
959 EXPECT_EQ(status,ret);
960 OsalMSleep(SENSOR_WAIT_TIME3);
961 ret = g_sensorInterface->Disable(SENSOR_TYPE_AMBIENT_TEMPERATURE);
962 EXPECT_EQ(status,ret);
963 }
964
965 /**
966 * @tc.name: EnableSensor0024
967 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
968 * @tc.type: FUNC
969 */
970 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_5900, TestSize.Level1)
971 {
972 if (g_sensorInterface == nullptr) {
973 ASSERT_NE(nullptr, g_sensorInterface);
974 return;
975 }
976
977 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
978 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
979 EXPECT_EQ(status,ret);
980 OsalMSleep(SENSOR_WAIT_TIME3);
981 ret = g_sensorInterface->Disable(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
982 EXPECT_EQ(status,ret);
983 }
984
985 /**
986 * @tc.name: EnableSensor0025
987 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
988 * @tc.type: FUNC
989 */
990 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6000, TestSize.Level1)
991 {
992 if (g_sensorInterface == nullptr) {
993 ASSERT_NE(nullptr, g_sensorInterface);
994 return;
995 }
996
997 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GAME_ROTATION_VECTOR);
998 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_GAME_ROTATION_VECTOR);
999 EXPECT_EQ(status,ret);
1000 OsalMSleep(SENSOR_WAIT_TIME3);
1001 ret = g_sensorInterface->Disable(SENSOR_TYPE_GAME_ROTATION_VECTOR);
1002 EXPECT_EQ(status,ret);
1003 }
1004
1005 /**
1006 * @tc.name: EnableSensor0026
1007 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1008 * @tc.type: FUNC
1009 */
1010 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6100, TestSize.Level1)
1011 {
1012 if (g_sensorInterface == nullptr) {
1013 ASSERT_NE(nullptr, g_sensorInterface);
1014 return;
1015 }
1016
1017 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
1018 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
1019 EXPECT_EQ(status,ret);
1020 OsalMSleep(SENSOR_WAIT_TIME3);
1021 ret = g_sensorInterface->Disable(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
1022 EXPECT_EQ(status,ret);
1023 }
1024
1025 /**
1026 * @tc.name: EnableSensor0027
1027 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6200, TestSize.Level1)
1031 {
1032 if (g_sensorInterface == nullptr) {
1033 ASSERT_NE(nullptr, g_sensorInterface);
1034 return;
1035 }
1036
1037 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_SIGNIFICANT_MOTION);
1038 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_SIGNIFICANT_MOTION);
1039 EXPECT_EQ(status,ret);
1040 OsalMSleep(SENSOR_WAIT_TIME3);
1041 ret = g_sensorInterface->Disable(SENSOR_TYPE_SIGNIFICANT_MOTION);
1042 EXPECT_EQ(status,ret);
1043 }
1044
1045 /**
1046 * @tc.name: EnableSensor0028
1047 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1048 * @tc.type: FUNC
1049 */
1050 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6300, TestSize.Level1)
1051 {
1052 if (g_sensorInterface == nullptr) {
1053 ASSERT_NE(nullptr, g_sensorInterface);
1054 return;
1055 }
1056
1057 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_PEDOMETER_DETECTION);
1058 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_PEDOMETER_DETECTION);
1059 EXPECT_EQ(status,ret);
1060 OsalMSleep(SENSOR_WAIT_TIME3);
1061 ret = g_sensorInterface->Disable(SENSOR_TYPE_PEDOMETER_DETECTION);
1062 EXPECT_EQ(status,ret);
1063 }
1064
1065 /**
1066 * @tc.name: EnableSensor0029
1067 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1068 * @tc.type: FUNC
1069 */
1070 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6400, TestSize.Level1)
1071 {
1072 if (g_sensorInterface == nullptr) {
1073 ASSERT_NE(nullptr, g_sensorInterface);
1074 return;
1075 }
1076
1077 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_PEDOMETER);
1078 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_PEDOMETER);
1079 EXPECT_EQ(status,ret);
1080 OsalMSleep(SENSOR_WAIT_TIME3);
1081 ret = g_sensorInterface->Disable(SENSOR_TYPE_PEDOMETER);
1082 EXPECT_EQ(status,ret);
1083 }
1084
1085 /**
1086 * @tc.name: EnableSensor0030
1087 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6500, TestSize.Level1)
1091 {
1092 if (g_sensorInterface == nullptr) {
1093 ASSERT_NE(nullptr, g_sensorInterface);
1094 return;
1095 }
1096
1097 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR);
1098 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR);
1099 EXPECT_EQ(status,ret);
1100 OsalMSleep(SENSOR_WAIT_TIME3);
1101 ret = g_sensorInterface->Disable(SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR);
1102 EXPECT_EQ(status,ret);
1103 }
1104
1105 /**
1106 * @tc.name: EnableSensor0031
1107 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6600, TestSize.Level1)
1111 {
1112 if (g_sensorInterface == nullptr) {
1113 ASSERT_NE(nullptr, g_sensorInterface);
1114 return;
1115 }
1116
1117 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_HEART_RATE);
1118 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_HEART_RATE);
1119 EXPECT_EQ(status,ret);
1120 OsalMSleep(SENSOR_WAIT_TIME3);
1121 ret = g_sensorInterface->Disable(SENSOR_TYPE_HEART_RATE);
1122 EXPECT_EQ(status,ret);
1123 }
1124
1125 /**
1126 * @tc.name: EnableSensor0032
1127 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6700, TestSize.Level1)
1131 {
1132 if (g_sensorInterface == nullptr) {
1133 ASSERT_NE(nullptr, g_sensorInterface);
1134 return;
1135 }
1136
1137 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_DEVICE_ORIENTATION);
1138 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_DEVICE_ORIENTATION);
1139 EXPECT_EQ(status,ret);
1140 OsalMSleep(SENSOR_WAIT_TIME3);
1141 ret = g_sensorInterface->Disable(SENSOR_TYPE_DEVICE_ORIENTATION);
1142 EXPECT_EQ(status,ret);
1143 }
1144
1145 /**
1146 * @tc.name: EnableSensor0033
1147 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6800, TestSize.Level1)
1151 {
1152 if (g_sensorInterface == nullptr) {
1153 ASSERT_NE(nullptr, g_sensorInterface);
1154 return;
1155 }
1156
1157 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_WEAR_DETECTION);
1158 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_WEAR_DETECTION);
1159 EXPECT_EQ(status,ret);
1160 OsalMSleep(SENSOR_WAIT_TIME3);
1161 ret = g_sensorInterface->Disable(SENSOR_TYPE_WEAR_DETECTION);
1162 EXPECT_EQ(status,ret);
1163 }
1164
1165 /**
1166 * @tc.name: EnableSensor0034
1167 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1168 * @tc.type: FUNC
1169 */
1170 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_6900, TestSize.Level1)
1171 {
1172 if (g_sensorInterface == nullptr) {
1173 ASSERT_NE(nullptr, g_sensorInterface);
1174 return;
1175 }
1176
1177 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED);
1178 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED);
1179 EXPECT_EQ(status,ret);
1180 OsalMSleep(SENSOR_WAIT_TIME3);
1181 ret = g_sensorInterface->Disable(SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED);
1182 EXPECT_EQ(status,ret);
1183 }
1184
1185 /**
1186 * @tc.name: EnableSensor0035
1187 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID.
1188 * @tc.type: FUNC
1189 */
1190 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7000, TestSize.Level1)
1191 {
1192 if (g_sensorInterface == nullptr) {
1193 ASSERT_NE(nullptr, g_sensorInterface);
1194 return;
1195 }
1196
1197 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MAX);
1198 int32_t ret = g_sensorInterface->Enable(SENSOR_TYPE_MAX);
1199 EXPECT_EQ(status,ret);
1200 OsalMSleep(SENSOR_WAIT_TIME3);
1201 ret = g_sensorInterface->Disable(SENSOR_TYPE_MAX);
1202 EXPECT_EQ(status,ret);
1203 }
1204
1205 /**
1206 * @tc.name: GetSdcSensorInfo
1207 * @tc.desc: Read event data for the specified sensor.
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7200, TestSize.Level1)
1211 {
1212 ASSERT_NE(nullptr, g_sensorInterface);
1213
1214 EXPECT_GT(g_info.size(), 0);
1215 std::vector<OHOS::HDI::Sensor::V2_0::SdcSensorInfo> sdcSensorInfo;
1216 int32_t ret = g_sensorInterface->GetSdcSensorInfo(sdcSensorInfo);
1217 EXPECT_EQ(SENSOR_SUCCESS, ret);
1218 std::string infoMsg = "[";
1219 for (auto it : sdcSensorInfo) {
1220 if (infoMsg != "[") {
1221 infoMsg += ", ";
1222 }
1223 infoMsg += "{";
1224 infoMsg += "offset = " + std::to_string(it.offset) + ", ";
1225 infoMsg += "sensorId = " + std::to_string(it.sensorId) + ", ";
1226 infoMsg += "ddrSize = " + std::to_string(it.ddrSize) + ", ";
1227 infoMsg += "minRateLevel = " + std::to_string(it.minRateLevel) + ", ";
1228 infoMsg += "maxRateLevel = " + std::to_string(it.maxRateLevel) + ", ";
1229 infoMsg += "memAddr = " + std::to_string(it.memAddr) + ", ";
1230 infoMsg += "reserved = " + std::to_string(it.reserved);
1231 infoMsg += "}";
1232 }
1233 infoMsg += "]";
1234 }
1235
1236 /**
1237 * @tc.name: ReportFrequencyTest0001
1238 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7300, TestSize.Level1)
1242 {
1243 ASSERT_NE(nullptr, g_sensorInterface);
1244
1245 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1246 EXPECT_EQ(SENSOR_SUCCESS, ret);
1247
1248 EXPECT_GT(g_info.size(), 0);
1249 int32_t sensorId = g_info[0].sensorId;
1250
1251 ret = g_sensorInterface->SetBatch(sensorId, SENSOR_INTERVAL1, SENSOR_INTERVAL1);
1252 EXPECT_EQ(SENSOR_SUCCESS, ret);
1253
1254 ret = g_sensorInterface->Enable(sensorId);
1255 EXPECT_EQ(SENSOR_SUCCESS, ret);
1256
1257 OsalMSleep(SENSOR_WAIT_TIME2);
1258
1259 ret = g_sensorInterface->Disable(sensorId);
1260 EXPECT_EQ(SENSOR_SUCCESS, ret);
1261
1262 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1263 EXPECT_EQ(SENSOR_SUCCESS, ret);
1264
1265 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
1266 SensorCallbackImpl::sensorDataFlag = 1;
1267 }
1268
1269 /**
1270 * @tc.name: ReportFrequencyTest0002
1271 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7400, TestSize.Level1)
1275 {
1276 ASSERT_NE(nullptr, g_sensorInterface);
1277
1278 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1279 EXPECT_EQ(SENSOR_SUCCESS, ret);
1280
1281 EXPECT_GT(g_info.size(), 0);
1282 int32_t sensorId = g_info[0].sensorId;
1283
1284 ret = g_sensorInterface->SetBatch(sensorId, SENSOR_INTERVAL3, SENSOR_INTERVAL1);
1285 EXPECT_EQ(SENSOR_SUCCESS, ret);
1286
1287 ret = g_sensorInterface->Enable(sensorId);
1288 EXPECT_EQ(SENSOR_SUCCESS, ret);
1289
1290 OsalMSleep(SENSOR_WAIT_TIME2);
1291
1292 ret = g_sensorInterface->Disable(sensorId);
1293 EXPECT_EQ(SENSOR_SUCCESS, ret);
1294
1295 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1296 EXPECT_EQ(SENSOR_SUCCESS, ret);
1297
1298 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
1299 SensorCallbackImpl::sensorDataFlag = 1;
1300 }
1301
1302 /**
1303 * @tc.name: ReportFrequencyTest0003
1304 * @tc.desc: Sets the sampling time and data report interval for sensors in batches.
1305 * @tc.type: FUNC
1306 */
1307 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7500, TestSize.Level1)
1308 {
1309 ASSERT_NE(nullptr, g_sensorInterface);
1310
1311 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1312 EXPECT_EQ(SENSOR_SUCCESS, ret);
1313
1314 EXPECT_GT(g_info.size(), 0);
1315 int32_t sensorId = g_info[0].sensorId;
1316
1317 ret = g_sensorInterface->SetBatch(sensorId, SENSOR_INTERVAL4, SENSOR_INTERVAL1);
1318 EXPECT_EQ(SENSOR_SUCCESS, ret);
1319
1320 ret = g_sensorInterface->Enable(sensorId);
1321 EXPECT_EQ(SENSOR_SUCCESS, ret);
1322
1323 OsalMSleep(SENSOR_WAIT_TIME2);
1324
1325 ret = g_sensorInterface->Disable(sensorId);
1326 EXPECT_EQ(SENSOR_SUCCESS, ret);
1327
1328 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
1329 EXPECT_EQ(SENSOR_SUCCESS, ret);
1330
1331 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1);
1332 SensorCallbackImpl::sensorDataFlag = 1;
1333 }
1334
1335 /**
1336 * @tc.name: SetSdcSensor1
1337 * @tc.desc: Read event data for the specified sensor.
1338 * @tc.type: FUNC
1339 */
1340 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7600, TestSize.Level1)
1341 {
1342 ASSERT_NE(nullptr, g_sensorInterface);
1343 EXPECT_GT(g_info.size(), 0);
1344 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_ELECTROCARDIOGRAPH, true, RATE_LEVEL);
1345 EXPECT_NE(SENSOR_SUCCESS, ret);
1346 OsalMSleep(SENSOR_WAIT_TIME);
1347 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_ELECTROCARDIOGRAPH, false, RATE_LEVEL);
1348 EXPECT_NE(SENSOR_SUCCESS, ret);
1349 }
1350
1351 /**
1352 * @tc.name: SetSdcSensor2
1353 * @tc.desc: Read event data for the specified sensor.
1354 * @tc.type: FUNC
1355 */
1356 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7700, TestSize.Level1)
1357 {
1358 ASSERT_NE(nullptr, g_sensorInterface);
1359 EXPECT_GT(g_info.size(), 0);
1360 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_ACCELEROMETER);
1361 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_ACCELEROMETER, true, RATE_LEVEL);
1362 EXPECT_EQ(status, ret);
1363 OsalMSleep(SENSOR_WAIT_TIME);
1364 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_ACCELEROMETER, false, RATE_LEVEL);
1365 EXPECT_EQ(status, ret);
1366 }
1367
1368 /**
1369 * @tc.name: SetSdcSensor3
1370 * @tc.desc: Read event data for the specified sensor.
1371 * @tc.type: FUNC
1372 */
1373 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7800, TestSize.Level1)
1374 {
1375 ASSERT_NE(nullptr, g_sensorInterface);
1376 EXPECT_GT(g_info.size(), 0);
1377 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_NONE);
1378 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_NONE, true, RATE_LEVEL);
1379 EXPECT_EQ(status, ret);
1380 OsalMSleep(SENSOR_WAIT_TIME);
1381 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_NONE, false, RATE_LEVEL);
1382 EXPECT_EQ(status, ret);
1383 }
1384
1385 /**
1386 * @tc.name: SetSdcSensor4
1387 * @tc.desc: Read event data for the specified sensor.
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_7900, TestSize.Level1)
1391 {
1392 ASSERT_NE(nullptr, g_sensorInterface);
1393 EXPECT_GT(g_info.size(), 0);
1394 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GYROSCOPE);
1395 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_GYROSCOPE, true, RATE_LEVEL);
1396 EXPECT_EQ(status, ret);
1397 OsalMSleep(SENSOR_WAIT_TIME);
1398 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_GYROSCOPE, false, RATE_LEVEL);
1399 EXPECT_EQ(status, ret);
1400 }
1401
1402 /**
1403 * @tc.name: SetSdcSensor5
1404 * @tc.desc: Read event data for the specified sensor.
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8000, TestSize.Level1)
1408 {
1409 ASSERT_NE(nullptr, g_sensorInterface);
1410 EXPECT_GT(g_info.size(), 0);
1411 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_PHOTOPLETHYSMOGRAPH, true, RATE_LEVEL);
1412 EXPECT_NE(SENSOR_SUCCESS, ret);
1413 OsalMSleep(SENSOR_WAIT_TIME);
1414 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_PHOTOPLETHYSMOGRAPH, false, RATE_LEVEL);
1415 EXPECT_NE(SENSOR_SUCCESS, ret);
1416 }
1417
1418 /**
1419 * @tc.name: SetSdcSensor6
1420 * @tc.desc: Read event data for the specified sensor.
1421 * @tc.type: FUNC
1422 */
1423 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8100, TestSize.Level1)
1424 {
1425 ASSERT_NE(nullptr, g_sensorInterface);
1426 EXPECT_GT(g_info.size(), 0);
1427 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_AMBIENT_LIGHT);
1428 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_AMBIENT_LIGHT, true, RATE_LEVEL);
1429 EXPECT_EQ(status, ret);
1430 OsalMSleep(SENSOR_WAIT_TIME);
1431 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_AMBIENT_LIGHT, false, RATE_LEVEL);
1432 EXPECT_EQ(status, ret);
1433 }
1434
1435 /**
1436 * @tc.name: SetSdcSensor7
1437 * @tc.desc: Read event data for the specified sensor.
1438 * @tc.type: FUNC
1439 */
1440 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8200, TestSize.Level1)
1441 {
1442 ASSERT_NE(nullptr, g_sensorInterface);
1443 EXPECT_GT(g_info.size(), 0);
1444 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_MAGNETIC_FIELD);
1445 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_MAGNETIC_FIELD, true, RATE_LEVEL);
1446 EXPECT_EQ(status, ret);
1447 OsalMSleep(SENSOR_WAIT_TIME);
1448 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_MAGNETIC_FIELD, false, RATE_LEVEL);
1449 EXPECT_EQ(status, ret);
1450 }
1451
1452 /**
1453 * @tc.name: SetSdcSensor8
1454 * @tc.desc: Read event data for the specified sensor.
1455 * @tc.type: FUNC
1456 */
1457 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8300, TestSize.Level1)
1458 {
1459 ASSERT_NE(nullptr, g_sensorInterface);
1460 EXPECT_GT(g_info.size(), 0);
1461 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_CAPACITIVE, true, RATE_LEVEL);
1462 EXPECT_NE(SENSOR_SUCCESS, ret);
1463 OsalMSleep(SENSOR_WAIT_TIME);
1464 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_CAPACITIVE, false, RATE_LEVEL);
1465 EXPECT_NE(SENSOR_SUCCESS, ret);
1466 }
1467
1468 /**
1469 * @tc.name: SetSdcSensor9
1470 * @tc.desc: Read event data for the specified sensor.
1471 * @tc.type: FUNC
1472 */
1473 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8400, TestSize.Level1)
1474 {
1475 ASSERT_NE(nullptr, g_sensorInterface);
1476 EXPECT_GT(g_info.size(), 0);
1477 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_BAROMETER);
1478 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_BAROMETER, true, RATE_LEVEL);
1479 EXPECT_EQ(status, ret);
1480 OsalMSleep(SENSOR_WAIT_TIME);
1481 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_BAROMETER, false, RATE_LEVEL);
1482 EXPECT_EQ(status, ret);
1483 }
1484
1485 /**
1486 * @tc.name: SetSdcSensor10
1487 * @tc.desc: Read event data for the specified sensor.
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8500, TestSize.Level1)
1491 {
1492 ASSERT_NE(nullptr, g_sensorInterface);
1493 EXPECT_GT(g_info.size(), 0);
1494 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_TEMPERATURE, true, RATE_LEVEL);
1495 EXPECT_NE(SENSOR_SUCCESS, ret);
1496 OsalMSleep(SENSOR_WAIT_TIME);
1497 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_TEMPERATURE, false, RATE_LEVEL);
1498 EXPECT_NE(SENSOR_SUCCESS, ret);
1499 }
1500
1501 /**
1502 * @tc.name: SetSdcSensor11
1503 * @tc.desc: Read event data for the specified sensor.
1504 * @tc.type: FUNC
1505 */
1506 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8600, TestSize.Level1)
1507 {
1508 ASSERT_NE(nullptr, g_sensorInterface);
1509 EXPECT_GT(g_info.size(), 0);
1510 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_HALL);
1511 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_HALL, true, RATE_LEVEL);
1512 EXPECT_EQ(status, ret);
1513 OsalMSleep(SENSOR_WAIT_TIME);
1514 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_HALL, false, RATE_LEVEL);
1515 EXPECT_EQ(status, ret);
1516 }
1517
1518 /**
1519 * @tc.name: SetSdcSensor12
1520 * @tc.desc: Read event data for the specified sensor.
1521 * @tc.type: FUNC
1522 */
1523 HWTEST_F(HdfSensorHdiTest, SUB_Driver_Sensor_HdiSensor_8700, TestSize.Level1)
1524 {
1525 ASSERT_NE(nullptr, g_sensorInterface);
1526 EXPECT_GT(g_info.size(), 0);
1527 int32_t status = IsSuppprtedSensorId(SENSOR_TYPE_GESTURE);
1528 int32_t ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_GESTURE, true, RATE_LEVEL);
1529 EXPECT_EQ(status, ret);
1530 OsalMSleep(SENSOR_WAIT_TIME);
1531 ret = g_sensorInterface->SetSdcSensor(SENSOR_TYPE_GESTURE, false, RATE_LEVEL);
1532 EXPECT_EQ(status, ret);
1533 }