/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>

#include <aidl/android/hardware/sensors/BnSensors.h>
#include <aidl/android/hardware/sensors/ISensors.h>
#include <android/binder_manager.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <hardware/sensors.h>
#include <log/log.h>
#include <utils/SystemClock.h>

#include "SensorsAidlEnvironment.h"
#include "SensorsAidlTestSharedMemory.h"
#include "sensors-vts-utils/SensorsVtsEnvironmentBase.h"

#include <cinttypes>
#include <condition_variable>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using aidl::android::hardware::sensors::Event;
using aidl::android::hardware::sensors::ISensors;
using aidl::android::hardware::sensors::SensorInfo;
using aidl::android::hardware::sensors::SensorStatus;
using aidl::android::hardware::sensors::SensorType;
using aidl::android::hardware::sensors::AdditionalInfo;
using android::ProcessState;
using std::chrono::duration_cast;

constexpr size_t kEventSize =
        static_cast<size_t>(ISensors::DIRECT_REPORT_SENSOR_EVENT_TOTAL_LENGTH);

namespace {

static void assertTypeMatchStringType(SensorType type, const std::string& stringType) {
    if (type >= SensorType::DEVICE_PRIVATE_BASE) {
        return;
    }

    switch (type) {
#define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type)                      \
    case SensorType::type:                                           \
        ASSERT_STREQ(SENSOR_STRING_TYPE_##type, stringType.c_str()); \
        break;
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_LIMITED_AXES);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_LIMITED_AXES_UNCALIBRATED);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_LIMITED_AXES);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_LIMITED_AXES_UNCALIBRATED);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEADING);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE);
        CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HINGE_ANGLE);
        default:
            FAIL() << "Type " << static_cast<int>(type)
                   << " in android defined range is not checked, "
                   << "stringType = " << stringType;
#undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE
    }
}

bool isDirectChannelTypeSupported(SensorInfo sensor, ISensors::SharedMemInfo::SharedMemType type) {
    switch (type) {
        case ISensors::SharedMemInfo::SharedMemType::ASHMEM:
            return (sensor.flags & SensorInfo::SENSOR_FLAG_BITS_DIRECT_CHANNEL_ASHMEM) != 0;
        case ISensors::SharedMemInfo::SharedMemType::GRALLOC:
            return (sensor.flags & SensorInfo::SENSOR_FLAG_BITS_DIRECT_CHANNEL_GRALLOC) != 0;
        default:
            return false;
    }
}

bool isDirectReportRateSupported(SensorInfo sensor, ISensors::RateLevel rate) {
    unsigned int r = static_cast<unsigned int>(sensor.flags &
                                               SensorInfo::SENSOR_FLAG_BITS_MASK_DIRECT_REPORT) >>
                     static_cast<unsigned int>(SensorInfo::SENSOR_FLAG_SHIFT_DIRECT_REPORT);
    return r >= static_cast<unsigned int>(rate);
}

int expectedReportModeForType(SensorType type) {
    switch (type) {
        case SensorType::ACCELEROMETER:
        case SensorType::ACCELEROMETER_LIMITED_AXES:
        case SensorType::ACCELEROMETER_UNCALIBRATED:
        case SensorType::ACCELEROMETER_LIMITED_AXES_UNCALIBRATED:
        case SensorType::GYROSCOPE:
        case SensorType::GYROSCOPE_LIMITED_AXES:
        case SensorType::MAGNETIC_FIELD:
        case SensorType::ORIENTATION:
        case SensorType::PRESSURE:
        case SensorType::GRAVITY:
        case SensorType::LINEAR_ACCELERATION:
        case SensorType::ROTATION_VECTOR:
        case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
        case SensorType::GAME_ROTATION_VECTOR:
        case SensorType::GYROSCOPE_UNCALIBRATED:
        case SensorType::GYROSCOPE_LIMITED_AXES_UNCALIBRATED:
        case SensorType::GEOMAGNETIC_ROTATION_VECTOR:
        case SensorType::POSE_6DOF:
        case SensorType::HEART_BEAT:
        case SensorType::HEADING:
            return SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE;

        case SensorType::LIGHT:
        case SensorType::PROXIMITY:
        case SensorType::RELATIVE_HUMIDITY:
        case SensorType::AMBIENT_TEMPERATURE:
        case SensorType::HEART_RATE:
        case SensorType::DEVICE_ORIENTATION:
        case SensorType::STEP_COUNTER:
        case SensorType::LOW_LATENCY_OFFBODY_DETECT:
            return SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE;

        case SensorType::SIGNIFICANT_MOTION:
        case SensorType::WAKE_GESTURE:
        case SensorType::GLANCE_GESTURE:
        case SensorType::PICK_UP_GESTURE:
        case SensorType::MOTION_DETECT:
        case SensorType::STATIONARY_DETECT:
            return SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE;

        case SensorType::STEP_DETECTOR:
        case SensorType::TILT_DETECTOR:
        case SensorType::WRIST_TILT_GESTURE:
        case SensorType::DYNAMIC_SENSOR_META:
            return SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE;

        default:
            ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type);
            return INT32_MAX;
    }
}

