Merge "Implement Direct Channel Tests" (745badbe) · Commits · e / os / android_hardware_interfaces

sensors/2.0/default/Sensors.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -147,7 +147,7 @@ Return<Result> Sensors::injectSensorData(const Event& event) {

		Return<void> 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<void>();
		}

sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp

+135 −0

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include "SensorsHidlEnvironmentV2_0.h"
		#include "sensors-vts-utils/SensorsHidlTestBase.h"
		#include "sensors-vts-utils/SensorsTestSharedMemory.h"

		#include <android/hardware/sensors/2.0/ISensors.h>
		#include <android/hardware/sensors/2.0/types.h>
		@@ -26,6 +27,7 @@

		#include <cinttypes>
		#include <condition_variable>
		#include <cstring>
		#include <map>
		#include <vector>

		@@ -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<SensorInfo> getOneShotSensors();
		std::vector<SensorInfo> getInjectEventSensors();
		int32_t getInvalidSensorHandle();
		void verifyDirectChannel(SharedMemType memType);
		void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
		std::shared_ptr<SensorsTestSharedMemory> 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<Result> 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<SensorsTestSharedMemory> 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<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
		constexpr size_t kNumEvents = 1;
		constexpr size_t kMemSize = kNumEvents * kEventSize;

		std::shared_ptr<SensorsTestSharedMemory> 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);

sensors/common/vts/utils/SensorsTestSharedMemory.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,10 @@ char* SensorsTestSharedMemory::getBuffer() const {
		return mBuffer;
		}

		size_t SensorsTestSharedMemory::getSize() const {
		return mSize;
		}

		std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const {
		constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
		constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD);

sensors/common/vts/utils/include/sensors-vts-utils/SensorsTestSharedMemory.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -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<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
		virtual ~SensorsTestSharedMemory();