Merge "Verify stale requests are removed" (5cbef169) · Commits · e / os / android_hardware_interfaces

sensors/2.0/vts/functional/VtsHalSensorsV2_0TargetTest.cpp

+115 −21

Original line number	Original line	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::SharedMemType;
	using ::android::hardware::sensors::V1_0::Vec3;		using ::android::hardware::sensors::V1_0::Vec3;

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

	class EventCallback : public IEventCallback {		class EventCallback : public IEventCallback {
	public:		public:
	void reset() {		void reset() {
	@@ -170,6 +172,7 @@ class SensorsHidlTest : public SensorsHidlTestBase {
	std::vector<SensorInfo> getOneShotSensors();		std::vector<SensorInfo> getOneShotSensors();
	std::vector<SensorInfo> getInjectEventSensors();		std::vector<SensorInfo> getInjectEventSensors();
	int32_t getInvalidSensorHandle();		int32_t getInvalidSensorHandle();
			bool getDirectChannelSensor(SensorInfo* sensor, SharedMemType* memType, RateLevel* rate);
	void verifyDirectChannel(SharedMemType memType);		void verifyDirectChannel(SharedMemType memType);
	void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,		void verifyRegisterDirectChannel(const SensorInfo& sensor, SharedMemType memType,
	std::shared_ptr<SensorsTestSharedMemory> mem,		std::shared_ptr<SensorsTestSharedMemory> mem,
	@@ -632,6 +635,32 @@ TEST_F(SensorsHidlTest, CallInitializeTwice) {
	activateAllSensors(false);		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,		void SensorsHidlTest::runSingleFlushTest(const std::vector<SensorInfo>& sensors,
	bool activateSensor, int32_t expectedFlushCount,		bool activateSensor, int32_t expectedFlushCount,
	Result expectedResponse) {		Result expectedResponse) {
	@@ -893,7 +922,6 @@ void SensorsHidlTest::verifyUnregisterDirectChannel(const SensorInfo& sensor, Sh
	}		}

	void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) {		void SensorsHidlTest::verifyDirectChannel(SharedMemType memType) {
	constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
	constexpr size_t kNumEvents = 1;		constexpr size_t kNumEvents = 1;
	constexpr size_t kMemSize = kNumEvents * kEventSize;		constexpr size_t kMemSize = kNumEvents * kEventSize;

	@@ -917,30 +945,96 @@ TEST_F(SensorsHidlTest, DirectChannelGralloc) {
	verifyDirectChannel(SharedMemType::GRALLOC);		verifyDirectChannel(SharedMemType::GRALLOC);
	}		}

	TEST_F(SensorsHidlTest, ConfigureDirectChannelWithInvalidHandle) {		bool SensorsHidlTest::getDirectChannelSensor(SensorInfo* sensor, SharedMemType* memType,
	for (const SensorInfo& sensor : getSensorsList()) {		RateLevel* rate) {
	if (isDirectChannelTypeSupported(sensor, SharedMemType::ASHMEM) \|\|		bool found = false;
	isDirectChannelTypeSupported(sensor, SharedMemType::GRALLOC)) {		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		// Find a supported rate level
	RateLevel rate = RateLevel::STOP;		constexpr int kNumRateLevels = 3;
	if (isDirectReportRateSupported(sensor, RateLevel::NORMAL)) {		RateLevel rates[kNumRateLevels] = {RateLevel::NORMAL, RateLevel::FAST,
	rate = RateLevel::NORMAL;		RateLevel::VERY_FAST};
	} else if (isDirectReportRateSupported(sensor, RateLevel::FAST)) {		*rate = RateLevel::STOP;
	rate = RateLevel::FAST;		for (int i = 0; i < kNumRateLevels; i++) {
	} else if (isDirectReportRateSupported(sensor, RateLevel::VERY_FAST)) {		if (isDirectReportRateSupported(*sensor, rates[i])) {
	rate = RateLevel::VERY_FAST;		*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		TEST_F(SensorsHidlTest, ConfigureDirectChannelWithInvalidHandle) {
	ASSERT_NE(rate, RateLevel::STOP);		SensorInfo sensor;
			SharedMemType memType;
			RateLevel rate;
			if (!getDirectChannelSensor(&sensor, &memType, &rate)) {
			return;
			}

	// Verify that an invalid channel handle produces a BAD_VALUE result		// Verify that an invalid channel handle produces a BAD_VALUE result
	configDirectReport(sensor.sensorHandle, -1, rate,		configDirectReport(sensor.sensorHandle, -1, rate, [](Result result, int32_t /* reportToken */) {
	[](Result result, int32_t /* reportToken */) {
	ASSERT_EQ(result, Result::BAD_VALUE);		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) {		int main(int argc, char** argv) {