void assertTypeMatchReportMode(SensorType type, int reportMode) {
    if (type >= SensorType::DEVICE_PRIVATE_BASE) {
        return;
    }

    int expected = expectedReportModeForType(type);

    ASSERT_TRUE(expected == INT32_MAX || expected == reportMode)
            << "reportMode=" << static_cast<int>(reportMode)
            << "expected=" << static_cast<int>(expected);
}

void assertDelayMatchReportMode(int32_t minDelayUs, int32_t maxDelayUs, int reportMode) {
    switch (reportMode) {
        case SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE:
            ASSERT_LT(0, minDelayUs);
            ASSERT_LE(0, maxDelayUs);
            break;
        case SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE:
            ASSERT_LE(0, minDelayUs);
            ASSERT_LE(0, maxDelayUs);
            break;
        case SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE:
            ASSERT_EQ(-1, minDelayUs);
            ASSERT_EQ(0, maxDelayUs);
            break;
        case SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE:
            // do not enforce anything for special reporting mode
            break;
        default:
            FAIL() << "Report mode " << static_cast<int>(reportMode) << " not checked";
    }
}

void checkIsOk(ndk::ScopedAStatus status) {
    ASSERT_TRUE(status.isOk());
}

}  // namespace

class EventCallback : public IEventCallback<Event> {
  public:
    void reset() {
        mFlushMap.clear();
        mEventMap.clear();
    }

    void onEvent(const Event& event) override {
        if (event.sensorType == SensorType::META_DATA &&
            event.payload.get<Event::EventPayload::Tag::meta>().what ==
                    Event::EventPayload::MetaData::MetaDataEventType::META_DATA_FLUSH_COMPLETE) {
            std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
            mFlushMap[event.sensorHandle]++;
            mFlushCV.notify_all();
        } else if (event.sensorType != SensorType::ADDITIONAL_INFO) {
            std::unique_lock<std::recursive_mutex> lock(mEventMutex);
            mEventMap[event.sensorHandle].push_back(event);
            mEventCV.notify_all();
        }
    }

    int32_t getFlushCount(int32_t sensorHandle) {
        std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
        return mFlushMap[sensorHandle];
    }

    void waitForFlushEvents(const std::vector<SensorInfo>& sensorsToWaitFor,
                            int32_t numCallsToFlush, std::chrono::milliseconds timeout) {
        std::unique_lock<std::recursive_mutex> lock(mFlushMutex);
        mFlushCV.wait_for(lock, timeout,
                          [&] { return flushesReceived(sensorsToWaitFor, numCallsToFlush); });
    }

    const std::vector<Event> getEvents(int32_t sensorHandle) {
        std::unique_lock<std::recursive_mutex> lock(mEventMutex);
        return mEventMap[sensorHandle];
    }

    void waitForEvents(const std::vector<SensorInfo>& sensorsToWaitFor,
                       std::chrono::milliseconds timeout) {
        std::unique_lock<std::recursive_mutex> lock(mEventMutex);
        mEventCV.wait_for(lock, timeout, [&] { return eventsReceived(sensorsToWaitFor); });
    }

  protected:
    bool flushesReceived(const std::vector<SensorInfo>& sensorsToWaitFor, int32_t numCallsToFlush) {
        for (const SensorInfo& sensor : sensorsToWaitFor) {
            if (getFlushCount(sensor.sensorHandle) < numCallsToFlush) {
                return false;
            }
        }
        return true;
    }

    bool eventsReceived(const std::vector<SensorInfo>& sensorsToWaitFor) {
        for (const SensorInfo& sensor : sensorsToWaitFor) {
            if (getEvents(sensor.sensorHandle).size() == 0) {
                return false;
            }
        }
        return true;
    }

    std::map<int32_t, int32_t> mFlushMap;
    std::recursive_mutex mFlushMutex;
    std::condition_variable_any mFlushCV;

    std::map<int32_t, std::vector<Event>> mEventMap;
    std::recursive_mutex mEventMutex;
    std::condition_variable_any mEventCV;
};

class SensorsAidlTest : public testing::TestWithParam<std::string> {
  public:
    virtual void SetUp() override {
        mEnvironment = new SensorsAidlEnvironment(GetParam());
        mEnvironment->SetUp();

        // Ensure that we have a valid environment before performing tests
        ASSERT_NE(getSensors(), nullptr);
    }

    virtual void TearDown() override {
        for (int32_t handle : mSensorHandles) {
            activate(handle, false);
        }
        mSensorHandles.clear();

        mEnvironment->TearDown();
        delete mEnvironment;
        mEnvironment = nullptr;
    }

  protected:
    std::vector<SensorInfo> getNonOneShotSensors();
    std::vector<SensorInfo> getNonOneShotAndNonSpecialSensors();
    std::vector<SensorInfo> getNonOneShotAndNonOnChangeAndNonSpecialSensors();
    std::vector<SensorInfo> getOneShotSensors();
    std::vector<SensorInfo> getInjectEventSensors();

