Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1f56b518 authored by Brian Stack's avatar Brian Stack
Browse files

Verify stale requests are removed 

Add tests to verify that sensor requests and direct connections are
invalidated after initialize is called on the Sensors HAL.

Bug: 120857563
Test: Builds, tests pass against default implementation
Change-Id: I690bc5168dfa9adb7b5e08fd6ddac49f68366846
parent 27b2bc77

sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp

+115 −21
Original line number Diff line number Diff line
@@ -41,6 +41,8 @@ using ::android::hardware::sensors::V1_0::SensorStatus; 
using ::android::hardware::sensors::V1_0::SharedMemType;

using ::android::hardware::sensors::V1_0::Vec3;



constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);



class EventCallback : public IEventCallback {

   public:

    void reset() {
@@ -170,6 +172,7 @@ class SensorsHidlTest : public SensorsHidlTestBase { 
    std::vector<SensorInfo> getOneShotSensors();

    std::vector<SensorInfo> getInjectEventSensors();

    int32_t getInvalidSensorHandle();

    bool getDirectChannelSensor(SensorInfo* sensor, SharedMemType* memType, RateLevel* rate);

    void verifyDirectChannel(SharedMemType memType);

    void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,

                                     std::shared_ptr<SensorsTestSharedMemory> mem,
@@ -632,6 +635,32 @@ TEST_F(SensorsHidlTest, CallInitializeTwice) { 
    activateAllSensors(false);

}



TEST_F(SensorsHidlTest, CleanupConnectionsOnInitialize) {

    activateAllSensors(true);



    // Verify that events are received

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

    constexpr int32_t kNumEvents = 1;

    ASSERT_GE(collectEvents(kCollectionTimeoutUs, kNumEvents, getEnvironment()).size(), kNumEvents);



    // Clear the active sensor handles so they are not disabled during TearDown

    auto handles = mSensorHandles;

    mSensorHandles.clear();

    getEnvironment()->TearDown();

    getEnvironment()->SetUp();



    // Verify no events are received until sensors are re-activated

    ASSERT_EQ(collectEvents(kCollectionTimeoutUs, kNumEvents, getEnvironment()).size(), 0);

    activateAllSensors(true);

    ASSERT_GE(collectEvents(kCollectionTimeoutUs, kNumEvents, getEnvironment()).size(), kNumEvents);



    // Disable sensors

    activateAllSensors(false);



    // Restore active sensors prior to clearing the environment

    mSensorHandles = handles;

}



void SensorsHidlTest::runSingleFlushTest(const std::vector<SensorInfo>& sensors,

                                         bool activateSensor, int32_t expectedFlushCount,

                                         Result expectedResponse) {
@@ -893,7 +922,6 @@ void SensorsHidlTest::verifyUnregisterDirectChannel(const SensorInfo& sensor, Sh 
}



void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) {

    constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);

    constexpr size_t kNumEvents = 1;

    constexpr size_t kMemSize = kNumEvents * kEventSize;
@@ -917,30 +945,96 @@ TEST_F(SensorsHidlTest, DirectChannelGralloc) { 
    verifyDirectChannel(SharedMemType::GRALLOC);

}



TEST_F(SensorsHidlTest, ConfigureDirectChannelWithInvalidHandle) {

    for (const SensorInfo& sensor : getSensorsList()) {

        if (isDirectChannelTypeSupported(sensor, SharedMemType::ASHMEM) ||

            isDirectChannelTypeSupported(sensor, SharedMemType::GRALLOC)) {

bool SensorsHidlTest::getDirectChannelSensor(SensorInfo* sensor, SharedMemType* memType,

                                             RateLevel* rate) {

    bool found = false;

    for (const SensorInfo& curSensor : getSensorsList()) {

        if (isDirectChannelTypeSupported(curSensor, SharedMemType::ASHMEM)) {

            *memType = SharedMemType::ASHMEM;

            *sensor = curSensor;

            found = true;

            break;

        } else if (isDirectChannelTypeSupported(curSensor, SharedMemType::GRALLOC)) {

            *memType = SharedMemType::GRALLOC;

            *sensor = curSensor;

            found = true;

            break;

        }

    }



    if (found) {

        // Find a supported rate level

            RateLevel rate = RateLevel::STOP;

            if (isDirectReportRateSupported(sensor, RateLevel::NORMAL)) {

                rate = RateLevel::NORMAL;

            } else if (isDirectReportRateSupported(sensor, RateLevel::FAST)) {

                rate = RateLevel::FAST;

            } else if (isDirectReportRateSupported(sensor, RateLevel::VERY_FAST)) {

                rate = RateLevel::VERY_FAST;

        constexpr int kNumRateLevels = 3;

        RateLevel rates[kNumRateLevels] = {RateLevel::NORMAL, RateLevel::FAST,

                                           RateLevel::VERY_FAST};

        *rate = RateLevel::STOP;

        for (int i = 0; i < kNumRateLevels; i++) {

            if (isDirectReportRateSupported(*sensor, rates[i])) {

                *rate = rates[i];

            }

        }



        // At least one rate level must be supported

        EXPECT_NE(*rate, RateLevel::STOP);

    }

    return found;

}



            // Ensure that at least one rate level is supported

            ASSERT_NE(rate, RateLevel::STOP);

TEST_F(SensorsHidlTest, ConfigureDirectChannelWithInvalidHandle) {

    SensorInfo sensor;

    SharedMemType memType;

    RateLevel rate;

    if (!getDirectChannelSensor(&sensor, &memType, &rate)) {

        return;

    }



    // Verify that an invalid channel handle produces a BAD_VALUE result

            configDirectReport(sensor.sensorHandle, -1, rate,

                               [](Result result, int32_t /* reportToken */) {

    configDirectReport(sensor.sensorHandle, -1, rate, [](Result result, int32_t /* reportToken */) {

        ASSERT_EQ(result, Result::BAD_VALUE);

    });

}



TEST_F(SensorsHidlTest, CleanupDirectConnectionOnInitialize) {

    constexpr size_t kNumEvents = 1;

    constexpr size_t kMemSize = kNumEvents * kEventSize;



    SensorInfo sensor;

    SharedMemType memType;

    RateLevel rate;



    if (!getDirectChannelSensor(&sensor, &memType, &rate)) {

        return;

    }



    std::shared_ptr<SensorsTestSharedMemory> mem(

        SensorsTestSharedMemory::create(memType, kMemSize));

    ASSERT_NE(mem, nullptr);



    int32_t directChannelHandle = 0;

    registerDirectChannel(mem->getSharedMemInfo(), [&](Result result, int32_t channelHandle) {

        ASSERT_EQ(result, Result::OK);

        directChannelHandle = channelHandle;

    });



    // Configure the channel and expect success

    configDirectReport(

        sensor.sensorHandle, directChannelHandle, rate,

        [](Result result, int32_t /* reportToken */) { ASSERT_EQ(result, Result::OK); });



    // Call initialize() via the environment setup to cause the HAL to re-initialize

    // Clear the active direct connections so they are not stopped during TearDown

    auto handles = mDirectChannelHandles;

    mDirectChannelHandles.clear();

    getEnvironment()->TearDown();

    getEnvironment()->SetUp();



    // Attempt to configure the direct channel and expect it to fail

    configDirectReport(

        sensor.sensorHandle, directChannelHandle, rate,

        [](Result result, int32_t /* reportToken */) { ASSERT_EQ(result, Result::BAD_VALUE); });



    // Restore original handles, though they should already be deactivated

    mDirectChannelHandles = handles;

}



int main(int argc, char** argv) {