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