    void verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType memType);

    void verifyRegisterDirectChannel(
            std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem,
            int32_t* directChannelHandle, bool supportsSharedMemType,
            bool supportsAnyDirectChannel);

    void verifyConfigure(const SensorInfo& sensor, ISensors::SharedMemInfo::SharedMemType memType,
                         int32_t directChannelHandle, bool directChannelSupported);

    void queryDirectChannelSupport(ISensors::SharedMemInfo::SharedMemType memType,
                                   bool* supportsSharedMemType, bool* supportsAnyDirectChannel);

    void verifyUnregisterDirectChannel(int32_t* directChannelHandle, bool supportsAnyDirectChannel);

    void checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle,
                        ISensors::RateLevel rateLevel, int32_t* reportToken);

    inline std::shared_ptr<ISensors>& getSensors() { return mEnvironment->mSensors; }

    inline SensorsAidlEnvironment* getEnvironment() { return mEnvironment; }

    inline bool isValidType(SensorType sensorType) { return (int)sensorType > 0; }

    std::vector<SensorInfo> getSensorsList();

    int32_t getInvalidSensorHandle() {
        // Find a sensor handle that does not exist in the sensor list
        int32_t maxHandle = 0;
        for (const SensorInfo& sensor : getSensorsList()) {
            maxHandle = std::max(maxHandle, sensor.sensorHandle);
        }
        return maxHandle + 1;
    }

    ndk::ScopedAStatus activate(int32_t sensorHandle, bool enable);
    void activateAllSensors(bool enable);

    ndk::ScopedAStatus batch(int32_t sensorHandle, int64_t samplingPeriodNs,
                             int64_t maxReportLatencyNs) {
        return getSensors()->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
    }

    ndk::ScopedAStatus flush(int32_t sensorHandle) { return getSensors()->flush(sensorHandle); }

    ndk::ScopedAStatus registerDirectChannel(const ISensors::SharedMemInfo& mem,
                                             int32_t* aidlReturn);

    ndk::ScopedAStatus unregisterDirectChannel(int32_t* channelHandle) {
        return getSensors()->unregisterDirectChannel(*channelHandle);
    }

    ndk::ScopedAStatus configDirectReport(int32_t sensorHandle, int32_t channelHandle,
                                          ISensors::RateLevel rate, int32_t* reportToken) {
        return getSensors()->configDirectReport(sensorHandle, channelHandle, rate, reportToken);
    }

    void runSingleFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
                            int32_t expectedFlushCount, bool expectedResult);

    void runFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
                      int32_t flushCalls, int32_t expectedFlushCount, bool expectedResult);

    inline static int32_t extractReportMode(int32_t flag) {
        return (flag & (SensorInfo::SENSOR_FLAG_BITS_CONTINUOUS_MODE |
                        SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE |
                        SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE |
                        SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE));
    }

    // All sensors and direct channnels used
    std::unordered_set<int32_t> mSensorHandles;
    std::unordered_set<int32_t> mDirectChannelHandles;

  private:
    SensorsAidlEnvironment* mEnvironment;
};

ndk::ScopedAStatus SensorsAidlTest::registerDirectChannel(const ISensors::SharedMemInfo& mem,
                                                          int32_t* aidlReturn) {
    // If registeration of a channel succeeds, add the handle of channel to a set so that it can be
    // unregistered when test fails. Unregister a channel does not remove the handle on purpose.
    // Unregistering a channel more than once should not have negative effect.

    ndk::ScopedAStatus status = getSensors()->registerDirectChannel(mem, aidlReturn);
    if (status.isOk()) {
        mDirectChannelHandles.insert(*aidlReturn);
    }
    return status;
}

std::vector<SensorInfo> SensorsAidlTest::getSensorsList() {
    std::vector<SensorInfo> sensorInfoList;
    checkIsOk(getSensors()->getSensorsList(&sensorInfoList));
    return sensorInfoList;
}

ndk::ScopedAStatus SensorsAidlTest::activate(int32_t sensorHandle, bool enable) {
    // If activating a sensor, add the handle in a set so that when test fails it can be turned off.
    // The handle is not removed when it is deactivating on purpose so that it is not necessary to
    // check the return value of deactivation. Deactivating a sensor more than once does not have
    // negative effect.
    if (enable) {
        mSensorHandles.insert(sensorHandle);
    }
    return getSensors()->activate(sensorHandle, enable);
}

void SensorsAidlTest::activateAllSensors(bool enable) {
    for (const SensorInfo& sensorInfo : getSensorsList()) {
        if (isValidType(sensorInfo.type)) {
            checkIsOk(batch(sensorInfo.sensorHandle, sensorInfo.minDelayUs,
                            0 /* maxReportLatencyNs */));
            checkIsOk(activate(sensorInfo.sensorHandle, enable));
        }
    }
}

std::vector<SensorInfo> SensorsAidlTest::getNonOneShotSensors() {
    std::vector<SensorInfo> sensors;
    for (const SensorInfo& info : getSensorsList()) {
        if (extractReportMode(info.flags) != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE) {
            sensors.push_back(info);
        }
    }
    return sensors;
}

std::vector<SensorInfo> SensorsAidlTest::getNonOneShotAndNonSpecialSensors() {
    std::vector<SensorInfo> sensors;
    for (const SensorInfo& info : getSensorsList()) {
        int reportMode = extractReportMode(info.flags);
        if (reportMode != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE &&
            reportMode != SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE) {
            sensors.push_back(info);
        }
    }
    return sensors;
}

std::vector<SensorInfo> SensorsAidlTest::getNonOneShotAndNonOnChangeAndNonSpecialSensors() {
    std::vector<SensorInfo> sensors;
    for (const SensorInfo& info : getSensorsList()) {
        int reportMode = extractReportMode(info.flags);
        if (reportMode != SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE &&
            reportMode != SensorInfo::SENSOR_FLAG_BITS_ON_CHANGE_MODE &&
            reportMode != SensorInfo::SENSOR_FLAG_BITS_SPECIAL_REPORTING_MODE) {
            sensors.push_back(info);
        }
    }
    return sensors;
}

std::vector<SensorInfo> SensorsAidlTest::getOneShotSensors() {
    std::vector<SensorInfo> sensors;
    for (const SensorInfo& info : getSensorsList()) {
        if (extractReportMode(info.flags) == SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE) {
            sensors.push_back(info);
        }
    }
    return sensors;
}

std::vector<SensorInfo> SensorsAidlTest::getInjectEventSensors() {
    std::vector<SensorInfo> out;
    std::vector<SensorInfo> sensorInfoList = getSensorsList();
    for (const SensorInfo& info : sensorInfoList) {
        if (info.flags & SensorInfo::SENSOR_FLAG_BITS_DATA_INJECTION) {
            out.push_back(info);
        }
    }
    return out;
}

void SensorsAidlTest::runSingleFlushTest(const std::vector<SensorInfo>& sensors,
                                         bool activateSensor, int32_t expectedFlushCount,
                                         bool expectedResult) {
    runFlushTest(sensors, activateSensor, 1 /* flushCalls */, expectedFlushCount, expectedResult);
}

void SensorsAidlTest::runFlushTest(const std::vector<SensorInfo>& sensors, bool activateSensor,
                                   int32_t flushCalls, int32_t expectedFlushCount,
                                   bool expectedResult) {
    EventCallback callback;
    getEnvironment()->registerCallback(&callback);

    for (const SensorInfo& sensor : sensors) {
        // Configure and activate the sensor
        batch(sensor.sensorHandle, sensor.maxDelayUs, 0 /* maxReportLatencyNs */);
        activate(sensor.sensorHandle, activateSensor);

        // Flush the sensor
        for (int32_t i = 0; i < flushCalls; i++) {
            SCOPED_TRACE(::testing::Message()
                         << "Flush " << i << "/" << flushCalls << ": "
                         << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                         << sensor.sensorHandle << std::dec
                         << " type=" << static_cast<int>(sensor.type) << " name=" << sensor.name);

            EXPECT_EQ(flush(sensor.sensorHandle).isOk(), expectedResult);
        }
    }

    // Wait up to one second for the flush events
    callback.waitForFlushEvents(sensors, flushCalls, std::chrono::milliseconds(1000) /* timeout */);

    // Deactivate all sensors after waiting for flush events so pending flush events are not
    // abandoned by the HAL.
    for (const SensorInfo& sensor : sensors) {
        activate(sensor.sensorHandle, false);
    }
    getEnvironment()->unregisterCallback();

    // Check that the correct number of flushes are present for each sensor
    for (const SensorInfo& sensor : sensors) {
        SCOPED_TRACE(::testing::Message()
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                     << " name=" << sensor.name);
        ASSERT_EQ(callback.getFlushCount(sensor.sensorHandle), expectedFlushCount);
    }
}

TEST_P(SensorsAidlTest, SensorListValid) {
    std::vector<SensorInfo> sensorInfoList = getSensorsList();
    std::unordered_map<int32_t, std::vector<std::string>> sensorTypeNameMap;
    for (size_t i = 0; i < sensorInfoList.size(); ++i) {
        const SensorInfo& info = sensorInfoList[i];
        SCOPED_TRACE(::testing::Message()
                     << i << "/" << sensorInfoList.size() << ": "
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << info.sensorHandle << std::dec << " type=" << static_cast<int>(info.type)
                     << " name=" << info.name);

        // Test type string non-empty only for private sensor typeinfo.
        if (info.type >= SensorType::DEVICE_PRIVATE_BASE) {
            EXPECT_FALSE(info.typeAsString.empty());
        } else if (!info.typeAsString.empty()) {
            // Test type string matches framework string if specified for non-private typeinfo.
            EXPECT_NO_FATAL_FAILURE(assertTypeMatchStringType(info.type, info.typeAsString));
        }

        // Test if all sensors have name and vendor
        EXPECT_FALSE(info.name.empty());
        EXPECT_FALSE(info.vendor.empty());

        // Make sure that the sensor handle is not within the reserved range for runtime
        // sensors.
        EXPECT_FALSE(ISensors::RUNTIME_SENSORS_HANDLE_BASE <= info.sensorHandle &&
                     info.sensorHandle <= ISensors::RUNTIME_SENSORS_HANDLE_END);

        // Make sure that sensors of the same type have a unique name.
        std::vector<std::string>& v = sensorTypeNameMap[static_cast<int32_t>(info.type)];
        bool isUniqueName = std::find(v.begin(), v.end(), info.name) == v.end();
        EXPECT_TRUE(isUniqueName) << "Duplicate sensor Name: " << info.name;
        if (isUniqueName) {
            v.push_back(info.name);
        }

        EXPECT_LE(0, info.power);
        EXPECT_LT(0, info.maxRange);

        // Info type, should have no sensor
        EXPECT_FALSE(info.type == SensorType::ADDITIONAL_INFO ||
                     info.type == SensorType::META_DATA);

        EXPECT_GE(info.fifoMaxEventCount, info.fifoReservedEventCount);

        // Test Reporting mode valid
        EXPECT_NO_FATAL_FAILURE(
                assertTypeMatchReportMode(info.type, extractReportMode(info.flags)));

        // Test min max are in the right order
        EXPECT_LE(info.minDelayUs, info.maxDelayUs);
        // Test min/max delay matches reporting mode
        EXPECT_NO_FATAL_FAILURE(assertDelayMatchReportMode(info.minDelayUs, info.maxDelayUs,
                                                           extractReportMode(info.flags)));
    }
}

