Move all matchers from dispatcher tests to TestInputListenerMatchers (7b6502d6) · Commits · e / os / platform_frameworks_native

services/inputflinger/tests/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -66,7 +66,6 @@ cc_test {
		"SyncQueue_test.cpp",
		"TimerProvider_test.cpp",
		"TestInputListener.cpp",
		"TestInputListenerMatchers.cpp",
		"TouchpadInputMapper_test.cpp",
		"KeyboardInputMapper_test.cpp",
		"UinputDevice.cpp",

services/inputflinger/tests/InputDispatcher_test.cpp

+0 −68

Original line number	Diff line number	Diff line
		@@ -134,16 +134,6 @@ static constexpr int expectedWallpaperFlags =

		using ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID;

		struct PointF {
		float x;
		float y;
		auto operator<=>(const PointF&) const = default;
		};

		inline std::string pointFToString(const PointF& p) {
		return std::string("(") + std::to_string(p.x) + ", " + std::to_string(p.y) + ")";
		}

		/**
		* Return a DOWN key event with KEYCODE_A.
		*/
		@@ -156,64 +146,6 @@ static KeyEvent getTestKeyEvent() {
		return event;
		}

		MATCHER_P(WithDownTime, downTime, "InputEvent with specified downTime") {
		*result_listener << "expected downTime " << downTime << ", but got " << arg.getDownTime();
		return arg.getDownTime() == downTime;
		}

		MATCHER_P(WithSource, source, "InputEvent with specified source") {
		*result_listener << "expected source " << inputEventSourceToString(source) << ", but got "
		<< inputEventSourceToString(arg.getSource());
		return arg.getSource() == source;
		}

		MATCHER_P(WithFlags, flags, "InputEvent with specified flags") {
		*result_listener << "expected flags " << std::hex << flags << ", but got " << arg.getFlags();
		return arg.getFlags() == flags;
		}

		MATCHER_P2(WithCoords, x, y, "MotionEvent with specified coordinates") {
		if (arg.getPointerCount() != 1) {
		*result_listener << "Expected 1 pointer, got " << arg.getPointerCount();
		return false;
		}
		const float receivedX = arg.getX(/pointerIndex=/0);
		const float receivedY = arg.getY(/pointerIndex=/0);
		*result_listener << "expected coords (" << x << ", " << y << "), but got (" << receivedX << ", "
		<< receivedY << ")";
		return receivedX == x && receivedY == y;
		}

		MATCHER_P2(WithRawCoords, x, y, "MotionEvent with specified raw coordinates") {
		if (arg.getPointerCount() != 1) {
		*result_listener << "Expected 1 pointer, got " << arg.getPointerCount();
		return false;
		}
		const float receivedX = arg.getRawX(/pointerIndex=/0);
		const float receivedY = arg.getRawY(/pointerIndex=/0);
		*result_listener << "expected raw coords (" << x << ", " << y << "), but got (" << receivedX
		<< ", " << receivedY << ")";
		return receivedX == x && receivedY == y;
		}

		MATCHER_P(WithPointerCount, pointerCount, "MotionEvent with specified number of pointers") {
		*result_listener << "expected pointerCount " << pointerCount << ", but got "
		<< arg.getPointerCount();
		return arg.getPointerCount() == pointerCount;
		}

		MATCHER_P(WithPointers, pointers, "MotionEvent with specified pointers") {
		// Build a map for the received pointers, by pointer id
		std::map<int32_t /pointerId/, PointF> actualPointers;
		for (size_t pointerIndex = 0; pointerIndex < arg.getPointerCount(); pointerIndex++) {
		const int32_t pointerId = arg.getPointerId(pointerIndex);
		actualPointers[pointerId] = {arg.getX(pointerIndex), arg.getY(pointerIndex)};
		}
		*result_listener << "expected pointers " << dumpMap(pointers, constToString, pointFToString)
		<< ", but got " << dumpMap(actualPointers, constToString, pointFToString);
		return pointers == actualPointers;
		}

		// --- FakeInputDispatcherPolicy ---

		class FakeInputDispatcherPolicy : public InputDispatcherPolicyInterface {

services/inputflinger/tests/TestInputListenerMatchers.cpp

deleted100644 → 0

+0 −37

Original line number	Diff line number	Diff line
		/*
		* Copyright 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "TestInputListenerMatchers.h"

		namespace android {

		WithKeyActionMatcher WithKeyAction(int32_t action) {
		return WithKeyActionMatcher(action);
		}

		WithMotionActionMatcher WithMotionAction(int32_t action) {
		return WithMotionActionMatcher(action);
		}

		WithDisplayIdMatcher WithDisplayId(int32_t displayId) {
		return WithDisplayIdMatcher(displayId);
		}

		WithDeviceIdMatcher WithDeviceId(int32_t deviceId) {
		return WithDeviceIdMatcher(deviceId);
		}

		} // namespace android

services/inputflinger/tests/TestInputListenerMatchers.h

+315 −34

Original line number	Diff line number	Diff line
		@@ -17,21 +17,60 @@
		#pragma once

		#include <cmath>
		#include <compare>

		#include <android-base/stringprintf.h>
		#include <android/input.h>
		#include <gmock/gmock.h>
		#include <gtest/gtest.h>
		#include <input/Input.h>
		#include <input/PrintTools.h>

		#include "NotifyArgs.h"
		#include "TestConstants.h"

		namespace android {

		MATCHER_P(WithSource, source, "InputEvent with specified source") {
		*result_listener << "expected source " << inputEventSourceToString(source) << ", but got "
		<< inputEventSourceToString(arg.source);
		return arg.source == source;
		struct PointF {
		float x;
		float y;
		auto operator<=>(const PointF&) const = default;
		};

		inline std::string pointFToString(const PointF& p) {
		return std::string("(") + std::to_string(p.x) + ", " + std::to_string(p.y) + ")";
		}

		/// Source
		class WithSourceMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithSourceMatcher(uint32_t source) : mSource(source) {}

		bool MatchAndExplain(const NotifyMotionArgs& args, std::ostream*) const {
		return mSource == args.source;
		}

		bool MatchAndExplain(const NotifyKeyArgs& args, std::ostream*) const {
		return mSource == args.source;
		}

		bool MatchAndExplain(const InputEvent& event, std::ostream*) const {
		return mSource == event.getSource();
		}

		void DescribeTo(std::ostream* os) const {
		*os << "with source " << inputEventSourceToString(mSource);
		}

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong source"; }

		private:
		const uint32_t mSource;
		};

		inline WithSourceMatcher WithSource(uint32_t source) {
		return WithSourceMatcher(source);
		}

		/// Key action
		@@ -58,7 +97,9 @@ private:
		const int32_t mAction;
		};

		WithKeyActionMatcher WithKeyAction(int32_t action);
		inline WithKeyActionMatcher WithKeyAction(int32_t action) {
		return WithKeyActionMatcher(action);
		}

		/// Motion action
		class WithMotionActionMatcher {
		@@ -95,7 +136,9 @@ private:
		const int32_t mAction;
		};

		WithMotionActionMatcher WithMotionAction(int32_t action);
		inline WithMotionActionMatcher WithMotionAction(int32_t action) {
		return WithMotionActionMatcher(action);
		}

		/// Display Id
		class WithDisplayIdMatcher {
		@@ -123,7 +166,9 @@ private:
		const int32_t mDisplayId;
		};

		WithDisplayIdMatcher WithDisplayId(int32_t displayId);
		inline WithDisplayIdMatcher WithDisplayId(int32_t displayId) {
		return WithDisplayIdMatcher(displayId);
		}

		/// Device Id
		class WithDeviceIdMatcher {
		@@ -155,7 +200,269 @@ private:
		const int32_t mDeviceId;
		};

		WithDeviceIdMatcher WithDeviceId(int32_t deviceId);
		inline WithDeviceIdMatcher WithDeviceId(int32_t deviceId) {
		return WithDeviceIdMatcher(deviceId);
		}

		/// Flags
		class WithFlagsMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithFlagsMatcher(int32_t flags) : mFlags(flags) {}

		bool MatchAndExplain(const NotifyMotionArgs& args, std::ostream*) const {
		return mFlags == args.flags;
		}

		bool MatchAndExplain(const NotifyKeyArgs& args, std::ostream*) const {
		return mFlags == args.flags;
		}

		bool MatchAndExplain(const MotionEvent& event, std::ostream*) const {
		return mFlags == event.getFlags();
		}

		bool MatchAndExplain(const KeyEvent& event, std::ostream*) const {
		return mFlags == event.getFlags();
		}

		void DescribeTo(std::ostream* os) const {
		*os << "with flags " << base::StringPrintf("0x%x", mFlags);
		}

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong flags"; }

		private:
		const int32_t mFlags;
		};

		inline WithFlagsMatcher WithFlags(int32_t flags) {
		return WithFlagsMatcher(flags);
		}

		/// DownTime
		class WithDownTimeMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithDownTimeMatcher(nsecs_t downTime) : mDownTime(downTime) {}

		bool MatchAndExplain(const NotifyMotionArgs& args, std::ostream*) const {
		return mDownTime == args.downTime;
		}

		bool MatchAndExplain(const NotifyKeyArgs& args, std::ostream*) const {
		return mDownTime == args.downTime;
		}

		bool MatchAndExplain(const MotionEvent& event, std::ostream*) const {
		return mDownTime == event.getDownTime();
		}

		bool MatchAndExplain(const KeyEvent& event, std::ostream*) const {
		return mDownTime == event.getDownTime();
		}

		void DescribeTo(std::ostream* os) const { *os << "with down time " << mDownTime; }

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong down time"; }

		private:
		const nsecs_t mDownTime;
		};

		inline WithDownTimeMatcher WithDownTime(nsecs_t downTime) {
		return WithDownTimeMatcher(downTime);
		}

		/// Coordinate matcher
		class WithCoordsMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithCoordsMatcher(size_t pointerIndex, float x, float y)
		: mPointerIndex(pointerIndex), mX(x), mY(y) {}

		bool MatchAndExplain(const MotionEvent& event, std::ostream* os) const {
		if (mPointerIndex >= event.getPointerCount()) {
		*os << "Pointer index " << mPointerIndex << " is out of bounds";
		return false;
		}

		bool matches = mX == event.getX(mPointerIndex) && mY == event.getY(mPointerIndex);
		if (!matches) {
		*os << "expected coords (" << mX << ", " << mY << ") at pointer index " << mPointerIndex
		<< ", but got (" << event.getX(mPointerIndex) << ", " << event.getY(mPointerIndex)
		<< ")";
		}
		return matches;
		}

		bool MatchAndExplain(const NotifyMotionArgs& event, std::ostream* os) const {
		if (mPointerIndex >= event.pointerCoords.size()) {
		*os << "Pointer index " << mPointerIndex << " is out of bounds";
		return false;
		}

		bool matches = mX == event.pointerCoords[mPointerIndex].getX() &&
		mY == event.pointerCoords[mPointerIndex].getY();
		if (!matches) {
		*os << "expected coords (" << mX << ", " << mY << ") at pointer index " << mPointerIndex
		<< ", but got (" << event.pointerCoords[mPointerIndex].getX() << ", "
		<< event.pointerCoords[mPointerIndex].getY() << ")";
		}
		return matches;
		}

		void DescribeTo(std::ostream* os) const {
		*os << "with coords (" << mX << ", " << mY << ") at pointer index " << mPointerIndex;
		}

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong coords"; }

		private:
		const size_t mPointerIndex;
		const float mX;
		const float mY;
		};

		inline WithCoordsMatcher WithCoords(float x, float y) {
		return WithCoordsMatcher(0, x, y);
		}

		inline WithCoordsMatcher WithPointerCoords(size_t pointerIndex, float x, float y) {
		return WithCoordsMatcher(pointerIndex, x, y);
		}

		/// Raw coordinate matcher
		class WithRawCoordsMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithRawCoordsMatcher(size_t pointerIndex, float rawX, float rawY)
		: mPointerIndex(pointerIndex), mRawX(rawX), mRawY(rawY) {}

		bool MatchAndExplain(const MotionEvent& event, std::ostream* os) const {
		if (mPointerIndex >= event.getPointerCount()) {
		*os << "Pointer index " << mPointerIndex << " is out of bounds";
		return false;
		}

		bool matches =
		mRawX == event.getRawX(mPointerIndex) && mRawY == event.getRawY(mPointerIndex);
		if (!matches) {
		*os << "expected raw coords (" << mRawX << ", " << mRawY << ") at pointer index "
		<< mPointerIndex << ", but got (" << event.getRawX(mPointerIndex) << ", "
		<< event.getRawY(mPointerIndex) << ")";
		}
		return matches;
		}

		void DescribeTo(std::ostream* os) const {
		*os << "with raw coords (" << mRawX << ", " << mRawY << ") at pointer index "
		<< mPointerIndex;
		}

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong raw coords"; }

		private:
		const size_t mPointerIndex;
		const float mRawX;
		const float mRawY;
		};

		inline WithRawCoordsMatcher WithRawCoords(float rawX, float rawY) {
		return WithRawCoordsMatcher(0, rawX, rawY);
		}

		inline WithRawCoordsMatcher WithPointerRawCoords(size_t pointerIndex, float rawX, float rawY) {
		return WithRawCoordsMatcher(pointerIndex, rawX, rawY);
		}

		/// Pointer count
		class WithPointerCountMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithPointerCountMatcher(size_t pointerCount) : mPointerCount(pointerCount) {}

		bool MatchAndExplain(const MotionEvent& event, std::ostream* os) const {
		if (event.getPointerCount() != mPointerCount) {
		*os << "expected pointer count " << mPointerCount << ", but got "
		<< event.getPointerCount();
		return false;
		}
		return true;
		}

		bool MatchAndExplain(const NotifyMotionArgs& event, std::ostream* os) const {
		if (event.pointerCoords.size() != mPointerCount) {
		*os << "expected pointer count " << mPointerCount << ", but got "
		<< event.pointerCoords.size();
		return false;
		}
		return true;
		}

		void DescribeTo(std::ostream* os) const { *os << "with pointer count " << mPointerCount; }

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong pointer count"; }

		private:
		const size_t mPointerCount;
		};

		inline WithPointerCountMatcher WithPointerCount(size_t pointerCount) {
		return WithPointerCountMatcher(pointerCount);
		}

		/// Pointers matcher
		class WithPointersMatcher {
		public:
		using is_gtest_matcher = void;
		explicit WithPointersMatcher(std::map<int32_t, PointF> pointers) : mPointers(pointers) {}

		bool MatchAndExplain(const MotionEvent& event, std::ostream* os) const {
		std::map<int32_t, PointF> actualPointers;
		for (size_t pointerIndex = 0; pointerIndex < event.getPointerCount(); pointerIndex++) {
		const int32_t pointerId = event.getPointerId(pointerIndex);
		actualPointers[pointerId] = {event.getX(pointerIndex), event.getY(pointerIndex)};
		}

		if (mPointers != actualPointers) {
		*os << "expected pointers " << dumpMap(mPointers, constToString, pointFToString)
		<< ", but got " << dumpMap(actualPointers, constToString, pointFToString);
		return false;
		}
		return true;
		}

		bool MatchAndExplain(const NotifyMotionArgs& event, std::ostream* os) const {
		std::map<int32_t, PointF> actualPointers;
		for (size_t pointerIndex = 0; pointerIndex < event.pointerCoords.size(); pointerIndex++) {
		const int32_t pointerId = event.pointerProperties[pointerIndex].id;
		actualPointers[pointerId] = {event.pointerCoords[pointerIndex].getX(),
		event.pointerCoords[pointerIndex].getY()};
		}

		if (mPointers != actualPointers) {
		*os << "expected pointers " << dumpMap(mPointers, constToString, pointFToString)
		<< ", but got " << dumpMap(actualPointers, constToString, pointFToString);
		return false;
		}
		return true;
		}

		void DescribeTo(std::ostream* os) const {
		*os << "with pointers " << dumpMap(mPointers, constToString, pointFToString);
		}

		void DescribeNegationTo(std::ostream* os) const { *os << "wrong pointers"; }

		private:
		const std::map<int32_t, PointF> mPointers;
		};

		inline WithPointersMatcher WithPointers(
		const std::map<int32_t /id/, PointF /coords/>& pointers) {
		return WithPointersMatcher(pointers);
		}

		MATCHER_P(WithKeyCode, keyCode, "KeyEvent with specified key code") {
		*result_listener << "expected key code " << keyCode << ", but got " << arg.keyCode;
		@@ -166,25 +473,12 @@ MATCHER_P(WithRepeatCount, repeatCount, "KeyEvent with specified repeat count")
		return arg.getRepeatCount() == repeatCount;
		}

		MATCHER_P(WithPointerCount, count, "MotionEvent with specified number of pointers") {
		*result_listener << "expected " << count << " pointer(s), but got " << arg.getPointerCount();
		return arg.getPointerCount() == count;
		}

		MATCHER_P2(WithPointerId, index, id, "MotionEvent with specified pointer ID for pointer index") {
		const auto argPointerId = arg.pointerProperties[index].id;
		*result_listener << "expected pointer with index " << index << " to have ID " << argPointerId;
		return argPointerId == id;
		}

		MATCHER_P2(WithCoords, x, y, "InputEvent with specified coords") {
		const auto argX = arg.pointerCoords[0].getX();
		const auto argY = arg.pointerCoords[0].getY();
		*result_listener << "expected coords (" << x << ", " << y << "), but got (" << argX << ", "
		<< argY << ")";
		return argX == x && argY == y;
		}

		MATCHER_P2(WithCursorPosition, x, y, "InputEvent with specified cursor position") {
		const auto argX = arg.xCursorPosition;
		const auto argY = arg.yCursorPosition;
		@@ -193,14 +487,6 @@ MATCHER_P2(WithCursorPosition, x, y, "InputEvent with specified cursor position"
		return (isnan(x) ? isnan(argX) : x == argX) && (isnan(y) ? isnan(argY) : y == argY);
		}

		MATCHER_P3(WithPointerCoords, pointer, x, y, "InputEvent with specified coords for pointer") {
		const auto argX = arg.pointerCoords[pointer].getX();
		const auto argY = arg.pointerCoords[pointer].getY();
		*result_listener << "expected pointer " << pointer << " to have coords (" << x << ", " << y
		<< "), but got (" << argX << ", " << argY << ")";
		return argX == x && argY == y;
		}

		MATCHER_P2(WithRelativeMotion, x, y, "InputEvent with specified relative motion") {
		const auto argX = arg.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X);
		const auto argY = arg.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y);
		@@ -288,11 +574,6 @@ MATCHER_P2(WithPointerToolType, pointer, toolType,
		return argToolType == toolType;
		}

		MATCHER_P(WithFlags, flags, "InputEvent with specified flags") {
		*result_listener << "expected flags " << flags << ", but got " << arg.flags;
		return arg.flags == static_cast<int32_t>(flags);
		}

		MATCHER_P(WithMotionClassification, classification,
		"InputEvent with specified MotionClassification") {
		*result_listener << "expected classification " << motionClassificationToString(classification)