Home | History | Annotate | Download | only in functional 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "sensors_hidl_hal_test"
     18 #include <VtsHalHidlTargetTestBase.h>
     19 #include <android-base/logging.h>
     20 #include <android/hardware/sensors/1.0/ISensors.h>
     21 #include <android/hardware/sensors/1.0/types.h>
     22 #include <cutils/ashmem.h>
     23 #include <hardware/sensors.h>  // for sensor type strings
     24 #include <log/log.h>
     25 #include <utils/SystemClock.h>
     26 
     27 #include <algorithm>
     28 #include <cinttypes>
     29 #include <cmath>
     30 #include <memory>
     31 #include <mutex>
     32 #include <thread>
     33 #include <unordered_set>
     34 #include <vector>
     35 
     36 #include <sys/mman.h>
     37 #include <unistd.h>
     38 
     39 using ::android::hardware::Return;
     40 using ::android::hardware::Void;
     41 using ::android::hardware::hidl_string;
     42 using ::android::sp;
     43 using namespace ::android::hardware::sensors::V1_0;
     44 
     45 // Test environment for sensors
     46 class SensorsHidlTest;
     47 class SensorsHidlEnvironment : public ::testing::Environment {
     48  public:
     49   // get the test environment singleton
     50   static SensorsHidlEnvironment* Instance() {
     51     static SensorsHidlEnvironment* instance = new SensorsHidlEnvironment;
     52     return instance;
     53   }
     54 
     55   virtual void SetUp();
     56   virtual void TearDown();
     57 
     58   // Get and clear all events collected so far (like "cat" shell command).
     59   // If output is nullptr, it clears all collected events.
     60   void catEvents(std::vector<Event>* output);
     61 
     62   // set sensor event collection status
     63   void setCollection(bool enable);
     64 
     65  private:
     66   friend SensorsHidlTest;
     67   // sensors hidl service
     68   sp<ISensors> sensors;
     69 
     70   SensorsHidlEnvironment() {}
     71 
     72   void addEvent(const Event& ev);
     73   void startPollingThread();
     74   void resetHal();
     75   static void pollingThread(SensorsHidlEnvironment* env, std::shared_ptr<bool> stop);
     76 
     77   bool collectionEnabled;
     78   std::shared_ptr<bool> stopThread;
     79   std::thread pollThread;
     80   std::vector<Event> events;
     81   std::mutex events_mutex;
     82 
     83   GTEST_DISALLOW_COPY_AND_ASSIGN_(SensorsHidlEnvironment);
     84 };
     85 
     86 void SensorsHidlEnvironment::SetUp() {
     87   resetHal();
     88 
     89   ASSERT_NE(sensors, nullptr) << "sensors is nullptr, cannot get hidl service";
     90 
     91   collectionEnabled = false;
     92   startPollingThread();
     93 
     94   // In case framework just stopped for test and there is sensor events in the pipe,
     95   // wait some time for those events to be cleared to avoid them messing up the test.
     96   std::this_thread::sleep_for(std::chrono::seconds(3));
     97 }
     98 
     99 void SensorsHidlEnvironment::TearDown() {
    100   if (stopThread) {
    101     *stopThread = true;
    102   }
    103   pollThread.detach();
    104 }
    105 
    106 void SensorsHidlEnvironment::resetHal() {
    107   // wait upto 100ms * 10 = 1s for hidl service.
    108   constexpr auto RETRY_DELAY = std::chrono::milliseconds(100);
    109 
    110   std::string step;
    111   bool succeed = false;
    112   for (size_t retry = 10; retry > 0; --retry) {
    113     // this do ... while is for easy error handling
    114     do {
    115       step = "getService()";
    116       sensors = ISensors::getService();
    117       if (sensors == nullptr) {
    118         break;
    119       }
    120 
    121       step = "poll() check";
    122       // Poke ISensor service. If it has lingering connection from previous generation of
    123       // system server, it will kill itself. There is no intention to handle the poll result,
    124       // which will be done since the size is 0.
    125       if(!sensors->poll(0, [](auto, const auto &, const auto &) {}).isOk()) {
    126         break;
    127       }
    128 
    129       step = "getSensorList";
    130       std::vector<SensorInfo> sensorList;
    131       if (!sensors->getSensorsList(
    132           [&] (const ::android::hardware::hidl_vec<SensorInfo> &list) {
    133             sensorList.reserve(list.size());
    134             for (size_t i = 0; i < list.size(); ++i) {
    135               sensorList.push_back(list[i]);
    136             }
    137           }).isOk()) {
    138         break;
    139       }
    140 
    141       // stop each sensor individually
    142       step = "stop each sensor";
    143       bool ok = true;
    144       for (const auto &i : sensorList) {
    145         if (!sensors->activate(i.sensorHandle, false).isOk()) {
    146           ok = false;
    147           break;
    148         }
    149       }
    150       if (!ok) {
    151         break;
    152       }
    153 
    154       // mark it done
    155       step = "done";
    156       succeed = true;
    157     } while(0);
    158 
    159     if (succeed) {
    160       return;
    161     }
    162 
    163     // Delay 100ms before retry, hidl service is expected to come up in short time after crash.
    164     ALOGI("%s unsuccessful, try again soon (remaining retry %zu).", step.c_str(), retry - 1);
    165     std::this_thread::sleep_for(RETRY_DELAY);
    166   }
    167 
    168   sensors = nullptr;
    169 }
    170 
    171 void SensorsHidlEnvironment::catEvents(std::vector<Event>* output) {
    172   std::lock_guard<std::mutex> lock(events_mutex);
    173   if (output) {
    174     output->insert(output->end(), events.begin(), events.end());
    175   }
    176   events.clear();
    177 }
    178 
    179 void SensorsHidlEnvironment::setCollection(bool enable) {
    180   std::lock_guard<std::mutex> lock(events_mutex);
    181   collectionEnabled = enable;
    182 }
    183 
    184 void SensorsHidlEnvironment::addEvent(const Event& ev) {
    185   std::lock_guard<std::mutex> lock(events_mutex);
    186   if (collectionEnabled) {
    187     events.push_back(ev);
    188   }
    189 }
    190 
    191 void SensorsHidlEnvironment::startPollingThread() {
    192   stopThread = std::shared_ptr<bool>(new bool(false));
    193   pollThread = std::thread(pollingThread, this, stopThread);
    194   events.reserve(128);
    195 }
    196 
    197 void SensorsHidlEnvironment::pollingThread(
    198     SensorsHidlEnvironment* env, std::shared_ptr<bool> stop) {
    199   ALOGD("polling thread start");
    200   bool needExit = *stop;
    201 
    202   while(!needExit) {
    203       env->sensors->poll(64, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) {
    204           if (result != Result::OK
    205               || (events.size() == 0 && dynamicSensorsAdded.size() == 0)
    206               || *stop) {
    207               needExit = true;
    208               return;
    209           }
    210 
    211           for (const auto& e : events) {
    212               env->addEvent(e);
    213           }
    214       });
    215   }
    216   ALOGD("polling thread end");
    217 }
    218 
    219 class SensorsTestSharedMemory {
    220  public:
    221   static SensorsTestSharedMemory* create(SharedMemType type, size_t size);
    222   SharedMemInfo getSharedMemInfo() const;
    223   char * getBuffer() const;
    224   std::vector<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
    225   virtual ~SensorsTestSharedMemory();
    226  private:
    227   SensorsTestSharedMemory(SharedMemType type, size_t size);
    228 
    229   SharedMemType mType;
    230   native_handle_t* mNativeHandle;
    231   size_t mSize;
    232   char* mBuffer;
    233 
    234   DISALLOW_COPY_AND_ASSIGN(SensorsTestSharedMemory);
    235 };
    236 
    237 SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const {
    238   SharedMemInfo mem = {
    239     .type = mType,
    240     .format = SharedMemFormat::SENSORS_EVENT,
    241     .size = static_cast<uint32_t>(mSize),
    242     .memoryHandle = mNativeHandle
    243   };
    244   return mem;
    245 }
    246 
    247 char * SensorsTestSharedMemory::getBuffer() const {
    248   return mBuffer;
    249 }
    250 
    251 std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const {
    252 
    253   constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
    254   constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD);
    255   constexpr size_t kOffsetToken = static_cast<size_t>(SensorsEventFormatOffset::REPORT_TOKEN);
    256   constexpr size_t kOffsetType = static_cast<size_t>(SensorsEventFormatOffset::SENSOR_TYPE);
    257   constexpr size_t kOffsetAtomicCounter =
    258       static_cast<size_t>(SensorsEventFormatOffset::ATOMIC_COUNTER);
    259   constexpr size_t kOffsetTimestamp = static_cast<size_t>(SensorsEventFormatOffset::TIMESTAMP);
    260   constexpr size_t kOffsetData = static_cast<size_t>(SensorsEventFormatOffset::DATA);
    261 
    262   std::vector<Event> events;
    263   std::vector<float> data(16);
    264 
    265   while (offset + kEventSize <= mSize) {
    266     int64_t atomicCounter = *reinterpret_cast<uint32_t *>(mBuffer + offset + kOffsetAtomicCounter);
    267     if (atomicCounter <= lastCounter) {
    268       break;
    269     }
    270 
    271     int32_t size = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetSize);
    272     if (size != kEventSize) {
    273       // unknown error, events parsed may be wrong, remove all
    274       events.clear();
    275       break;
    276     }
    277 
    278     int32_t token = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetToken);
    279     int32_t type = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetType);
    280     int64_t timestamp = *reinterpret_cast<int64_t *>(mBuffer + offset + kOffsetTimestamp);
    281 
    282     ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32 ", timestamp %" PRId64,
    283         offset, atomicCounter, token, type, timestamp);
    284 
    285     Event event = {
    286       .timestamp = timestamp,
    287       .sensorHandle = token,
    288       .sensorType = static_cast<SensorType>(type),
    289     };
    290     event.u.data = android::hardware::hidl_array<float, 16>
    291         (reinterpret_cast<float*>(mBuffer + offset + kOffsetData));
    292 
    293     events.push_back(event);
    294 
    295     lastCounter = atomicCounter;
    296     offset += kEventSize;
    297   }
    298 
    299   return events;
    300 }
    301 
    302 SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size)
    303     : mType(type), mSize(0), mBuffer(nullptr) {
    304   native_handle_t *handle = nullptr;
    305   char *buffer = nullptr;
    306   switch(type) {
    307     case SharedMemType::ASHMEM: {
    308       int fd;
    309       handle = ::native_handle_create(1 /*nFds*/, 0/*nInts*/);
    310       if (handle != nullptr) {
    311         handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size);
    312         if (handle->data[0] > 0) {
    313           // memory is pinned by default
    314           buffer = static_cast<char *>
    315               (::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
    316           if (buffer != reinterpret_cast<char*>(MAP_FAILED)) {
    317             break;
    318           }
    319           ::native_handle_close(handle);
    320         }
    321         ::native_handle_delete(handle);
    322         handle = nullptr;
    323       }
    324       break;
    325     }
    326     case SharedMemType::GRALLOC: {
    327 
    328       break;
    329     }
    330     default:
    331       break;
    332   }
    333 
    334   if (buffer != nullptr) {
    335     mNativeHandle = handle;
    336     mSize = size;
    337     mBuffer = buffer;
    338   }
    339 }
    340 
    341 SensorsTestSharedMemory::~SensorsTestSharedMemory() {
    342   switch(mType) {
    343     case SharedMemType::ASHMEM: {
    344       if (mSize != 0) {
    345         ::munmap(mBuffer, mSize);
    346         mBuffer = nullptr;
    347 
    348         ::native_handle_close(mNativeHandle);
    349         ::native_handle_delete(mNativeHandle);
    350 
    351         mNativeHandle = nullptr;
    352         mSize = 0;
    353       }
    354       break;
    355     }
    356     default: {
    357       if (mNativeHandle != nullptr || mSize != 0 || mBuffer != nullptr) {
    358         ALOGE("SensorsTestSharedMemory %p not properly destructed: "
    359             "type %d, native handle %p, size %zu, buffer %p",
    360             this, static_cast<int>(mType), mNativeHandle, mSize, mBuffer);
    361       }
    362       break;
    363     }
    364   }
    365 }
    366 
    367 SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) {
    368   constexpr size_t kMaxSize = 128*1024*1024; // sensor test should not need more than 128M
    369   if (size == 0 || size >= kMaxSize) {
    370     return nullptr;
    371   }
    372 
    373   auto m = new SensorsTestSharedMemory(type, size);
    374   if (m->mSize != size || m->mBuffer == nullptr) {
    375     delete m;
    376     m = nullptr;
    377   }
    378   return m;
    379 }
    380 
    381 class SensorEventsChecker {
    382  public:
    383   virtual bool check(const std::vector<Event> &events, std::string *out) const = 0;
    384   virtual ~SensorEventsChecker() {}
    385 };
    386 
    387 class NullChecker : public SensorEventsChecker {
    388  public:
    389   virtual bool check(const std::vector<Event> &, std::string *) const {
    390     return true;
    391   }
    392 };
    393 
    394 class SensorEventPerEventChecker : public SensorEventsChecker {
    395  public:
    396   virtual bool checkEvent(const Event &event, std::string *out) const = 0;
    397   virtual bool check(const std::vector<Event> &events, std::string *out) const {
    398     for (const auto &e : events) {
    399       if (!checkEvent(e, out)) {
    400         return false;
    401       }
    402     }
    403     return true;
    404   }
    405 };
    406 
    407 class Vec3NormChecker : public SensorEventPerEventChecker {
    408  public:
    409   Vec3NormChecker(float min, float max) : mRange(min, max) {}
    410   static Vec3NormChecker byNominal(float nominal, float allowedError) {
    411     return Vec3NormChecker(nominal - allowedError, nominal + allowedError);
    412   }
    413 
    414   virtual bool checkEvent(const Event &event, std::string *out) const {
    415     Vec3 v = event.u.vec3;
    416     float norm = std::sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
    417     if (norm < mRange.first || norm > mRange.second) {
    418       if (out != nullptr) {
    419         std::ostringstream ss;
    420         ss << "Event @ " << event.timestamp << " (" << v.x << ", " << v.y << ", " << v.z << ")"
    421            << " has norm " << norm << ", which is beyond range"
    422            << " [" << mRange.first << ", " << mRange.second << "]";
    423         *out = ss.str();
    424       }
    425       return false;
    426     }
    427     return true;
    428   }
    429  protected:
    430   std::pair<float, float> mRange;
    431 };
    432 
    433 // The main test class for SENSORS HIDL HAL.
    434 class SensorsHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    435  public:
    436   virtual void SetUp() override {
    437   }
    438 
    439   virtual void TearDown() override {
    440     // stop all sensors
    441     for (auto s : mSensorHandles) {
    442       S()->activate(s, false);
    443     }
    444     mSensorHandles.clear();
    445 
    446     // stop all direct report and channels
    447     for (auto c : mDirectChannelHandles) {
    448       // disable all reports
    449       S()->configDirectReport(-1, c, RateLevel::STOP, [] (auto, auto){});
    450       S()->unregisterDirectChannel(c);
    451     }
    452     mDirectChannelHandles.clear();
    453   }
    454 
    455  protected:
    456   SensorInfo defaultSensorByType(SensorType type);
    457   std::vector<SensorInfo> getSensorsList();
    458   std::vector<Event> collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
    459         bool clearBeforeStart = true, bool changeCollection = true);
    460 
    461   // implementation wrapper
    462   Return<void> getSensorsList(ISensors::getSensorsList_cb _hidl_cb) {
    463     return S()->getSensorsList(_hidl_cb);
    464   }
    465 
    466   Return<Result> activate(
    467           int32_t sensorHandle, bool enabled);
    468 
    469   Return<Result> batch(
    470           int32_t sensorHandle,
    471           int64_t samplingPeriodNs,
    472           int64_t maxReportLatencyNs) {
    473     return S()->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
    474   }
    475 
    476   Return<Result> flush(int32_t sensorHandle) {
    477     return S()->flush(sensorHandle);
    478   }
    479 
    480   Return<Result> injectSensorData(const Event& event) {
    481     return S()->injectSensorData(event);
    482   }
    483 
    484   Return<void> registerDirectChannel(
    485           const SharedMemInfo& mem, ISensors::registerDirectChannel_cb _hidl_cb);
    486 
    487   Return<Result> unregisterDirectChannel(int32_t channelHandle) {
    488     return S()->unregisterDirectChannel(channelHandle);
    489   }
    490 
    491   Return<void> configDirectReport(
    492           int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
    493           ISensors::configDirectReport_cb _hidl_cb) {
    494     return S()->configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb);
    495   }
    496 
    497   inline sp<ISensors>& S() {
    498     return SensorsHidlEnvironment::Instance()->sensors;
    499   }
    500 
    501   inline static SensorFlagBits extractReportMode(uint64_t flag) {
    502     return (SensorFlagBits) (flag
    503         & ((uint64_t) SensorFlagBits::CONTINUOUS_MODE
    504           | (uint64_t) SensorFlagBits::ON_CHANGE_MODE
    505           | (uint64_t) SensorFlagBits::ONE_SHOT_MODE
    506           | (uint64_t) SensorFlagBits::SPECIAL_REPORTING_MODE));
    507   }
    508 
    509   inline static bool isMetaSensorType(SensorType type) {
    510     return (type == SensorType::META_DATA
    511             || type == SensorType::DYNAMIC_SENSOR_META
    512             || type == SensorType::ADDITIONAL_INFO);
    513   }
    514 
    515   inline static bool isValidType(SensorType type) {
    516     return (int32_t) type > 0;
    517   }
    518 
    519   void testStreamingOperation(SensorType type,
    520                               std::chrono::nanoseconds samplingPeriod,
    521                               std::chrono::seconds duration,
    522                               const SensorEventsChecker &checker);
    523   void testSamplingRateHotSwitchOperation(SensorType type);
    524   void testBatchingOperation(SensorType type);
    525   void testDirectReportOperation(
    526       SensorType type, SharedMemType memType, RateLevel rate, const SensorEventsChecker &checker);
    527 
    528   static void assertTypeMatchStringType(SensorType type, const hidl_string& stringType);
    529   static void assertTypeMatchReportMode(SensorType type, SensorFlagBits reportMode);
    530   static void assertDelayMatchReportMode(
    531           int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode);
    532   static SensorFlagBits expectedReportModeForType(SensorType type);
    533   static bool isDirectReportRateSupported(SensorInfo sensor, RateLevel rate);
    534   static bool isDirectChannelTypeSupported(SensorInfo sensor, SharedMemType type);
    535 
    536   // checkers
    537   static const Vec3NormChecker sAccelNormChecker;
    538   static const Vec3NormChecker sGyroNormChecker;
    539 
    540   // all sensors and direct channnels used
    541   std::unordered_set<int32_t> mSensorHandles;
    542   std::unordered_set<int32_t> mDirectChannelHandles;
    543 };
    544 
    545 const Vec3NormChecker SensorsHidlTest::sAccelNormChecker(
    546         Vec3NormChecker::byNominal(GRAVITY_EARTH, 1.0f/*m/s^2*/));
    547 const Vec3NormChecker SensorsHidlTest::sGyroNormChecker(
    548         Vec3NormChecker::byNominal(0.f, 0.1f/*rad/s*/));
    549 
    550 Return<Result> SensorsHidlTest::activate(int32_t sensorHandle, bool enabled) {
    551   // If activating a sensor, add the handle in a set so that when test fails it can be turned off.
    552   // The handle is not removed when it is deactivating on purpose so that it is not necessary to
    553   // check the return value of deactivation. Deactivating a sensor more than once does not have
    554   // negative effect.
    555   if (enabled) {
    556     mSensorHandles.insert(sensorHandle);
    557   }
    558   return S()->activate(sensorHandle, enabled);
    559 }
    560 
    561 Return<void> SensorsHidlTest::registerDirectChannel(
    562     const SharedMemInfo& mem, ISensors::registerDirectChannel_cb cb) {
    563   // If registeration of a channel succeeds, add the handle of channel to a set so that it can be
    564   // unregistered when test fails. Unregister a channel does not remove the handle on purpose.
    565   // Unregistering a channel more than once should not have negative effect.
    566   S()->registerDirectChannel(mem,
    567       [&] (auto result, auto channelHandle) {
    568         if (result == Result::OK) {
    569           mDirectChannelHandles.insert(channelHandle);
    570         }
    571         cb(result, channelHandle);
    572       });
    573   return Void();
    574 }
    575 
    576 std::vector<Event> SensorsHidlTest::collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
    577       bool clearBeforeStart, bool changeCollection) {
    578   std::vector<Event> events;
    579   constexpr useconds_t SLEEP_GRANULARITY = 100*1000; //granularity 100 ms
    580 
    581   ALOGI("collect max of %zu events for %d us, clearBeforeStart %d",
    582         nEventLimit, timeLimitUs, clearBeforeStart);
    583 
    584   if (changeCollection) {
    585     SensorsHidlEnvironment::Instance()->setCollection(true);
    586   }
    587   if (clearBeforeStart) {
    588     SensorsHidlEnvironment::Instance()->catEvents(nullptr);
    589   }
    590 
    591   while (timeLimitUs > 0) {
    592     useconds_t duration = std::min(SLEEP_GRANULARITY, timeLimitUs);
    593     usleep(duration);
    594     timeLimitUs -= duration;
    595 
    596     SensorsHidlEnvironment::Instance()->catEvents(&events);
    597     if (events.size() >= nEventLimit) {
    598       break;
    599     }
    600     ALOGV("time to go = %d, events to go = %d",
    601           (int)timeLimitUs, (int)(nEventLimit - events.size()));
    602   }
    603 
    604   if (changeCollection) {
    605     SensorsHidlEnvironment::Instance()->setCollection(false);
    606   }
    607   return events;
    608 }
    609 
    610 void SensorsHidlTest::assertTypeMatchStringType(SensorType type, const hidl_string& stringType) {
    611 
    612   if (type >= SensorType::DEVICE_PRIVATE_BASE) {
    613     return;
    614   }
    615 
    616   switch (type) {
    617 #define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \
    618     case SensorType::type: ASSERT_STREQ(SENSOR_STRING_TYPE_ ## type, stringType.c_str()); break;
    619     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
    620     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED);
    621     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
    622     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE);
    623     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION);
    624     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META);
    625     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR);
    626     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR);
    627     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE);
    628     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY);
    629     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE);
    630     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED);
    631     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT);
    632     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE);
    633     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT);
    634     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION);
    635     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT);
    636     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD);
    637     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED);
    638     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT);
    639     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION);
    640     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE);
    641     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF);
    642     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE);
    643     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY);
    644     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY);
    645     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR);
    646     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION);
    647     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT);
    648     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER);
    649     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR);
    650     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TEMPERATURE);
    651     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR);
    652     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE);
    653     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE);
    654     default:
    655       FAIL() << "Type " << static_cast<int>(type) << " in android defined range is not checked, "
    656              << "stringType = " << stringType;
    657 #undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE
    658   }
    659 }
    660 
    661 void SensorsHidlTest::assertTypeMatchReportMode(SensorType type, SensorFlagBits reportMode) {
    662   if (type >= SensorType::DEVICE_PRIVATE_BASE) {
    663     return;
    664   }
    665 
    666   SensorFlagBits expected = expectedReportModeForType(type);
    667 
    668   ASSERT_TRUE(expected == (SensorFlagBits) -1 || expected == reportMode)
    669       << "reportMode=" << static_cast<int>(reportMode)
    670       << "expected=" << static_cast<int>(expected);
    671 }
    672 
    673 void SensorsHidlTest::assertDelayMatchReportMode(
    674     int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode) {
    675   switch(reportMode) {
    676     case SensorFlagBits::CONTINUOUS_MODE:
    677       ASSERT_LT(0, minDelay);
    678       ASSERT_LE(0, maxDelay);
    679       break;
    680     case SensorFlagBits::ON_CHANGE_MODE:
    681       ASSERT_LE(0, minDelay);
    682       ASSERT_LE(0, maxDelay);
    683       break;
    684     case SensorFlagBits::ONE_SHOT_MODE:
    685       ASSERT_EQ(-1, minDelay);
    686       ASSERT_EQ(0, maxDelay);
    687       break;
    688     case SensorFlagBits::SPECIAL_REPORTING_MODE:
    689       // do not enforce anything for special reporting mode
    690       break;
    691     default:
    692       FAIL() << "Report mode " << static_cast<int>(reportMode) << " not checked";
    693   }
    694 }
    695 
    696 // return -1 means no expectation for this type
    697 SensorFlagBits SensorsHidlTest::expectedReportModeForType(SensorType type) {
    698   switch (type) {
    699     case SensorType::ACCELEROMETER:
    700     case SensorType::ACCELEROMETER_UNCALIBRATED:
    701     case SensorType::GYROSCOPE:
    702     case SensorType::MAGNETIC_FIELD:
    703     case SensorType::ORIENTATION:
    704     case SensorType::PRESSURE:
    705     case SensorType::TEMPERATURE:
    706     case SensorType::GRAVITY:
    707     case SensorType::LINEAR_ACCELERATION:
    708     case SensorType::ROTATION_VECTOR:
    709     case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
    710     case SensorType::GAME_ROTATION_VECTOR:
    711     case SensorType::GYROSCOPE_UNCALIBRATED:
    712     case SensorType::GEOMAGNETIC_ROTATION_VECTOR:
    713     case SensorType::POSE_6DOF:
    714     case SensorType::HEART_BEAT:
    715       return SensorFlagBits::CONTINUOUS_MODE;
    716 
    717     case SensorType::LIGHT:
    718     case SensorType::PROXIMITY:
    719     case SensorType::RELATIVE_HUMIDITY:
    720     case SensorType::AMBIENT_TEMPERATURE:
    721     case SensorType::HEART_RATE:
    722     case SensorType::DEVICE_ORIENTATION:
    723     case SensorType::STEP_COUNTER:
    724     case SensorType::LOW_LATENCY_OFFBODY_DETECT:
    725       return SensorFlagBits::ON_CHANGE_MODE;
    726 
    727     case SensorType::SIGNIFICANT_MOTION:
    728     case SensorType::WAKE_GESTURE:
    729     case SensorType::GLANCE_GESTURE:
    730     case SensorType::PICK_UP_GESTURE:
    731     case SensorType::MOTION_DETECT:
    732     case SensorType::STATIONARY_DETECT:
    733       return SensorFlagBits::ONE_SHOT_MODE;
    734 
    735     case SensorType::STEP_DETECTOR:
    736     case SensorType::TILT_DETECTOR:
    737     case SensorType::WRIST_TILT_GESTURE:
    738     case SensorType::DYNAMIC_SENSOR_META:
    739       return SensorFlagBits::SPECIAL_REPORTING_MODE;
    740 
    741     default:
    742       ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type);
    743       return (SensorFlagBits)-1;
    744   }
    745 }
    746 
    747 bool SensorsHidlTest::isDirectReportRateSupported(SensorInfo sensor, RateLevel rate) {
    748   unsigned int r =
    749       static_cast<unsigned int>(sensor.flags & SensorFlagBits::MASK_DIRECT_REPORT)
    750         >> static_cast<unsigned int>(SensorFlagShift::DIRECT_REPORT);
    751   return r >= static_cast<unsigned int>(rate);
    752 }
    753 
    754 bool SensorsHidlTest::isDirectChannelTypeSupported(SensorInfo sensor, SharedMemType type) {
    755   switch (type) {
    756     case SharedMemType::ASHMEM:
    757       return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_ASHMEM) != 0;
    758     case SharedMemType::GRALLOC:
    759       return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_GRALLOC) != 0;
    760     default:
    761       return false;
    762   }
    763 }
    764 
    765 SensorInfo SensorsHidlTest::defaultSensorByType(SensorType type) {
    766   SensorInfo ret;
    767 
    768   ret.type = (SensorType) -1;
    769   S()->getSensorsList(
    770       [&] (const auto &list) {
    771         const size_t count = list.size();
    772         for (size_t i = 0; i < count; ++i) {
    773           if (list[i].type == type) {
    774             ret = list[i];
    775             return;
    776           }
    777         }
    778       });
    779 
    780   return ret;
    781 }
    782 
    783 std::vector<SensorInfo> SensorsHidlTest::getSensorsList() {
    784   std::vector<SensorInfo> ret;
    785 
    786   S()->getSensorsList(
    787       [&] (const auto &list) {
    788         const size_t count = list.size();
    789         ret.reserve(list.size());
    790         for (size_t i = 0; i < count; ++i) {
    791           ret.push_back(list[i]);
    792         }
    793       });
    794 
    795   return ret;
    796 }
    797 
    798 // Test if sensor list returned is valid
    799 TEST_F(SensorsHidlTest, SensorListValid) {
    800   S()->getSensorsList(
    801       [&] (const auto &list) {
    802         const size_t count = list.size();
    803         for (size_t i = 0; i < count; ++i) {
    804           const auto &s = list[i];
    805           SCOPED_TRACE(::testing::Message() << i << "/" << count << ": "
    806                        << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
    807                        << s.sensorHandle << std::dec
    808                        << " type=" << static_cast<int>(s.type)
    809                        << " name=" << s.name);
    810 
    811           // Test non-empty type string
    812           EXPECT_FALSE(s.typeAsString.empty());
    813 
    814           // Test defined type matches defined string type
    815           EXPECT_NO_FATAL_FAILURE(assertTypeMatchStringType(s.type, s.typeAsString));
    816 
    817           // Test if all sensor has name and vendor
    818           EXPECT_FALSE(s.name.empty());
    819           EXPECT_FALSE(s.vendor.empty());
    820 
    821           // Test power > 0, maxRange > 0
    822           EXPECT_LE(0, s.power);
    823           EXPECT_LT(0, s.maxRange);
    824 
    825           // Info type, should have no sensor
    826           EXPECT_FALSE(
    827               s.type == SensorType::ADDITIONAL_INFO
    828               || s.type == SensorType::META_DATA);
    829 
    830           // Test fifoMax >= fifoReserved
    831           EXPECT_GE(s.fifoMaxEventCount, s.fifoReservedEventCount)
    832               << "max=" << s.fifoMaxEventCount << " reserved=" << s.fifoReservedEventCount;
    833 
    834           // Test Reporting mode valid
    835           EXPECT_NO_FATAL_FAILURE(assertTypeMatchReportMode(s.type, extractReportMode(s.flags)));
    836 
    837           // Test min max are in the right order
    838           EXPECT_LE(s.minDelay, s.maxDelay);
    839           // Test min/max delay matches reporting mode
    840           EXPECT_NO_FATAL_FAILURE(
    841               assertDelayMatchReportMode(s.minDelay, s.maxDelay, extractReportMode(s.flags)));
    842         }
    843       });
    844 }
    845 
    846 // Test if sensor list returned is valid
    847 TEST_F(SensorsHidlTest, SetOperationMode) {
    848     std::vector<SensorInfo> sensorList = getSensorsList();
    849 
    850     bool needOperationModeSupport =
    851         std::any_of(sensorList.begin(), sensorList.end(),
    852                     [] (const auto& s) {
    853                       return (s.flags & SensorFlagBits::DATA_INJECTION) != 0;
    854                     });
    855     if (!needOperationModeSupport) {
    856       return;
    857     }
    858 
    859     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL));
    860     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::DATA_INJECTION));
    861     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL));
    862 }
    863 
    864 // Test if sensor list returned is valid
    865 TEST_F(SensorsHidlTest, InjectSensorEventData) {
    866     std::vector<SensorInfo> sensorList = getSensorsList();
    867     std::vector<SensorInfo> sensorSupportInjection;
    868 
    869     bool needOperationModeSupport =
    870         std::any_of(sensorList.begin(), sensorList.end(),
    871                     [&sensorSupportInjection] (const auto& s) {
    872                       bool ret = (s.flags & SensorFlagBits::DATA_INJECTION) != 0;
    873                       if (ret) {
    874                         sensorSupportInjection.push_back(s);
    875                       }
    876                       return ret;
    877                     });
    878     if (!needOperationModeSupport) {
    879       return;
    880     }
    881 
    882     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL));
    883     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::DATA_INJECTION));
    884 
    885     for (const auto &s : sensorSupportInjection) {
    886       switch (s.type) {
    887         case SensorType::ACCELEROMETER:
    888         case SensorType::GYROSCOPE:
    889         case SensorType::MAGNETIC_FIELD: {
    890           usleep(100000); // sleep 100ms
    891 
    892           Event dummy;
    893           dummy.timestamp = android::elapsedRealtimeNano();
    894           dummy.sensorType = s.type;
    895           dummy.sensorHandle = s.sensorHandle;
    896           Vec3 v = {1, 2, 3, SensorStatus::ACCURACY_HIGH};
    897           dummy.u.vec3 = v;
    898 
    899           EXPECT_EQ(Result::OK, S()->injectSensorData(dummy));
    900           break;
    901         }
    902         default:
    903           break;
    904       }
    905     }
    906     ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL));
    907 }
    908 
    909 void SensorsHidlTest::testStreamingOperation(SensorType type,
    910                                              std::chrono::nanoseconds samplingPeriod,
    911                                              std::chrono::seconds duration,
    912                                              const SensorEventsChecker &checker) {
    913   std::vector<Event> events;
    914 
    915   const int64_t samplingPeriodInNs = samplingPeriod.count();
    916   const int64_t batchingPeriodInNs = 0; // no batching
    917   const useconds_t minTimeUs = std::chrono::microseconds(duration).count();
    918   const size_t minNEvent = duration / samplingPeriod;
    919 
    920   SensorInfo sensor = defaultSensorByType(type);
    921 
    922   if (!isValidType(sensor.type)) {
    923     // no default sensor of this type
    924     return;
    925   }
    926 
    927   if (std::chrono::microseconds(sensor.minDelay) > samplingPeriod) {
    928     // rate not supported
    929     return;
    930   }
    931 
    932   int32_t handle = sensor.sensorHandle;
    933 
    934   ASSERT_EQ(batch(handle, samplingPeriodInNs, batchingPeriodInNs), Result::OK);
    935   ASSERT_EQ(activate(handle, 1), Result::OK);
    936   events = collectEvents(minTimeUs, minNEvent, true /*clearBeforeStart*/);
    937   ASSERT_EQ(activate(handle, 0), Result::OK);
    938 
    939   ALOGI("Collected %zu samples", events.size());
    940 
    941   ASSERT_GT(events.size(), 0u);
    942 
    943   size_t nRealEvent = 0;
    944   bool handleMismatchReported = false;
    945   bool metaSensorTypeErrorReported = false;
    946   for (auto & e : events) {
    947     if (e.sensorType == type) {
    948       // avoid generating hundreds of error
    949       if (!handleMismatchReported) {
    950         EXPECT_EQ(e.sensorHandle, handle)
    951             << (handleMismatchReported = true,
    952                 "Event of the same type must come from the sensor registered");
    953       }
    954       ++ nRealEvent;
    955     } else {
    956       // avoid generating hundreds of error
    957       if (!metaSensorTypeErrorReported) {
    958         EXPECT_TRUE(isMetaSensorType(e.sensorType))
    959             << (metaSensorTypeErrorReported = true,
    960                 "Only meta types are allowed besides the type registered");
    961       }
    962     }
    963   }
    964 
    965   std::string s;
    966   EXPECT_TRUE(checker.check(events, &s)) << s;
    967 
    968   EXPECT_GE(nRealEvent, minNEvent / 2); // make sure returned events are not all meta
    969 }
    970 
    971 // Test if sensor hal can do UI speed accelerometer streaming properly
    972 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationSlow) {
    973   testStreamingOperation(SensorType::ACCELEROMETER,
    974                          std::chrono::milliseconds(200),
    975                          std::chrono::seconds(5),
    976                          sAccelNormChecker);
    977 }
    978 
    979 // Test if sensor hal can do normal speed accelerometer streaming properly
    980 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationNormal) {
    981   testStreamingOperation(SensorType::ACCELEROMETER,
    982                          std::chrono::milliseconds(20),
    983                          std::chrono::seconds(5),
    984                          sAccelNormChecker);
    985 }
    986 
    987 // Test if sensor hal can do game speed accelerometer streaming properly
    988 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationFast) {
    989   testStreamingOperation(SensorType::ACCELEROMETER,
    990                          std::chrono::milliseconds(5),
    991                          std::chrono::seconds(5),
    992                          sAccelNormChecker);
    993 }
    994 
    995 // Test if sensor hal can do UI speed gyroscope streaming properly
    996 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationSlow) {
    997   testStreamingOperation(SensorType::GYROSCOPE,
    998                          std::chrono::milliseconds(200),
    999                          std::chrono::seconds(5),
   1000                          sGyroNormChecker);
   1001 }
   1002 
   1003 // Test if sensor hal can do normal speed gyroscope streaming properly
   1004 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationNormal) {
   1005   testStreamingOperation(SensorType::GYROSCOPE,
   1006                          std::chrono::milliseconds(20),
   1007                          std::chrono::seconds(5),
   1008                          sGyroNormChecker);
   1009 }
   1010 
   1011 // Test if sensor hal can do game speed gyroscope streaming properly
   1012 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationFast) {
   1013   testStreamingOperation(SensorType::GYROSCOPE,
   1014                          std::chrono::milliseconds(5),
   1015                          std::chrono::seconds(5),
   1016                          sGyroNormChecker);
   1017 }
   1018 
   1019 // Test if sensor hal can do UI speed magnetometer streaming properly
   1020 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationSlow) {
   1021   testStreamingOperation(SensorType::MAGNETIC_FIELD,
   1022                          std::chrono::milliseconds(200),
   1023                          std::chrono::seconds(5),
   1024                          NullChecker());
   1025 }
   1026 
   1027 // Test if sensor hal can do normal speed magnetometer streaming properly
   1028 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationNormal) {
   1029   testStreamingOperation(SensorType::MAGNETIC_FIELD,
   1030                          std::chrono::milliseconds(20),
   1031                          std::chrono::seconds(5),
   1032                          NullChecker());
   1033 }
   1034 
   1035 // Test if sensor hal can do game speed magnetometer streaming properly
   1036 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationFast) {
   1037   testStreamingOperation(SensorType::MAGNETIC_FIELD,
   1038                          std::chrono::milliseconds(5),
   1039                          std::chrono::seconds(5),
   1040                          NullChecker());
   1041 }
   1042 
   1043 void SensorsHidlTest::testSamplingRateHotSwitchOperation(SensorType type) {
   1044   std::vector<Event> events1, events2;
   1045 
   1046   constexpr int64_t batchingPeriodInNs = 0; // no batching
   1047   constexpr size_t minNEvent = 50;
   1048 
   1049   SensorInfo sensor = defaultSensorByType(type);
   1050 
   1051   if (!isValidType(sensor.type)) {
   1052     // no default sensor of this type
   1053     return;
   1054   }
   1055 
   1056   int32_t handle = sensor.sensorHandle;
   1057   int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
   1058   int64_t maxSamplingPeriodInNs = sensor.maxDelay * 1000ll;
   1059 
   1060   if (minSamplingPeriodInNs == maxSamplingPeriodInNs) {
   1061     // only support single rate
   1062     return;
   1063   }
   1064 
   1065   ASSERT_EQ(batch(handle, minSamplingPeriodInNs, batchingPeriodInNs), Result::OK);
   1066   ASSERT_EQ(activate(handle, 1), Result::OK);
   1067 
   1068   usleep(500000); // sleep 0.5 sec to wait for change rate to happen
   1069   events1 = collectEvents(sensor.minDelay * minNEvent, minNEvent, true /*clearBeforeStart*/);
   1070 
   1071   ASSERT_EQ(batch(handle, maxSamplingPeriodInNs, batchingPeriodInNs), Result::OK);
   1072 
   1073   usleep(500000); // sleep 0.5 sec to wait for change rate to happen
   1074   events2 = collectEvents(sensor.maxDelay * minNEvent, minNEvent, true /*clearBeforeStart*/);
   1075 
   1076   ASSERT_EQ(activate(handle, 0), Result::OK);
   1077 
   1078   ALOGI("Collected %zu fast samples and %zu slow samples", events1.size(), events2.size());
   1079 
   1080   ASSERT_GT(events1.size(), 0u);
   1081   ASSERT_GT(events2.size(), 0u);
   1082 
   1083   int64_t minDelayAverageInterval, maxDelayAverageInterval;
   1084 
   1085   size_t nEvent = 0;
   1086   int64_t prevTimestamp = -1;
   1087   int64_t timestampInterval = 0;
   1088   for (auto & e : events1) {
   1089     if (e.sensorType == type) {
   1090       ASSERT_EQ(e.sensorHandle, handle);
   1091       if (prevTimestamp > 0) {
   1092         timestampInterval += e.timestamp - prevTimestamp;
   1093       }
   1094       prevTimestamp = e.timestamp;
   1095       ++ nEvent;
   1096     }
   1097   }
   1098   ASSERT_GT(nEvent, 2u);
   1099   minDelayAverageInterval = timestampInterval / (nEvent - 1);
   1100 
   1101   nEvent = 0;
   1102   prevTimestamp = -1;
   1103   timestampInterval = 0;
   1104   for (auto & e : events2) {
   1105     if (e.sensorType == type) {
   1106       ASSERT_EQ(e.sensorHandle, handle);
   1107       if (prevTimestamp > 0) {
   1108         timestampInterval += e.timestamp - prevTimestamp;
   1109       }
   1110       prevTimestamp = e.timestamp;
   1111       ++ nEvent;
   1112     }
   1113   }
   1114   ASSERT_GT(nEvent, 2u);
   1115   maxDelayAverageInterval = timestampInterval / (nEvent - 1);
   1116 
   1117   // change of rate is significant.
   1118   EXPECT_GT((maxDelayAverageInterval - minDelayAverageInterval), minDelayAverageInterval / 10);
   1119 
   1120   // fastest rate sampling time is close to spec
   1121   ALOGI("minDelayAverageInterval = %" PRId64, minDelayAverageInterval);
   1122   EXPECT_LT(std::abs(minDelayAverageInterval - minSamplingPeriodInNs),
   1123       minSamplingPeriodInNs / 10);
   1124 }
   1125 
   1126 // Test if sensor hal can do accelerometer sampling rate switch properly when sensor is active
   1127 TEST_F(SensorsHidlTest, AccelerometerSamplingPeriodHotSwitchOperation) {
   1128   testSamplingRateHotSwitchOperation(SensorType::ACCELEROMETER);
   1129 }
   1130 
   1131 // Test if sensor hal can do gyroscope sampling rate switch properly when sensor is active
   1132 TEST_F(SensorsHidlTest, GyroscopeSamplingPeriodHotSwitchOperation) {
   1133   testSamplingRateHotSwitchOperation(SensorType::GYROSCOPE);
   1134 }
   1135 
   1136 // Test if sensor hal can do magnetometer sampling rate switch properly when sensor is active
   1137 TEST_F(SensorsHidlTest, MagnetometerSamplingPeriodHotSwitchOperation) {
   1138   testSamplingRateHotSwitchOperation(SensorType::MAGNETIC_FIELD);
   1139 }
   1140 
   1141 void SensorsHidlTest::testBatchingOperation(SensorType type) {
   1142   std::vector<Event> events;
   1143 
   1144   constexpr int64_t maxBatchingTestTimeNs = 30ull * 1000 * 1000 * 1000;
   1145   constexpr int64_t oneSecondInNs = 1ull * 1000 * 1000 * 1000;
   1146 
   1147   SensorInfo sensor = defaultSensorByType(type);
   1148 
   1149   if (!isValidType(sensor.type)) {
   1150     // no default sensor of this type
   1151     return;
   1152   }
   1153 
   1154   int32_t handle = sensor.sensorHandle;
   1155   int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
   1156   uint32_t minFifoCount = sensor.fifoReservedEventCount;
   1157   int64_t batchingPeriodInNs = minFifoCount * minSamplingPeriodInNs;
   1158 
   1159   if (batchingPeriodInNs < oneSecondInNs) {
   1160     // batching size too small to test reliably
   1161     return;
   1162   }
   1163 
   1164   batchingPeriodInNs = std::min(batchingPeriodInNs, maxBatchingTestTimeNs);
   1165 
   1166   ALOGI("Test batching for %d ms", (int)(batchingPeriodInNs / 1000 / 1000));
   1167 
   1168   int64_t allowedBatchDeliverTimeNs =
   1169       std::max(oneSecondInNs, batchingPeriodInNs / 10);
   1170 
   1171   ASSERT_EQ(batch(handle, minSamplingPeriodInNs, INT64_MAX), Result::OK);
   1172   ASSERT_EQ(activate(handle, 1), Result::OK);
   1173 
   1174   usleep(500000); // sleep 0.5 sec to wait for initialization
   1175   ASSERT_EQ(flush(handle), Result::OK);
   1176 
   1177   // wait for 80% of the reserved batching period
   1178   // there should not be any significant amount of events
   1179   // since collection is not enabled all events will go down the drain
   1180   usleep(batchingPeriodInNs / 1000 * 8 / 10);
   1181 
   1182   SensorsHidlEnvironment::Instance()->setCollection(true);
   1183   // clean existing collections
   1184   collectEvents(0 /*timeLimitUs*/, 0/*nEventLimit*/,
   1185         true /*clearBeforeStart*/, false /*change collection*/);
   1186 
   1187   // 0.8 + 0.2 times the batching period
   1188   usleep(batchingPeriodInNs / 1000 * 8 / 10);
   1189   ASSERT_EQ(flush(handle), Result::OK);
   1190 
   1191   // plus some time for the event to deliver
   1192   events = collectEvents(allowedBatchDeliverTimeNs / 1000,
   1193         minFifoCount, false /*clearBeforeStart*/, false /*change collection*/);
   1194 
   1195   SensorsHidlEnvironment::Instance()->setCollection(false);
   1196   ASSERT_EQ(activate(handle, 0), Result::OK);
   1197 
   1198   size_t nEvent = 0;
   1199   for (auto & e : events) {
   1200     if (e.sensorType == type && e.sensorHandle == handle) {
   1201       ++ nEvent;
   1202     }
   1203   }
   1204 
   1205   // at least reach 90% of advertised capacity
   1206   ASSERT_GT(nEvent, (size_t)(minFifoCount * 9 / 10));
   1207 }
   1208 
   1209 // Test if sensor hal can do accelerometer batching properly
   1210 TEST_F(SensorsHidlTest, AccelerometerBatchingOperation) {
   1211   testBatchingOperation(SensorType::ACCELEROMETER);
   1212 }
   1213 
   1214 // Test if sensor hal can do gyroscope batching properly
   1215 TEST_F(SensorsHidlTest, GyroscopeBatchingOperation) {
   1216   testBatchingOperation(SensorType::GYROSCOPE);
   1217 }
   1218 
   1219 // Test if sensor hal can do magnetometer batching properly
   1220 TEST_F(SensorsHidlTest, MagnetometerBatchingOperation) {
   1221   testBatchingOperation(SensorType::MAGNETIC_FIELD);
   1222 }
   1223 
   1224 void SensorsHidlTest::testDirectReportOperation(
   1225     SensorType type, SharedMemType memType, RateLevel rate, const SensorEventsChecker &checker) {
   1226   constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
   1227   constexpr size_t kNEvent = 4096;
   1228   constexpr size_t kMemSize = kEventSize * kNEvent;
   1229 
   1230   constexpr float kNormalNominal = 50;
   1231   constexpr float kFastNominal = 200;
   1232   constexpr float kVeryFastNominal = 800;
   1233 
   1234   constexpr float kNominalTestTimeSec = 1.f;
   1235   constexpr float kMaxTestTimeSec = kNominalTestTimeSec + 0.5f; // 0.5 second for initialization
   1236 
   1237   SensorInfo sensor = defaultSensorByType(type);
   1238 
   1239   if (!isValidType(sensor.type)) {
   1240     // no default sensor of this type
   1241     return;
   1242   }
   1243 
   1244   if (!isDirectReportRateSupported(sensor, rate)) {
   1245     return;
   1246   }
   1247 
   1248   if (!isDirectChannelTypeSupported(sensor, memType)) {
   1249     return;
   1250   }
   1251 
   1252   std::unique_ptr<SensorsTestSharedMemory>
   1253       mem(SensorsTestSharedMemory::create(memType, kMemSize));
   1254   ASSERT_NE(mem, nullptr);
   1255 
   1256   char* buffer = mem->getBuffer();
   1257   // fill memory with data
   1258   for (size_t i = 0; i < kMemSize; ++i) {
   1259     buffer[i] = '\xcc';
   1260   }
   1261 
   1262   int32_t channelHandle;
   1263   registerDirectChannel(mem->getSharedMemInfo(),
   1264       [&channelHandle] (auto result, auto channelHandle_) {
   1265           ASSERT_EQ(result, Result::OK);
   1266           channelHandle = channelHandle_;
   1267       });
   1268 
   1269   // check memory is zeroed
   1270   for (size_t i = 0; i < kMemSize; ++i) {
   1271     ASSERT_EQ(buffer[i], '\0');
   1272   }
   1273 
   1274   int32_t eventToken;
   1275   configDirectReport(sensor.sensorHandle, channelHandle, rate,
   1276       [&eventToken] (auto result, auto token) {
   1277           ASSERT_EQ(result, Result::OK);
   1278           eventToken = token;
   1279       });
   1280 
   1281   usleep(static_cast<useconds_t>(kMaxTestTimeSec * 1e6f));
   1282   auto events = mem->parseEvents();
   1283 
   1284   // find norminal rate
   1285   float nominalFreq = 0.f;
   1286   switch (rate) {
   1287       case RateLevel::NORMAL:
   1288           nominalFreq = kNormalNominal;
   1289           break;
   1290       case RateLevel::FAST:
   1291           nominalFreq = kFastNominal;
   1292           break;
   1293       case RateLevel::VERY_FAST:
   1294           nominalFreq = kVeryFastNominal;
   1295           break;
   1296       case RateLevel::STOP:
   1297           FAIL();
   1298   }
   1299 
   1300   // allowed to be between 55% and 220% of nominal freq
   1301   ASSERT_GT(events.size(), static_cast<size_t>(nominalFreq * 0.55f * kNominalTestTimeSec));
   1302   ASSERT_LT(events.size(), static_cast<size_t>(nominalFreq * 2.2f * kMaxTestTimeSec));
   1303 
   1304   int64_t lastTimestamp = 0;
   1305   bool typeErrorReported = false;
   1306   bool tokenErrorReported = false;
   1307   bool timestampErrorReported = false;
   1308   for (auto &e : events) {
   1309     if (!typeErrorReported) {
   1310       EXPECT_EQ(type, e.sensorType)
   1311           << (typeErrorReported = true, "Type in event does not match type of sensor registered.");
   1312     }
   1313     if (!tokenErrorReported) {
   1314       EXPECT_EQ(eventToken, e.sensorHandle)
   1315           << (tokenErrorReported = true,
   1316             "Event token does not match that retured from configDirectReport");
   1317     }
   1318     if (!timestampErrorReported) {
   1319       EXPECT_GT(e.timestamp, lastTimestamp)
   1320           << (timestampErrorReported = true, "Timestamp not monotonically increasing");
   1321     }
   1322     lastTimestamp = e.timestamp;
   1323   }
   1324 
   1325   std::string s;
   1326   EXPECT_TRUE(checker.check(events, &s)) << s;
   1327 
   1328   // stop sensor and unregister channel
   1329   configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::STOP,
   1330                      [](auto result, auto) { EXPECT_EQ(result, Result::OK); });
   1331   EXPECT_EQ(unregisterDirectChannel(channelHandle), Result::OK);
   1332 }
   1333 
   1334 // Test sensor event direct report with ashmem for accel sensor at normal rate
   1335 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationNormal) {
   1336   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::NORMAL,
   1337                             sAccelNormChecker);
   1338 }
   1339 
   1340 // Test sensor event direct report with ashmem for accel sensor at fast rate
   1341 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationFast) {
   1342   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::FAST,
   1343                             sAccelNormChecker);
   1344 }
   1345 
   1346 // Test sensor event direct report with ashmem for accel sensor at very fast rate
   1347 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationVeryFast) {
   1348   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::VERY_FAST,
   1349                             sAccelNormChecker);
   1350 }
   1351 
   1352 // Test sensor event direct report with ashmem for gyro sensor at normal rate
   1353 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationNormal) {
   1354   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::NORMAL,
   1355                             sGyroNormChecker);
   1356 }
   1357 
   1358 // Test sensor event direct report with ashmem for gyro sensor at fast rate
   1359 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationFast) {
   1360   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::FAST,
   1361                             sGyroNormChecker);
   1362 }
   1363 
   1364 // Test sensor event direct report with ashmem for gyro sensor at very fast rate
   1365 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationVeryFast) {
   1366   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::VERY_FAST,
   1367                             sGyroNormChecker);
   1368 }
   1369 
   1370 // Test sensor event direct report with ashmem for mag sensor at normal rate
   1371 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationNormal) {
   1372   testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::NORMAL,
   1373                             NullChecker());
   1374 }
   1375 
   1376 // Test sensor event direct report with ashmem for mag sensor at fast rate
   1377 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationFast) {
   1378   testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::FAST,
   1379                             NullChecker());
   1380 }
   1381 
   1382 // Test sensor event direct report with ashmem for mag sensor at very fast rate
   1383 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationVeryFast) {
   1384   testDirectReportOperation(
   1385       SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::VERY_FAST, NullChecker());
   1386 }
   1387 
   1388 int main(int argc, char **argv) {
   1389   ::testing::AddGlobalTestEnvironment(SensorsHidlEnvironment::Instance());
   1390   ::testing::InitGoogleTest(&argc, argv);
   1391   int status = RUN_ALL_TESTS();
   1392   ALOGI("Test result = %d", status);
   1393   return status;
   1394 }
   1395 // vim: set ts=2 sw=2
   1396