TEST_P(SensorsAidlTest, SetOperationMode) {
    if (getInjectEventSensors().size() > 0) {
        ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
        ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::DATA_INJECTION).isOk());
        ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
    } else {
      int errorCode =
          getSensors()
              ->setOperationMode(ISensors::OperationMode::DATA_INJECTION)
              .getExceptionCode();
      ASSERT_TRUE((errorCode == EX_UNSUPPORTED_OPERATION) ||
                  (errorCode == EX_ILLEGAL_ARGUMENT));
    }
}

TEST_P(SensorsAidlTest, InjectSensorEventData) {
    std::vector<SensorInfo> sensors = getInjectEventSensors();
    if (sensors.size() == 0) {
        return;
    }

    ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::DATA_INJECTION).isOk());

    EventCallback callback;
    getEnvironment()->registerCallback(&callback);

    // AdditionalInfo event should not be sent to Event FMQ
    Event additionalInfoEvent;
    additionalInfoEvent.sensorType = SensorType::ADDITIONAL_INFO;
    additionalInfoEvent.timestamp = android::elapsedRealtimeNano();
    AdditionalInfo info;
    info.type = AdditionalInfo::AdditionalInfoType::AINFO_BEGIN;
    info.serial = 1;
    AdditionalInfo::AdditionalInfoPayload::Int32Values infoData;
    for (int32_t i = 0; i < 14; i++) {
        infoData.values[i] = i;
    }
    info.payload.set<AdditionalInfo::AdditionalInfoPayload::Tag::dataInt32>(infoData);
    additionalInfoEvent.payload.set<Event::EventPayload::Tag::additional>(info);

    Event injectedEvent;
    injectedEvent.timestamp = android::elapsedRealtimeNano();
    Event::EventPayload::Vec3 data = {1, 2, 3, SensorStatus::ACCURACY_HIGH};
    injectedEvent.payload.set<Event::EventPayload::Tag::vec3>(data);

    for (const auto& s : sensors) {
        additionalInfoEvent.sensorHandle = s.sensorHandle;
        ASSERT_TRUE(getSensors()->injectSensorData(additionalInfoEvent).isOk());

        injectedEvent.sensorType = s.type;
        injectedEvent.sensorHandle = s.sensorHandle;
        ASSERT_TRUE(getSensors()->injectSensorData(injectedEvent).isOk());
    }

    // Wait for events to be written back to the Event FMQ
    callback.waitForEvents(sensors, std::chrono::milliseconds(1000) /* timeout */);
    getEnvironment()->unregisterCallback();

    for (const auto& s : sensors) {
        auto events = callback.getEvents(s.sensorHandle);
        if (events.empty()) {
            FAIL() << "Received no events";
        } else {
            auto lastEvent = events.back();
            SCOPED_TRACE(::testing::Message()
                         << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                         << s.sensorHandle << std::dec << " type=" << static_cast<int>(s.type)
                         << " name=" << s.name);

            // Verify that only a single event has been received
            ASSERT_EQ(events.size(), 1);

            // Verify that the event received matches the event injected and is not the additional
            // info event
            ASSERT_EQ(lastEvent.sensorType, s.type);
            ASSERT_EQ(lastEvent.timestamp, injectedEvent.timestamp);
            ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().x,
                      injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().x);
            ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().y,
                      injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().y);
            ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().z,
                      injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().z);
            ASSERT_EQ(lastEvent.payload.get<Event::EventPayload::Tag::vec3>().status,
                      injectedEvent.payload.get<Event::EventPayload::Tag::vec3>().status);
        }
    }

    ASSERT_TRUE(getSensors()->setOperationMode(ISensors::OperationMode::NORMAL).isOk());
}

TEST_P(SensorsAidlTest, CallInitializeTwice) {
    // Create a helper class so that a second environment is able to be instantiated
    class SensorsAidlEnvironmentTest : public SensorsAidlEnvironment {
      public:
        SensorsAidlEnvironmentTest(const std::string& service_name)
            : SensorsAidlEnvironment(service_name) {}
    };

    if (getSensorsList().size() == 0) {
        // No sensors
        return;
    }

    constexpr useconds_t kCollectionTimeoutUs = 1000 * 1000;  // 1s
    constexpr int32_t kNumEvents = 1;

    // Create a new environment that calls initialize()
    std::unique_ptr<SensorsAidlEnvironmentTest> newEnv =
            std::make_unique<SensorsAidlEnvironmentTest>(GetParam());
    newEnv->SetUp();
    if (HasFatalFailure()) {
        return;  // Exit early if setting up the new environment failed
    }

    activateAllSensors(true);
    // Verify that the old environment does not receive any events
    EXPECT_EQ(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), 0);
    // Verify that the new event queue receives sensor events
    EXPECT_GE(newEnv.get()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
    activateAllSensors(false);

    // Cleanup the test environment
    newEnv->TearDown();

    // Restore the test environment for future tests
    getEnvironment()->TearDown();
    getEnvironment()->SetUp();
    if (HasFatalFailure()) {
        return;  // Exit early if resetting the environment failed
    }

    // Ensure that the original environment is receiving events
    activateAllSensors(true);
    EXPECT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);
    activateAllSensors(false);
}

TEST_P(SensorsAidlTest, CleanupConnectionsOnInitialize) {
    activateAllSensors(true);

    // Verify that events are received
    constexpr useconds_t kCollectionTimeoutUs = 1000 * 1000;  // 1s
    constexpr int32_t kNumEvents = 1;
    ASSERT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);

    // Clear the active sensor handles so they are not disabled during TearDown
    auto handles = mSensorHandles;
    mSensorHandles.clear();
    getEnvironment()->TearDown();
    getEnvironment()->SetUp();
    if (HasFatalFailure()) {
        return;  // Exit early if resetting the environment failed
    }

    // Verify no events are received until sensors are re-activated
    ASSERT_EQ(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), 0);
    activateAllSensors(true);
    ASSERT_GE(getEnvironment()->collectEvents(kCollectionTimeoutUs, kNumEvents).size(), kNumEvents);

    // Disable sensors
    activateAllSensors(false);

    // Restore active sensors prior to clearing the environment
    mSensorHandles = handles;
}

TEST_P(SensorsAidlTest, FlushSensor) {
    std::vector<SensorInfo> sensors = getNonOneShotSensors();
    if (sensors.size() == 0) {
        return;
    }

    constexpr int32_t kFlushes = 5;
    runSingleFlushTest(sensors, true /* activateSensor */, 1 /* expectedFlushCount */,
                       true /* expectedResult */);
    runFlushTest(sensors, true /* activateSensor */, kFlushes, kFlushes, true /* expectedResult */);
}

TEST_P(SensorsAidlTest, FlushOneShotSensor) {
    // Find a sensor that is a one-shot sensor
    std::vector<SensorInfo> sensors = getOneShotSensors();
    if (sensors.size() == 0) {
        return;
    }

    runSingleFlushTest(sensors, true /* activateSensor */, 0 /* expectedFlushCount */,
                       false /* expectedResult */);
}

TEST_P(SensorsAidlTest, FlushInactiveSensor) {
    // Attempt to find a non-one shot sensor, then a one-shot sensor if necessary
    std::vector<SensorInfo> sensors = getNonOneShotSensors();
    if (sensors.size() == 0) {
        sensors = getOneShotSensors();
        if (sensors.size() == 0) {
            return;
        }
    }

    runSingleFlushTest(sensors, false /* activateSensor */, 0 /* expectedFlushCount */,
                       false /* expectedResult */);
}

TEST_P(SensorsAidlTest, Batch) {
    if (getSensorsList().size() == 0) {
        return;
    }

    activateAllSensors(false /* enable */);
    for (const SensorInfo& sensor : getSensorsList()) {
        SCOPED_TRACE(::testing::Message()
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                     << " name=" << sensor.name);

        // Call batch on inactive sensor
        // One shot sensors have minDelay set to -1 which is an invalid
        // parameter. Use 0 instead to avoid errors.
        int64_t samplingPeriodNs =
                extractReportMode(sensor.flags) == SensorInfo::SENSOR_FLAG_BITS_ONE_SHOT_MODE
                        ? 0
                        : sensor.minDelayUs;
        checkIsOk(batch(sensor.sensorHandle, samplingPeriodNs, 0 /* maxReportLatencyNs */));

        // Activate the sensor
        activate(sensor.sensorHandle, true /* enabled */);

        // Call batch on an active sensor
        checkIsOk(batch(sensor.sensorHandle, sensor.maxDelayUs, 0 /* maxReportLatencyNs */));
    }
    activateAllSensors(false /* enable */);

    // Call batch on an invalid sensor
    SensorInfo sensor = getSensorsList().front();
    sensor.sensorHandle = getInvalidSensorHandle();
    ASSERT_EQ(batch(sensor.sensorHandle, sensor.minDelayUs, 0 /* maxReportLatencyNs */)
                      .getExceptionCode(),
              EX_ILLEGAL_ARGUMENT);
}

TEST_P(SensorsAidlTest, Activate) {
    if (getSensorsList().size() == 0) {
        return;
    }

    // Verify that sensor events are generated when activate is called
    for (const SensorInfo& sensor : getSensorsList()) {
        SCOPED_TRACE(::testing::Message()
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                     << " name=" << sensor.name);

        checkIsOk(batch(sensor.sensorHandle, sensor.minDelayUs, 0 /* maxReportLatencyNs */));
        checkIsOk(activate(sensor.sensorHandle, true));

        // Call activate on a sensor that is already activated
        checkIsOk(activate(sensor.sensorHandle, true));

        // Deactivate the sensor
        checkIsOk(activate(sensor.sensorHandle, false));

        // Call deactivate on a sensor that is already deactivated
        checkIsOk(activate(sensor.sensorHandle, false));
    }

    // Attempt to activate an invalid sensor
    int32_t invalidHandle = getInvalidSensorHandle();
    ASSERT_EQ(activate(invalidHandle, true).getExceptionCode(), EX_ILLEGAL_ARGUMENT);
    ASSERT_EQ(activate(invalidHandle, false).getExceptionCode(), EX_ILLEGAL_ARGUMENT);
}

