From 75c7cb40358cbbfd327dec5b424b856d3768c9ac Mon Sep 17 00:00:00 2001 From: Anthony Stange Date: Fri, 26 Jul 2019 15:19:00 -0400 Subject: [PATCH] Fix wait_for timestamps in Sensors VTS Previously, NoStaleEvents was treating any timestamps it dealt with as if they were in microseconds, but sensors.minDelay is in microseconds and Event timestamps are in nanoseconds. This uses std::chrono helpers to ensure the correct time is used when deciding how long to sleep during the test so that if waitForEvents never passes, the test doesn't time out. Bug: 136736906 Test: Run VTS and verify VtsHalSensorsV2_0Target doesn't finish as an incomplete module. Change-Id: Ibba59dbf9312f97d7275e5aa8cd36547ab09e328 Merged-In: Ibba59dbf9312f97d7275e5aa8cd36547ab09e328 --- .../VtsHalSensorsV2_0TargetTest.cpp | 40 ++++++++++--------- 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp b/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp index fe335f836b..8364ba992e 100644 --- a/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp +++ b/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp @@ -38,6 +38,10 @@ using ::android::hardware::sensors::V1_0::SensorsEventFormatOffset; using ::android::hardware::sensors::V1_0::SensorStatus; using ::android::hardware::sensors::V1_0::SharedMemType; using ::android::hardware::sensors::V1_0::Vec3; +using std::chrono::duration_cast; +using std::chrono::microseconds; +using std::chrono::milliseconds; +using std::chrono::nanoseconds; constexpr size_t kEventSize = static_cast(SensorsEventFormatOffset::TOTAL_LENGTH); @@ -67,9 +71,9 @@ class EventCallback : public IEventCallback { } void waitForFlushEvents(const std::vector& sensorsToWaitFor, - int32_t numCallsToFlush, int64_t timeoutMs) { + int32_t numCallsToFlush, milliseconds timeout) { std::unique_lock lock(mFlushMutex); - mFlushCV.wait_for(lock, std::chrono::milliseconds(timeoutMs), + mFlushCV.wait_for(lock, timeout, [&] { return flushesReceived(sensorsToWaitFor, numCallsToFlush); }); } @@ -78,10 +82,9 @@ class EventCallback : public IEventCallback { return mEventMap[sensorHandle]; } - void waitForEvents(const std::vector& sensorsToWaitFor, int32_t timeoutMs) { + void waitForEvents(const std::vector& sensorsToWaitFor, milliseconds timeout) { std::unique_lock lock(mEventMutex); - mEventCV.wait_for(lock, std::chrono::milliseconds(timeoutMs), - [&] { return eventsReceived(sensorsToWaitFor); }); + mEventCV.wait_for(lock, timeout, [&] { return eventsReceived(sensorsToWaitFor); }); } protected: @@ -386,7 +389,7 @@ TEST_F(SensorsHidlTest, InjectSensorEventData) { } // Wait for events to be written back to the Event FMQ - callback.waitForEvents(sensors, 1000 /* timeoutMs */); + callback.waitForEvents(sensors, milliseconds(1000) /* timeout */); for (const auto& s : sensors) { auto events = callback.getEvents(s.sensorHandle); @@ -713,7 +716,7 @@ void SensorsHidlTest::runFlushTest(const std::vector& sensors, bool } // Wait up to one second for the flush events - callback.waitForFlushEvents(sensors, flushCalls, 1000 /* timeoutMs */); + callback.waitForFlushEvents(sensors, flushCalls, milliseconds(1000) /* timeout */); // Deactivate all sensors after waiting for flush events so pending flush events are not // abandoned by the HAL. @@ -839,8 +842,8 @@ TEST_F(SensorsHidlTest, Activate) { } TEST_F(SensorsHidlTest, NoStaleEvents) { - constexpr int64_t kFiveHundredMilliseconds = 500 * 1000; - constexpr int64_t kOneSecond = 1000 * 1000; + constexpr milliseconds kFiveHundredMs(500); + constexpr milliseconds kOneSecond(1000); // Register the callback to receive sensor events EventCallback callback; @@ -848,9 +851,10 @@ TEST_F(SensorsHidlTest, NoStaleEvents) { // This test is not valid for one-shot or special-report-mode sensors const std::vector sensors = getNonOneShotAndNonSpecialSensors(); - int32_t maxMinDelay = 0; + milliseconds maxMinDelay(0); for (const SensorInfo& sensor : sensors) { - maxMinDelay = std::max(maxMinDelay, sensor.minDelay); + milliseconds minDelay = duration_cast(microseconds(sensor.minDelay)); + maxMinDelay = milliseconds(std::max(maxMinDelay.count(), minDelay.count())); } // Activate the sensors so that they start generating events @@ -859,7 +863,7 @@ TEST_F(SensorsHidlTest, NoStaleEvents) { // 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, kFiveHundredMilliseconds + (5 * maxMinDelay)); + callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay)); activateAllSensors(false); // Save the last received event for each sensor @@ -876,10 +880,10 @@ TEST_F(SensorsHidlTest, NoStaleEvents) { } // Allow some time to pass, reset the callback, then reactivate the sensors - usleep(kOneSecond + (5 * maxMinDelay)); + usleep(duration_cast(kOneSecond + (5 * maxMinDelay)).count()); callback.reset(); activateAllSensors(true); - callback.waitForEvents(sensors, kFiveHundredMilliseconds + (5 * maxMinDelay)); + callback.waitForEvents(sensors, kFiveHundredMs + (5 * maxMinDelay)); activateAllSensors(false); for (const SensorInfo& sensor : sensors) { @@ -894,11 +898,11 @@ TEST_F(SensorsHidlTest, NoStaleEvents) { // Ensure that the first event received is not stale by ensuring that its timestamp is // sufficiently different from the previous event const Event newEvent = callback.getEvents(sensor.sensorHandle).front(); - int64_t delta = newEvent.timestamp - lastEventTimestampMap[sensor.sensorHandle]; - ASSERT_GE(delta, kFiveHundredMilliseconds + (3 * sensor.minDelay)); + milliseconds delta = duration_cast( + nanoseconds(newEvent.timestamp - lastEventTimestampMap[sensor.sensorHandle])); + milliseconds sensorMinDelay = duration_cast(microseconds(sensor.minDelay)); + ASSERT_GE(delta, kFiveHundredMs + (3 * sensorMinDelay)); } - - getEnvironment()->unregisterCallback(); } void SensorsHidlTest::checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle,