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