TEST_P(SensorsAidlTest, NoStaleEvents) {
    constexpr std::chrono::milliseconds kFiveHundredMs(500);
    constexpr std::chrono::milliseconds kOneSecond(1000);

    // Register the callback to receive sensor events
    EventCallback callback;
    getEnvironment()->registerCallback(&callback);

    // This test is not valid for one-shot, on-change or special-report-mode sensors
    const std::vector<SensorInfo> sensors = getNonOneShotAndNonOnChangeAndNonSpecialSensors();
    std::chrono::milliseconds maxMinDelay(0);
    for (const SensorInfo& sensor : sensors) {
        std::chrono::milliseconds minDelay = duration_cast<std::chrono::milliseconds>(
                std::chrono::microseconds(sensor.minDelayUs));
        maxMinDelay = std::chrono::milliseconds(std::max(maxMinDelay.count(), minDelay.count()));
    }

    // Activate the sensors so that they start generating events
    activateAllSensors(true);

    // According to the CDD, the first sample must be generated within 400ms + 2 * sample_time
    // and the maximum reporting latency is 100ms + 2 * sample_time. Wait a sufficient amount
    // of time to guarantee that a sample has arrived.
    callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay));
    activateAllSensors(false);

    // Save the last received event for each sensor
    std::map<int32_t, int64_t> lastEventTimestampMap;
    for (const SensorInfo& sensor : sensors) {
        SCOPED_TRACE(::testing::Message()
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                     << " name=" << sensor.name);

        if (callback.getEvents(sensor.sensorHandle).size() >= 1) {
            lastEventTimestampMap[sensor.sensorHandle] =
                    callback.getEvents(sensor.sensorHandle).back().timestamp;
        }
    }

    // Allow some time to pass, reset the callback, then reactivate the sensors
    usleep(duration_cast<std::chrono::microseconds>(kOneSecond + (5 * maxMinDelay)).count());
    callback.reset();
    activateAllSensors(true);
    callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay));
    activateAllSensors(false);

    getEnvironment()->unregisterCallback();

    for (const SensorInfo& sensor : sensors) {
        SCOPED_TRACE(::testing::Message()
                     << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                     << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                     << " name=" << sensor.name);

        // Skip sensors that did not previously report an event
        if (lastEventTimestampMap.find(sensor.sensorHandle) == lastEventTimestampMap.end()) {
            continue;
        }

        // Skip sensors with no events
        const std::vector<Event> events = callback.getEvents(sensor.sensorHandle);
        if (events.empty()) {
            continue;
        }

        // Ensure that the first event received is not stale by ensuring that its timestamp is
        // sufficiently different from the previous event
        const Event newEvent = events.front();
        std::chrono::milliseconds delta =
                duration_cast<std::chrono::milliseconds>(std::chrono::nanoseconds(
                        newEvent.timestamp - lastEventTimestampMap[sensor.sensorHandle]));
        std::chrono::milliseconds sensorMinDelay = duration_cast<std::chrono::milliseconds>(
                std::chrono::microseconds(sensor.minDelayUs));
        ASSERT_GE(delta, kFiveHundredMs + (3 * sensorMinDelay));
    }
}

void SensorsAidlTest::checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle,
                                     ISensors::RateLevel rateLevel, int32_t* reportToken) {
    ndk::ScopedAStatus status =
            configDirectReport(sensor.sensorHandle, directChannelHandle, rateLevel, reportToken);

    SCOPED_TRACE(::testing::Message()
                 << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                 << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                 << " name=" << sensor.name);

    if (isDirectReportRateSupported(sensor, rateLevel)) {
        ASSERT_TRUE(status.isOk());
        if (rateLevel != ISensors::RateLevel::STOP) {
          ASSERT_GT(*reportToken, 0);
        }
    } else {
      ASSERT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT);
    }
}

void SensorsAidlTest::queryDirectChannelSupport(ISensors::SharedMemInfo::SharedMemType memType,
                                                bool* supportsSharedMemType,
                                                bool* supportsAnyDirectChannel) {
    *supportsSharedMemType = false;
    *supportsAnyDirectChannel = false;
    for (const SensorInfo& curSensor : getSensorsList()) {
        if (isDirectChannelTypeSupported(curSensor, memType)) {
            *supportsSharedMemType = true;
        }
        if (isDirectChannelTypeSupported(curSensor,
                                         ISensors::SharedMemInfo::SharedMemType::ASHMEM) ||
            isDirectChannelTypeSupported(curSensor,
                                         ISensors::SharedMemInfo::SharedMemType::GRALLOC)) {
            *supportsAnyDirectChannel = true;
        }

        if (*supportsSharedMemType && *supportsAnyDirectChannel) {
            break;
        }
    }
}

