From 56358cae58cdd0540920f2011b87d7888b74999f Mon Sep 17 00:00:00 2001 From: Brian Stack Date: Mon, 29 Oct 2018 17:20:43 -0700 Subject: Implement Direct Channel Tests Implements Direct Channel tests for Sensors HAL 2.0. The tests verify that the interface has been implemented correctly and that expected values are returned. These tests are not intended to verify that the rate at which sensor events are generated is correct. Also, correctly return -1 as the channel handle if direct report is not supported. Bug: 115969174 Test: Tests pass against default implementation Change-Id: I31b3211268701665757b03d5ee4ba2316f461282 --- sensors/2.0/default/Sensors.cpp | 2 +- .../vts/functional/VtsHalSensorsV2_0TargetTest.cpp | 135 +++++++++++++++++++++ .../common/vts/utils/SensorsTestSharedMemory.cpp | 4 + .../sensors-vts-utils/SensorsTestSharedMemory.h | 1 + 4 files changed, 141 insertions(+), 1 deletion(-) (limited to 'sensors') diff --git a/sensors/2.0/default/Sensors.cpp b/sensors/2.0/default/Sensors.cpp index 4346ee1eb..75030e088 100644 --- a/sensors/2.0/default/Sensors.cpp +++ b/sensors/2.0/default/Sensors.cpp @@ -133,7 +133,7 @@ Return Sensors::injectSensorData(const Event& event) { Return Sensors::registerDirectChannel(const SharedMemInfo& /* mem */, registerDirectChannel_cb _hidl_cb) { - _hidl_cb(Result::INVALID_OPERATION, 0 /* channelHandle */); + _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */); return Return(); } diff --git a/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp b/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp index cc78af3db..ac020adab 100644 --- a/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp +++ b/sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp @@ -18,6 +18,7 @@ #include "SensorsHidlEnvironmentV2_0.h" #include "sensors-vts-utils/SensorsHidlTestBase.h" +#include "sensors-vts-utils/SensorsTestSharedMemory.h" #include #include @@ -26,6 +27,7 @@ #include #include +#include #include #include @@ -34,7 +36,9 @@ using ::android::hardware::Return; using ::android::hardware::Void; using ::android::hardware::sensors::V1_0::MetaDataEventType; using ::android::hardware::sensors::V1_0::OperationMode; +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; class EventCallback : public IEventCallback { @@ -166,6 +170,15 @@ class SensorsHidlTest : public SensorsHidlTestBase { std::vector getOneShotSensors(); std::vector getInjectEventSensors(); int32_t getInvalidSensorHandle(); + void verifyDirectChannel(SharedMemType memType); + void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType, + std::shared_ptr mem, + int32_t* directChannelHandle); + void verifyConfigure(const SensorInfo& sensor, SharedMemType memType, + int32_t directChannelHandle); + void verifyUnregisterDirectChannel(const SensorInfo& sensor, SharedMemType memType, + int32_t directChannelHandle); + void checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle, RateLevel rateLevel); }; Return SensorsHidlTest::activate(int32_t sensorHandle, bool enabled) { @@ -808,6 +821,128 @@ TEST_F(SensorsHidlTest, NoStaleEvents) { getEnvironment()->unregisterCallback(); } +void SensorsHidlTest::checkRateLevel(const SensorInfo& sensor, int32_t directChannelHandle, + RateLevel rateLevel) { + configDirectReport(sensor.sensorHandle, directChannelHandle, rateLevel, + [&](Result result, int32_t reportToken) { + if (isDirectReportRateSupported(sensor, rateLevel)) { + ASSERT_EQ(result, Result::OK); + ASSERT_GT(reportToken, 0); + } else { + ASSERT_EQ(result, Result::BAD_VALUE); + } + }); +} + +void SensorsHidlTest::verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType, + std::shared_ptr mem, + int32_t* directChannelHandle) { + char* buffer = mem->getBuffer(); + memset(buffer, 0xff, mem->getSize()); + + registerDirectChannel(mem->getSharedMemInfo(), [&](Result result, int32_t channelHandle) { + if (isDirectChannelTypeSupported(sensor, memType)) { + ASSERT_EQ(result, Result::OK); + 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 { + ASSERT_EQ(result, Result::INVALID_OPERATION); + ASSERT_EQ(channelHandle, -1); + } + *directChannelHandle = channelHandle; + }); +} + +void SensorsHidlTest::verifyConfigure(const SensorInfo& sensor, SharedMemType memType, + int32_t directChannelHandle) { + if (isDirectChannelTypeSupported(sensor, memType)) { + // Verify that each rate level is properly supported + checkRateLevel(sensor, directChannelHandle, RateLevel::NORMAL); + checkRateLevel(sensor, directChannelHandle, RateLevel::FAST); + checkRateLevel(sensor, directChannelHandle, RateLevel::VERY_FAST); + checkRateLevel(sensor, directChannelHandle, RateLevel::STOP); + + // Verify that a sensor handle of -1 is only acceptable when using RateLevel::STOP + configDirectReport( + -1 /* sensorHandle */, directChannelHandle, RateLevel::NORMAL, + [](Result result, int32_t /* reportToken */) { ASSERT_EQ(result, Result::BAD_VALUE); }); + configDirectReport( + -1 /* sensorHandle */, directChannelHandle, RateLevel::STOP, + [](Result result, int32_t /* reportToken */) { ASSERT_EQ(result, Result::OK); }); + } else { + // Direct channel is not supported for this SharedMemType + configDirectReport(sensor.sensorHandle, directChannelHandle, RateLevel::NORMAL, + [](Result result, int32_t /* reportToken */) { + ASSERT_EQ(result, Result::INVALID_OPERATION); + }); + } +} + +void SensorsHidlTest::verifyUnregisterDirectChannel(const SensorInfo& sensor, SharedMemType memType, + int32_t directChannelHandle) { + Result result = unregisterDirectChannel(directChannelHandle); + if (isDirectChannelTypeSupported(sensor, memType)) { + ASSERT_EQ(result, Result::OK); + } else { + ASSERT_EQ(result, Result::INVALID_OPERATION); + } +} + +void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) { + constexpr size_t kEventSize = static_cast(SensorsEventFormatOffset::TOTAL_LENGTH); + constexpr size_t kNumEvents = 1; + constexpr size_t kMemSize = kNumEvents * kEventSize; + + std::shared_ptr mem( + SensorsTestSharedMemory::create(memType, kMemSize)); + ASSERT_NE(mem, nullptr); + + for (const SensorInfo& sensor : getSensorsList()) { + int32_t directChannelHandle = 0; + verifyRegisterDirectChannel(sensor, memType, mem, &directChannelHandle); + verifyConfigure(sensor, memType, directChannelHandle); + verifyUnregisterDirectChannel(sensor, memType, directChannelHandle); + } +} + +TEST_F(SensorsHidlTest, DirectChannelAshmem) { + verifyDirectChannel(SharedMemType::ASHMEM); +} + +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)) { + // 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; + } + + // Ensure that at least one rate level is supported + ASSERT_NE(rate, RateLevel::STOP); + + // Verify that an invalid channel handle produces a BAD_VALUE result + configDirectReport(sensor.sensorHandle, -1, rate, + [](Result result, int32_t /* reportToken */) { + ASSERT_EQ(result, Result::BAD_VALUE); + }); + } + } +} + int main(int argc, char** argv) { ::testing::AddGlobalTestEnvironment(SensorsHidlEnvironmentV2_0::Instance()); ::testing::InitGoogleTest(&argc, argv); diff --git a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp index 50964983e..819e2974f 100644 --- a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp +++ b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp @@ -35,6 +35,10 @@ char* SensorsTestSharedMemory::getBuffer() const { return mBuffer; } +size_t SensorsTestSharedMemory::getSize() const { + return mSize; +} + std::vector SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const { constexpr size_t kEventSize = static_cast(SensorsEventFormatOffset::TOTAL_LENGTH); constexpr size_t kOffsetSize = static_cast(SensorsEventFormatOffset::SIZE_FIELD); diff --git a/sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h b/sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h index 055b8e742..002f42c11 100644 --- a/sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h +++ b/sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h @@ -33,6 +33,7 @@ class SensorsTestSharedMemory { static SensorsTestSharedMemory* create(SharedMemType type, size_t size); SharedMemInfo getSharedMemInfo() const; char* getBuffer() const; + size_t getSize() const; std::vector parseEvents(int64_t lastCounter = -1, size_t offset = 0) const; virtual ~SensorsTestSharedMemory(); -- cgit v1.2.3