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