void SensorsAidlTest::verifyRegisterDirectChannel(
        std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem,
        int32_t* directChannelHandle, bool supportsSharedMemType, bool supportsAnyDirectChannel) {
    char* buffer = mem->getBuffer();
    size_t size = mem->getSize();

    if (supportsSharedMemType) {
        memset(buffer, 0xff, size);
    }

    int32_t channelHandle;

    ::ndk::ScopedAStatus status = registerDirectChannel(mem->getSharedMemInfo(), &channelHandle);
    if (supportsSharedMemType) {
        ASSERT_TRUE(status.isOk());
        ASSERT_GT(channelHandle, 0);

        // Verify that the memory has been zeroed
        for (size_t i = 0; i < mem->getSize(); i++) {
          ASSERT_EQ(buffer[i], 0x00);
        }
    } else {
        int32_t error = supportsAnyDirectChannel ? EX_ILLEGAL_ARGUMENT : EX_UNSUPPORTED_OPERATION;
        ASSERT_EQ(status.getExceptionCode(), error);
    }
    *directChannelHandle = channelHandle;
}

void SensorsAidlTest::verifyUnregisterDirectChannel(int32_t* channelHandle,
                                                    bool supportsAnyDirectChannel) {
    int result = supportsAnyDirectChannel ? EX_NONE : EX_UNSUPPORTED_OPERATION;
    ndk::ScopedAStatus status = unregisterDirectChannel(channelHandle);
    ASSERT_EQ(status.getExceptionCode(), result);
}

void SensorsAidlTest::verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType memType) {
    constexpr size_t kNumEvents = 1;
    constexpr size_t kMemSize = kNumEvents * kEventSize;

    std::shared_ptr<SensorsAidlTestSharedMemory<SensorType, Event>> mem(
            SensorsAidlTestSharedMemory<SensorType, Event>::create(memType, kMemSize));
    ASSERT_NE(mem, nullptr);

    bool supportsSharedMemType;
    bool supportsAnyDirectChannel;
    queryDirectChannelSupport(memType, &supportsSharedMemType, &supportsAnyDirectChannel);

    for (const SensorInfo& sensor : getSensorsList()) {
        int32_t directChannelHandle = 0;
        verifyRegisterDirectChannel(mem, &directChannelHandle, supportsSharedMemType,
                                    supportsAnyDirectChannel);
        verifyConfigure(sensor, memType, directChannelHandle, supportsAnyDirectChannel);
        verifyUnregisterDirectChannel(&directChannelHandle, supportsAnyDirectChannel);
    }
}

void SensorsAidlTest::verifyConfigure(const SensorInfo& sensor,
                                      ISensors::SharedMemInfo::SharedMemType memType,
                                      int32_t directChannelHandle, bool supportsAnyDirectChannel) {
    SCOPED_TRACE(::testing::Message()
                 << " handle=0x" << std::hex << std::setw(8) << std::setfill('0')
                 << sensor.sensorHandle << std::dec << " type=" << static_cast<int>(sensor.type)
                 << " name=" << sensor.name);

    int32_t reportToken = 0;
    if (isDirectChannelTypeSupported(sensor, memType)) {
        // Verify that each rate level is properly supported
        checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::NORMAL, &reportToken);
        checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::FAST, &reportToken);
        checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::VERY_FAST, &reportToken);
        checkRateLevel(sensor, directChannelHandle, ISensors::RateLevel::STOP, &reportToken);

        // Verify that a sensor handle of -1 is only acceptable when using RateLevel::STOP
        ndk::ScopedAStatus status = configDirectReport(-1 /* sensorHandle */, directChannelHandle,
                                                       ISensors::RateLevel::NORMAL, &reportToken);
        ASSERT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT);

        status = configDirectReport(-1 /* sensorHandle */, directChannelHandle,
                                    ISensors::RateLevel::STOP, &reportToken);
        ASSERT_TRUE(status.isOk());
    } else {
        // directChannelHandle will be -1 here, HAL should either reject it as a bad value if there
        // is some level of direct channel report, otherwise return INVALID_OPERATION if direct
        // channel is not supported at all
        int error = supportsAnyDirectChannel ? EX_ILLEGAL_ARGUMENT : EX_UNSUPPORTED_OPERATION;
        ndk::ScopedAStatus status = configDirectReport(sensor.sensorHandle, directChannelHandle,
                                                       ISensors::RateLevel::NORMAL, &reportToken);
        ASSERT_EQ(status.getExceptionCode(), error);
    }
}

TEST_P(SensorsAidlTest, DirectChannelAshmem) {
    verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType::ASHMEM);
}

TEST_P(SensorsAidlTest, DirectChannelGralloc) {
    verifyDirectChannel(ISensors::SharedMemInfo::SharedMemType::GRALLOC);
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SensorsAidlTest);
INSTANTIATE_TEST_SUITE_P(Sensors, SensorsAidlTest,
                         testing::ValuesIn(android::getAidlHalInstanceNames(ISensors::descriptor)),
                         android::PrintInstanceNameToString);

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    ProcessState::self()->setThreadPoolMaxThreadCount(1);
    ProcessState::self()->startThreadPool();
    return RUN_ALL_TESTS();
}
