1 /* 2 * Copyright (c) 2021-2023 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 #include "sensor_callback_impl_test.h" 27 #include "sensor_uhdf_log.h" 28 #include "sensor_trace.h" 29 30 using namespace OHOS::HDI::Sensor::V3_0; 31 using namespace OHOS::HDI::Sensor; 32 using namespace testing::ext; 33 34 namespace { 35 sptr<V3_0::ISensorInterface> g_sensorInterface = nullptr; 36 sptr<V3_0::ISensorCallback> g_traditionalCallback = new SensorCallbackImpl(); 37 sptr<V3_0::ISensorCallback> g_traditionalCallbackTest = new SensorCallbackImplTest(); 38 sptr<V3_0::ISensorCallback> g_medicalCallback = new SensorCallbackImpl(); 39 std::vector<HdfSensorInformation> g_info; 40 std::vector<HdfSensorEvents> g_events; 41 struct SensorValueRange { 42 float highThreshold; 43 float lowThreshold; 44 }; 45 46 struct SensorDevelopmentList { 47 int32_t sensorTypeId; 48 char sensorName[SENSOR_NAME_MAX_LEN]; 49 int32_t dataForm; // 0: fixed, 1: range 50 int32_t dataDimension; 51 struct SensorValueRange *valueRange; 52 }; 53 54 struct SensorValueRange g_testRange[] = {{1e5, 0}}; 55 struct SensorValueRange g_accelRange[] = {{78, -78}, {78, -78}, {78, -78}}; 56 struct SensorValueRange g_alsRange[] = {{10000000, 0}}; 57 struct SensorValueRange g_pedometerRange[] = {{10000, 0}}; 58 struct SensorValueRange g_proximityRange[] = {{5, 0}}; 59 struct SensorValueRange g_hallRange[] = {{2, 0}}; 60 struct SensorValueRange g_barometerRange[] = {{1100, -1100}, {1100, -1100}}; 61 struct SensorValueRange g_magneticRange[] = {{2000, -2000}, {2000, -2000}, {2000, -2000}}; 62 struct SensorValueRange g_gyroscopeRange[] = {{35, -35}, {35, -35}, {35, -35}}; 63 struct SensorValueRange g_gravityRange[] = {{78, -78}, {78, -78}, {78, -78}}; 64 struct SensorValueRange g_humidityRange[] = {{100, 0}}; 65 struct SensorValueRange g_temperatureRange[] = {{125, -40}}; 66 67 struct SensorDevelopmentList g_sensorList[] = { 68 {SENSOR_TYPE_NONE, "sensor_test", 1, 1, g_testRange}, 69 {SENSOR_TYPE_ACCELEROMETER, "accelerometer", 1, 3, g_accelRange}, 70 {SENSOR_TYPE_PEDOMETER, "pedometer", 1, 1, g_pedometerRange}, 71 {SENSOR_TYPE_PROXIMITY, "proximity", 0, 1, g_proximityRange}, 72 {SENSOR_TYPE_HALL, "hallrometer", 1, 1, g_hallRange}, 73 {SENSOR_TYPE_BAROMETER, "barometer", 1, 2, g_barometerRange}, 74 {SENSOR_TYPE_AMBIENT_LIGHT, "als", 1, 1, g_alsRange}, 75 {SENSOR_TYPE_MAGNETIC_FIELD, "magnetometer", 1, 3, g_magneticRange}, 76 {SENSOR_TYPE_GYROSCOPE, "gyroscope", 1, 3, g_gyroscopeRange}, 77 {SENSOR_TYPE_GRAVITY, "gravity", 1, 3, g_gravityRange}, 78 {SENSOR_TYPE_HUMIDITY, "humidity", 1, 1, g_humidityRange}, 79 {SENSOR_TYPE_TEMPERATURE, "tenperature", 1, 1, g_temperatureRange} 80 }; 81 82 constexpr int g_listNum = sizeof(g_sensorList) / sizeof(g_sensorList[0]); 83 constexpr int64_t SENSOR_INTERVAL1 = 200000000; 84 constexpr int64_t SENSOR_INTERVAL2 = 20000000; 85 constexpr int64_t SENSOR_INTERVAL3 = 40000000; 86 constexpr int64_t SENSOR_INTERVAL4 = 20000000; 87 constexpr int64_t SENSOR_INTERVAL5 = 50000000; 88 constexpr int32_t SENSOR_POLL_TIME = 1; 89 constexpr int32_t SENSOR_WAIT_TIME = 100; 90 constexpr int32_t SENSOR_WAIT_TIME2 = 1000; 91 constexpr int32_t SENSOR_WAIT_TIME3 = 1000; 92 constexpr int32_t ABNORMAL_SENSORID = -1; 93 constexpr int32_t RATE_LEVEL = 50; 94 95 96 class HdfSensorHdiTest : public testing::Test { 97 public: 98 static void SetUpTestCase(); 99 static void TearDownTestCase(); 100 void SetUp(); 101 void TearDown(); 102 }; 103 SetUpTestCase()104 void HdfSensorHdiTest::SetUpTestCase() 105 { 106 g_sensorInterface = V3_0::ISensorInterface::Get(); 107 } 108 TearDownTestCase()109 void HdfSensorHdiTest::TearDownTestCase() 110 { 111 } 112 SetUp()113 void HdfSensorHdiTest::SetUp() 114 { 115 } 116 TearDown()117 void HdfSensorHdiTest::TearDown() 118 { 119 } 120 121 /** 122 * @tc.name: GetSensorClient0001 123 * @tc.desc: Get a client and check whether the client is empty. 124 * @tc.type: FUNC 125 * @tc.require: #I4L3LF 126 */ 127 HWTEST_F(HdfSensorHdiTest, GetSensorClient0001, TestSize.Level1) 128 { 129 ASSERT_NE(nullptr, g_sensorInterface); 130 } 131 132 /** 133 * @tc.name: GetSensorList0001 134 * @tc.desc: Obtains information about all sensors in the system. 135 * @tc.type: FUNC 136 * @tc.require: #I4L3LF 137 */ 138 HWTEST_F(HdfSensorHdiTest, GetSensorList0001, TestSize.Level1) 139 { 140 if (g_sensorInterface == nullptr) { 141 ASSERT_NE(nullptr, g_sensorInterface); 142 return; 143 } 144 int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info); 145 EXPECT_EQ(SENSOR_SUCCESS, ret); 146 EXPECT_GT(g_info.size(), 0); 147 printf("get sensor list num[%zu]\n\r", g_info.size()); 148 149 for (auto iter : g_info) { 150 printf("get sensoriId[%d], info name[%s], power[%f]\n\r", iter.deviceSensorInfo.sensorType, 151 iter.sensorName.c_str(), iter.power); 152 for (int j =0; j < g_listNum; ++j) { 153 if (iter.deviceSensorInfo.sensorType == g_sensorList[j].sensorTypeId) { 154 EXPECT_GT(iter.sensorName.size(), 0); 155 break; 156 } 157 } 158 } 159 } 160 161 /** 162 * @tc.name: RegisterSensorDataCb0001 163 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise. 164 * @tc.type: FUNC 165 * @tc.require: SR000F869M, AR000F869P, AR000F8QNL 166 */ 167 HWTEST_F(HdfSensorHdiTest, RegisterSensorDataCb0001, TestSize.Level1) 168 { 169 if (g_sensorInterface == nullptr) { 170 ASSERT_NE(nullptr, g_sensorInterface); 171 return; 172 } 173 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 174 EXPECT_EQ(SENSOR_SUCCESS, ret); 175 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 176 EXPECT_EQ(SENSOR_SUCCESS, ret); 177 } 178 179 /** 180 * @tc.name: RegisterSensorDataCb0002 181 * @tc.desc: Returns 0 if the callback is successfully registered; returns a negative value otherwise. 182 * @tc.type: FUNC 183 * @tc.require: SR000F869M, AR000F869P, AR000F8QNL 184 */ 185 HWTEST_F(HdfSensorHdiTest, RegisterSensorDataCb0002, TestSize.Level1) 186 { 187 if (g_sensorInterface == nullptr) { 188 ASSERT_NE(nullptr, g_sensorInterface); 189 return; 190 } 191 int32_t ret = g_sensorInterface->Register(MEDICAL_SENSOR_TYPE, g_medicalCallback); 192 EXPECT_EQ(SENSOR_SUCCESS, ret); 193 ret = g_sensorInterface->Unregister(MEDICAL_SENSOR_TYPE, g_medicalCallback); 194 EXPECT_EQ(SENSOR_SUCCESS, ret); 195 } 196 197 /** 198 * @tc.name: RegisterDataCb001 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(HdfSensorHdiTest, RegisterSensorDataCb0003, TestSize.Level1) 204 { 205 if (g_sensorInterface == nullptr) { 206 ASSERT_NE(nullptr, g_sensorInterface); 207 return; 208 } 209 int32_t ret = g_sensorInterface->Register(SENSOR_GROUP_TYPE_MAX, g_medicalCallback); 210 EXPECT_EQ(SENSOR_INVALID_PARAM, ret); 211 ret = g_sensorInterface->Unregister(SENSOR_GROUP_TYPE_MAX, g_medicalCallback); 212 EXPECT_EQ(SENSOR_INVALID_PARAM, ret); 213 } 214 215 /** 216 * @tc.name: EnableSensor0001 217 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 218 * @tc.type: FUNC 219 * @tc.require: #I4L3LF 220 */ 221 HWTEST_F(HdfSensorHdiTest, EnableSensor0001, TestSize.Level1) 222 { 223 if (g_sensorInterface == nullptr) { 224 ASSERT_NE(nullptr, g_sensorInterface); 225 return; 226 } 227 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 228 EXPECT_EQ(SENSOR_SUCCESS, ret); 229 230 EXPECT_GT(g_info.size(), 0); 231 232 for (auto iter : g_info) { 233 ret = g_sensorInterface->SetBatch( 234 {0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_INTERVAL1, SENSOR_POLL_TIME); 235 EXPECT_EQ(SENSOR_SUCCESS, ret); 236 ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 237 EXPECT_EQ(SENSOR_SUCCESS, ret); 238 OsalMSleep(SENSOR_WAIT_TIME); 239 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 240 EXPECT_EQ(SENSOR_SUCCESS, ret); 241 } 242 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 243 EXPECT_EQ(0, ret); 244 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 245 SensorCallbackImpl::sensorDataFlag = 1; 246 } 247 248 /** 249 * @tc.name: EnableSensor0002 250 * @tc.desc: Enables the sensor available in the sensor list based on the specified sensor ID. 251 * @tc.type: FUNC 252 * @tc.require: #I4L3LF #I8FJ2I 253 */ 254 HWTEST_F(HdfSensorHdiTest, EnableSensor0002, TestSize.Level1) 255 { 256 if (g_sensorInterface == nullptr) { 257 ASSERT_NE(nullptr, g_sensorInterface); 258 return; 259 } 260 int32_t ret = g_sensorInterface->Enable({0, ABNORMAL_SENSORID, 0, 0}); 261 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret); 262 ret = g_sensorInterface->Disable({0, ABNORMAL_SENSORID, 0, 0}); 263 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret); 264 } 265 266 /** 267 * @tc.name: SetSensorBatch0001 268 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 269 * @tc.type: FUNC 270 * @tc.require: #I4L3LF 271 */ 272 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0001, TestSize.Level1) 273 { 274 if (g_sensorInterface == nullptr) { 275 ASSERT_NE(nullptr, g_sensorInterface); 276 return; 277 } 278 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 279 EXPECT_EQ(SENSOR_SUCCESS, ret); 280 281 for (auto iter : g_info) { 282 ret = g_sensorInterface->SetBatch( 283 {0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_INTERVAL2, SENSOR_POLL_TIME); 284 EXPECT_EQ(SENSOR_SUCCESS, ret); 285 ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 286 EXPECT_EQ(SENSOR_SUCCESS, ret); 287 OsalMSleep(SENSOR_WAIT_TIME); 288 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 289 EXPECT_EQ(SENSOR_SUCCESS, ret); 290 } 291 292 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 293 EXPECT_EQ(SENSOR_SUCCESS, ret); 294 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 295 SensorCallbackImpl::sensorDataFlag = 1; 296 } 297 298 /** @tc.name: SetSensorBatch0002 299 @tc.desc: Sets the sampling time and data report interval for sensors in batches. 300 @tc.type: FUNC 301 @tc.requrire: #I4L3LF 302 */ 303 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0002, TestSize.Level1) 304 { 305 if (g_sensorInterface == nullptr) { 306 ASSERT_NE(nullptr, g_sensorInterface); 307 return; 308 } 309 int32_t ret = g_sensorInterface->SetBatch({0, ABNORMAL_SENSORID, 0, 0}, 0, 0); 310 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret); 311 } 312 313 /** 314 * @tc.name: SetSensorBatch0003 315 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 316 * @tc.type: FUNC 317 * @tc.require: #I4L3LF 318 */ 319 HWTEST_F(HdfSensorHdiTest, SetSensorBatch0003, TestSize.Level1) 320 { 321 if (g_sensorInterface == nullptr) { 322 ASSERT_NE(nullptr, g_sensorInterface); 323 return; 324 } 325 for (auto iter : g_info) { 326 int32_t ret = g_sensorInterface->SetBatch( 327 {0, iter.deviceSensorInfo.sensorType, 0, 0}, -1, SENSOR_POLL_TIME); 328 EXPECT_EQ(SENSOR_INVALID_PARAM, ret); 329 } 330 } 331 332 /** 333 * @tc.name: SetSensorMode0001 334 * @tc.desc: Sets the data reporting mode for the specified sensor. 335 * @tc.type: FUNC 336 * @tc.require: #I4L3LF 337 */ 338 HWTEST_F(HdfSensorHdiTest, SetSensorMode0001, TestSize.Level1) 339 { 340 if (g_sensorInterface == nullptr) { 341 ASSERT_NE(nullptr, g_sensorInterface); 342 return; 343 } 344 EXPECT_GT(g_info.size(), 0); 345 for (auto iter : g_info) { 346 int32_t ret = g_sensorInterface->SetBatch( 347 {0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_INTERVAL1, SENSOR_POLL_TIME); 348 EXPECT_EQ(SENSOR_SUCCESS, ret); 349 if (iter.deviceSensorInfo.sensorType == SENSOR_TYPE_HALL) { 350 ret = g_sensorInterface->SetMode({0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_MODE_ON_CHANGE); 351 EXPECT_EQ(SENSOR_SUCCESS, ret); 352 } else { 353 ret = g_sensorInterface->SetMode({0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_MODE_REALTIME); 354 EXPECT_EQ(SENSOR_SUCCESS, ret); 355 } 356 ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 357 EXPECT_EQ(SENSOR_SUCCESS, ret); 358 OsalMSleep(SENSOR_WAIT_TIME); 359 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 360 EXPECT_EQ(SENSOR_SUCCESS, ret); 361 } 362 } 363 364 /** 365 * @tc.name: SetSensorMode0002 366 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid. 367 * Other values are invalid. 368 * @tc.type: FUNC 369 * @tc.require: #I4L3LF 370 */ 371 HWTEST_F(HdfSensorHdiTest, SetSensorMode0002, TestSize.Level1) 372 { 373 if (g_sensorInterface == nullptr) { 374 ASSERT_NE(nullptr, g_sensorInterface); 375 return; 376 } 377 int32_t ret = g_sensorInterface->SetMode({0, ABNORMAL_SENSORID, 0, 0}, SENSOR_MODE_REALTIME); 378 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret); 379 } 380 381 /** 382 * @tc.name: SetSensorMode0003 383 * @tc.desc: Sets the data reporting mode for the specified sensor.The current real-time polling mode is valid. 384 * Other values are invalid. 385 * @tc.type: FUNC 386 * @tc.require: #I4L3LF 387 */ 388 HWTEST_F(HdfSensorHdiTest, SetSensorMode0003, TestSize.Level1) 389 { 390 if (g_sensorInterface == nullptr) { 391 ASSERT_NE(nullptr, g_sensorInterface); 392 return; 393 } 394 EXPECT_GT(g_info.size(), 0); 395 for (auto iter : g_info) { 396 int32_t ret = g_sensorInterface->SetBatch( 397 {0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_INTERVAL1, SENSOR_POLL_TIME); 398 EXPECT_EQ(SENSOR_SUCCESS, ret); 399 ret = g_sensorInterface->SetMode({0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_MODE_DEFAULT); 400 EXPECT_EQ(SENSOR_FAILURE, ret); 401 ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 402 EXPECT_EQ(SENSOR_SUCCESS, ret); 403 OsalMSleep(SENSOR_WAIT_TIME); 404 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 405 EXPECT_EQ(SENSOR_SUCCESS, ret); 406 } 407 } 408 409 /** 410 * @tc.name: SetSensorOption0001 411 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy. 412 * @tc.type: FUNC 413 * @tc.require: #I4L3LF 414 */ 415 HWTEST_F(HdfSensorHdiTest, SetSensorOption0001, TestSize.Level1) 416 { 417 if (g_sensorInterface == nullptr) { 418 ASSERT_NE(nullptr, g_sensorInterface); 419 return; 420 } 421 EXPECT_GT(g_info.size(), 0); 422 for (auto iter : g_info) { 423 int32_t ret = g_sensorInterface->SetOption({0, iter.deviceSensorInfo.sensorType, 0, 0}, 0); 424 EXPECT_EQ(SENSOR_SUCCESS, ret); 425 } 426 } 427 428 /** 429 * @tc.name: SetSensorOption0002 430 * @tc.desc: Sets options for the specified sensor, including its measurement range and accuracy. 431 * @tc.type: FUNC 432 * @tc.require: #I4L3LF 433 */ 434 HWTEST_F(HdfSensorHdiTest, SetSensorOption0002, TestSize.Level1) 435 { 436 if (g_sensorInterface == nullptr) { 437 ASSERT_NE(nullptr, g_sensorInterface); 438 return; 439 } 440 int32_t ret = g_sensorInterface->SetOption({0, ABNORMAL_SENSORID, 0, 0}, 0); 441 EXPECT_EQ(SENSOR_NOT_SUPPORT, ret); 442 } 443 444 /** 445 * @tc.name: ReadSensorData0001 446 * @tc.desc: Read event data for the specified sensor. 447 * @tc.type: FUNC 448 * @tc.require: #I4L3LF 449 */ 450 HWTEST_F(HdfSensorHdiTest, ReadSensorData0001, TestSize.Level1) 451 { 452 ASSERT_NE(nullptr, g_sensorInterface); 453 454 EXPECT_GT(g_info.size(), 0); 455 for (auto iter : g_info) { 456 int32_t ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 457 EXPECT_EQ(SENSOR_SUCCESS, ret); 458 OsalMSleep(SENSOR_WAIT_TIME); 459 ret = g_sensorInterface->ReadData({0, iter.deviceSensorInfo.sensorType, 0, 0}, g_events); 460 EXPECT_EQ(SENSOR_SUCCESS, ret); 461 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 462 EXPECT_EQ(SENSOR_SUCCESS, ret); 463 } 464 } 465 466 /** 467 * @tc.name: SetSdcSensor 468 * @tc.desc: Read event data for the specified sensor. 469 * @tc.type: FUNC 470 * @tc.require: #I4L3LF 471 */ 472 HWTEST_F(HdfSensorHdiTest, SetSdcSensor, TestSize.Level1) 473 { 474 ASSERT_NE(nullptr, g_sensorInterface); 475 476 EXPECT_GT(g_info.size(), 0); 477 for (auto iter : g_info) { 478 int32_t ret = g_sensorInterface->SetSdcSensor( 479 {0, iter.deviceSensorInfo.sensorType, 0, 0}, true, RATE_LEVEL); 480 EXPECT_EQ(SENSOR_SUCCESS, ret); 481 OsalMSleep(SENSOR_WAIT_TIME); 482 ret = g_sensorInterface->SetSdcSensor({0, iter.deviceSensorInfo.sensorType, 0, 0}, false, RATE_LEVEL); 483 EXPECT_EQ(SENSOR_SUCCESS, ret); 484 } 485 } 486 487 /** 488 * @tc.name: GetSdcSensorInfo 489 * @tc.desc: Read event data for the specified sensor. 490 * @tc.type: FUNC 491 * @tc.require: #I4L3LF 492 */ 493 HWTEST_F(HdfSensorHdiTest, GetSdcSensorInfo, TestSize.Level1) 494 { 495 ASSERT_NE(nullptr, g_sensorInterface); 496 497 EXPECT_GT(g_info.size(), 0); 498 std::vector<OHOS::HDI::Sensor::V3_0::SdcSensorInfo> sdcSensorInfo; 499 int32_t ret = g_sensorInterface->GetSdcSensorInfo(sdcSensorInfo); 500 EXPECT_EQ(SENSOR_SUCCESS, ret); 501 std::string infoMsg = "["; 502 for (auto it : sdcSensorInfo) { 503 if (infoMsg != "[") { 504 infoMsg += ", "; 505 } 506 infoMsg += "{"; 507 infoMsg += "offset = " + std::to_string(it.offset) + ", "; 508 infoMsg += "sensorId = " + std::to_string(it.deviceSensorInfo.sensorType) + ", "; 509 infoMsg += "ddrSize = " + std::to_string(it.ddrSize) + ", "; 510 infoMsg += "minRateLevel = " + std::to_string(it.minRateLevel) + ", "; 511 infoMsg += "maxRateLevel = " + std::to_string(it.maxRateLevel) + ", "; 512 infoMsg += "memAddr = " + std::to_string(it.memAddr) + ", "; 513 infoMsg += "reserved = " + std::to_string(it.reserved); 514 infoMsg += "}"; 515 } 516 infoMsg += "]"; 517 HDF_LOGI("%{public}s: sdcSensorInfo = %{public}s", __func__, infoMsg.c_str()); 518 } 519 520 /** 521 * @tc.name: ReportFrequencyTest0001 522 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 523 * @tc.type: FUNC 524 * @tc.require: #I4L3LF 525 */ 526 HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0001, TestSize.Level1) 527 { 528 HDF_LOGI("enter the ReportFrequencyTest0001 function"); 529 ASSERT_NE(nullptr, g_sensorInterface); 530 531 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 532 EXPECT_EQ(SENSOR_SUCCESS, ret); 533 534 EXPECT_GT(g_info.size(), 0); 535 int32_t sensorId = g_info[0].deviceSensorInfo.sensorType; 536 HDF_LOGI("sensorId is %{public}d", sensorId); 537 538 ret = g_sensorInterface->SetBatch({0, sensorId, 0, 0}, SENSOR_INTERVAL1, SENSOR_INTERVAL1); 539 EXPECT_EQ(SENSOR_SUCCESS, ret); 540 541 ret = g_sensorInterface->Enable({0, sensorId, 0, 0}); 542 EXPECT_EQ(SENSOR_SUCCESS, ret); 543 544 OsalMSleep(SENSOR_WAIT_TIME2); 545 546 ret = g_sensorInterface->Disable({0, sensorId, 0, 0}); 547 EXPECT_EQ(SENSOR_SUCCESS, ret); 548 549 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 550 EXPECT_EQ(SENSOR_SUCCESS, ret); 551 552 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 553 SensorCallbackImpl::sensorDataFlag = 1; 554 } 555 556 /** 557 * @tc.name: ReportFrequencyTest0002 558 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 559 * @tc.type: FUNC 560 * @tc.require: #I4L3LF 561 */ 562 HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0002, TestSize.Level1) 563 { 564 HDF_LOGI("enter the ReportFrequencyTest0002 function"); 565 ASSERT_NE(nullptr, g_sensorInterface); 566 567 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 568 EXPECT_EQ(SENSOR_SUCCESS, ret); 569 570 EXPECT_GT(g_info.size(), 0); 571 int32_t sensorId = g_info[0].deviceSensorInfo.sensorType; 572 HDF_LOGI("sensorId is %{public}d", sensorId); 573 574 ret = g_sensorInterface->SetBatch({0, sensorId, 0, 0}, SENSOR_INTERVAL3, SENSOR_INTERVAL1); 575 EXPECT_EQ(SENSOR_SUCCESS, ret); 576 577 ret = g_sensorInterface->Enable({0, sensorId, 0, 0}); 578 EXPECT_EQ(SENSOR_SUCCESS, ret); 579 580 OsalMSleep(SENSOR_WAIT_TIME2); 581 582 ret = g_sensorInterface->Disable({0, sensorId, 0, 0}); 583 EXPECT_EQ(SENSOR_SUCCESS, ret); 584 585 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 586 EXPECT_EQ(SENSOR_SUCCESS, ret); 587 588 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 589 SensorCallbackImpl::sensorDataFlag = 1; 590 } 591 592 /** 593 * @tc.name: ReportFrequencyTest0003 594 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 595 * @tc.type: FUNC 596 * @tc.require: #I4L3LF 597 */ 598 HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0003, TestSize.Level1) 599 { 600 HDF_LOGI("enter the ReportFrequencyTest0003 function"); 601 ASSERT_NE(nullptr, g_sensorInterface); 602 603 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 604 EXPECT_EQ(SENSOR_SUCCESS, ret); 605 606 EXPECT_GT(g_info.size(), 0); 607 int32_t sensorId = g_info[0].deviceSensorInfo.sensorType; 608 HDF_LOGI("sensorId is %{public}d", sensorId); 609 610 ret = g_sensorInterface->SetBatch({0, sensorId, 0, 0}, SENSOR_INTERVAL4, SENSOR_INTERVAL1); 611 EXPECT_EQ(SENSOR_SUCCESS, ret); 612 613 ret = g_sensorInterface->Enable({0, sensorId, 0, 0}); 614 EXPECT_EQ(SENSOR_SUCCESS, ret); 615 616 OsalMSleep(SENSOR_WAIT_TIME2); 617 618 ret = g_sensorInterface->Disable({0, sensorId, 0, 0}); 619 EXPECT_EQ(SENSOR_SUCCESS, ret); 620 621 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 622 EXPECT_EQ(SENSOR_SUCCESS, ret); 623 624 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 625 SensorCallbackImpl::sensorDataFlag = 1; 626 } 627 628 /** 629 * @tc.name: SetSdcSensor_001 630 * @tc.desc: Read event data for the specified sensor. 631 * @tc.type: FUNC 632 * @tc.require: #I4L3LF 633 */ 634 HWTEST_F(HdfSensorHdiTest, SetSdcSensor_001, TestSize.Level1) 635 { 636 SENSOR_TRACE; 637 HDF_LOGI("enter the SetSdcSensor_001 function"); 638 ASSERT_NE(nullptr, g_sensorInterface); 639 int32_t ret; 640 EXPECT_GT(g_info.size(), 0); 641 for (auto iter : g_info) { 642 ret = g_sensorInterface->SetSdcSensor({0, iter.deviceSensorInfo.sensorType, 0, 0}, true, RATE_LEVEL); 643 EXPECT_EQ(SENSOR_SUCCESS, ret); 644 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 645 EXPECT_EQ(SENSOR_SUCCESS, ret); 646 ret = g_sensorInterface->SetSdcSensor({0, iter.deviceSensorInfo.sensorType, 0, 0}, false, RATE_LEVEL); 647 EXPECT_EQ(SENSOR_SUCCESS, ret); 648 } 649 } 650 651 /** 652 * @tc.name: EnableButUnregisterTest 653 * @tc.desc: Read event data for the specified sensor. 654 * @tc.type: FUNC 655 * @tc.require: #I4L3LF 656 */ 657 HWTEST_F(HdfSensorHdiTest, EnableButUnregisterTest, TestSize.Level1) 658 { 659 SENSOR_TRACE; 660 ASSERT_NE(nullptr, g_sensorInterface); 661 HDF_LOGI("enter the EnableButUnregisterTest function"); 662 663 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 664 EXPECT_EQ(SENSOR_SUCCESS, ret); 665 EXPECT_GT(g_info.size(), 0); 666 for (auto iter : g_info) { 667 int32_t ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 668 EXPECT_EQ(SENSOR_SUCCESS, ret); 669 } 670 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 671 EXPECT_EQ(SENSOR_SUCCESS, ret); 672 OsalMSleep(SENSOR_WAIT_TIME2); 673 for (auto iter : g_info) { 674 int32_t ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 675 EXPECT_EQ(SENSOR_SUCCESS, ret); 676 } 677 } 678 679 /** 680 * @tc.name: SensorCallbackImplFailureTest 681 * @tc.desc: Read event data for the specified sensor. 682 * @tc.type: FUNC 683 * @tc.require: #I4L3LF 684 */ 685 HWTEST_F(HdfSensorHdiTest, SensorCallbackImplFailureTest, TestSize.Level1) 686 { 687 SENSOR_TRACE; 688 ASSERT_NE(nullptr, g_sensorInterface); 689 HDF_LOGI("enter the SensorCallbackImplFailureTest function"); 690 691 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallbackTest); 692 EXPECT_EQ(SENSOR_SUCCESS, ret); 693 EXPECT_GT(g_info.size(), 0); 694 for (auto iter : g_info) { 695 int32_t ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 696 EXPECT_EQ(SENSOR_SUCCESS, ret); 697 } 698 OsalMSleep(SENSOR_WAIT_TIME2); 699 for (auto iter : g_info) { 700 int32_t ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 701 EXPECT_EQ(SENSOR_SUCCESS, ret); 702 } 703 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 704 EXPECT_EQ(SENSOR_SUCCESS, ret); 705 } 706 707 /** 708 * @tc.name: V3_0_EnableSensor 709 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 710 * @tc.type: FUNC 711 * @tc.require: #I4L3LF 712 */ 713 HWTEST_F(HdfSensorHdiTest, V3_0_EnableSensor, TestSize.Level1) 714 { 715 HDF_LOGI("enter the V3_0_EnableSensor function"); 716 ASSERT_NE(nullptr, g_sensorInterface); 717 718 int32_t ret = g_sensorInterface->RegisterAsync(TRADITIONAL_SENSOR_TYPE, g_traditionalCallbackTest); 719 EXPECT_EQ(SENSOR_SUCCESS, ret); 720 721 for (auto iter : g_info) { 722 ret = g_sensorInterface->SetBatch( 723 {0, iter.deviceSensorInfo.sensorType, 0, 0}, SENSOR_INTERVAL1, SENSOR_POLL_TIME); 724 EXPECT_EQ(SENSOR_SUCCESS, ret); 725 ret = g_sensorInterface->Enable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 726 EXPECT_EQ(SENSOR_SUCCESS, ret); 727 } 728 729 OsalMSleep(SENSOR_WAIT_TIME2); 730 731 for (auto iter : g_info) { 732 ret = g_sensorInterface->Disable({0, iter.deviceSensorInfo.sensorType, 0, 0}); 733 EXPECT_EQ(SENSOR_SUCCESS, ret); 734 } 735 ret = g_sensorInterface->UnregisterAsync(TRADITIONAL_SENSOR_TYPE, g_traditionalCallbackTest); 736 EXPECT_EQ(SENSOR_SUCCESS, ret); 737 } 738 739 /** 740 * @tc.name: ReportFrequencyTest0003 741 * @tc.desc: Sets the sampling time and data report interval for sensors in batches. 742 * @tc.type: FUNC 743 * @tc.require: #I4L3LF 744 */ 745 HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0032, TestSize.Level1) 746 { 747 HDF_LOGI("enter the ReportFrequencyTest0032 function"); 748 ASSERT_NE(nullptr, g_sensorInterface); 749 750 int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 751 752 EXPECT_EQ(SENSOR_SUCCESS, ret); 753 754 EXPECT_GT(g_info.size(), 0); 755 756 int32_t sensorId = 1; 757 HDF_LOGI("sensorId is %{public}d", sensorId); 758 759 ret = g_sensorInterface->SetBatch({0, sensorId, 0, 0}, SENSOR_INTERVAL5, SENSOR_INTERVAL1); 760 EXPECT_EQ(SENSOR_SUCCESS, ret); 761 762 ret = g_sensorInterface->Enable({0, sensorId, 0, 0}); 763 EXPECT_EQ(SENSOR_SUCCESS, ret); 764 765 OsalMSleep(SENSOR_WAIT_TIME3); 766 767 ret = g_sensorInterface->Disable({0, sensorId, 0, 0}); 768 EXPECT_EQ(SENSOR_SUCCESS, ret); 769 770 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); 771 EXPECT_EQ(SENSOR_SUCCESS, ret); 772 773 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); 774 SensorCallbackImpl::sensorDataFlag = 1; 775 } 776 777 /** 778 * @tc.name: SetSdcSensorTest1_1 779 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 780 * @tc.type: FUNC 781 * @tc.require: #I4L3LF 782 */ 783 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest1_1, TestSize.Level1) 784 { 785 HDF_LOGI("enter the SetSdcSensorTest1_1 function"); 786 ASSERT_NE(nullptr, g_sensorInterface); 787 788 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, true, 10); 789 EXPECT_EQ(SENSOR_SUCCESS, ret); 790 OsalMSleep(2000); 791 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 792 EXPECT_EQ(SENSOR_SUCCESS, ret); 793 } 794 795 /** 796 * @tc.name: SetSdcSensorTest1_2 797 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 798 * @tc.type: FUNC 799 * @tc.require: #I4L3LF 800 */ 801 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest1_2, TestSize.Level1) 802 { 803 HDF_LOGI("enter the SetSdcSensorTest1_2 function"); 804 ASSERT_NE(nullptr, g_sensorInterface); 805 806 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, true, 20); 807 EXPECT_EQ(SENSOR_SUCCESS, ret); 808 OsalMSleep(2000); 809 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 810 EXPECT_EQ(SENSOR_SUCCESS, ret); 811 } 812 813 /** 814 * @tc.name: SetSdcSensorTest1_3 815 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 816 * @tc.type: FUNC 817 * @tc.require: #I4L3LF 818 */ 819 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest1_3, TestSize.Level1) 820 { 821 HDF_LOGI("enter the SetSdcSensorTest1_3 function"); 822 ASSERT_NE(nullptr, g_sensorInterface); 823 824 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, true, 50); 825 EXPECT_EQ(SENSOR_SUCCESS, ret); 826 OsalMSleep(2000); 827 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 828 EXPECT_EQ(SENSOR_SUCCESS, ret); 829 } 830 831 /** 832 * @tc.name: SetSdcSensorTest2_1 833 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 834 * @tc.type: FUNC 835 * @tc.require: #I4L3LF 836 */ 837 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest2_1, TestSize.Level1) 838 { 839 HDF_LOGI("enter the SetSdcSensorTest2_1 function"); 840 ASSERT_NE(nullptr, g_sensorInterface); 841 842 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, true, 10); 843 EXPECT_EQ(SENSOR_SUCCESS, ret); 844 OsalMSleep(2000); 845 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 846 EXPECT_EQ(SENSOR_SUCCESS, ret); 847 } 848 849 /** 850 * @tc.name: SetSdcSensorTest2_2 851 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 852 * @tc.type: FUNC 853 * @tc.require: #I4L3LF 854 */ 855 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest2_2, TestSize.Level1) 856 { 857 HDF_LOGI("enter the SetSdcSensorTest2_2 function"); 858 ASSERT_NE(nullptr, g_sensorInterface); 859 860 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, true, 20); 861 EXPECT_EQ(SENSOR_SUCCESS, ret); 862 OsalMSleep(2000); 863 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 864 EXPECT_EQ(SENSOR_SUCCESS, ret); 865 } 866 867 /** 868 * @tc.name: SetSdcSensorTest2_3 869 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 870 * @tc.type: FUNC 871 * @tc.require: #I4L3LF 872 */ 873 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest2_3, TestSize.Level1) 874 { 875 HDF_LOGI("enter the SetSdcSensorTest2_3 function"); 876 ASSERT_NE(nullptr, g_sensorInterface); 877 878 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 50); 879 EXPECT_EQ(SENSOR_SUCCESS, ret); 880 OsalMSleep(2000); 881 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 882 EXPECT_EQ(SENSOR_SUCCESS, ret); 883 } 884 885 /** 886 * @tc.name: SetSdcSensorTest3_1 887 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 888 * @tc.type: FUNC 889 * @tc.require: #I4L3LF 890 */ 891 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest3_1, TestSize.Level1) 892 { 893 HDF_LOGI("enter the SetSdcSensorTest3_1 function"); 894 ASSERT_NE(nullptr, g_sensorInterface); 895 896 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 897 EXPECT_EQ(SENSOR_SUCCESS, ret); 898 OsalMSleep(2000); 899 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 900 EXPECT_EQ(SENSOR_SUCCESS, ret); 901 } 902 903 /** 904 * @tc.name: SetSdcSensorTest3_2 905 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 906 * @tc.type: FUNC 907 * @tc.require: #I4L3LF 908 */ 909 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest3_2, TestSize.Level1) 910 { 911 HDF_LOGI("enter the SetSdcSensorTest3_2 function"); 912 ASSERT_NE(nullptr, g_sensorInterface); 913 914 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 915 EXPECT_EQ(SENSOR_SUCCESS, ret); 916 OsalMSleep(2000); 917 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 918 EXPECT_EQ(SENSOR_SUCCESS, ret); 919 } 920 921 /** 922 * @tc.name: SetSdcSensorTest3_3 923 * @tc.desc: Enables the sensor unavailable in the sensor list based on the specified sensor ID. 924 * @tc.type: FUNC 925 * @tc.require: #I4L3LF 926 */ 927 HWTEST_F(HdfSensorHdiTest, SetSdcSensorTest3_3, TestSize.Level1) 928 { 929 HDF_LOGI("enter the SetSdcSensorTest3_3 function"); 930 ASSERT_NE(nullptr, g_sensorInterface); 931 932 int32_t ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 933 EXPECT_EQ(SENSOR_SUCCESS, ret); 934 OsalMSleep(2000); 935 ret = g_sensorInterface->SetSdcSensor({0, 1, 0, 0}, false, 10); 936 EXPECT_EQ(SENSOR_SUCCESS, ret); 937 } 938 }