Move all matchers from dispatcher tests to TestInputListenerMatchers
Bug: 245989146
Test: atest inputflinger_tests
Change-Id: If628a5053ff1acbe2c4a448bf7aaa194254cfcc9
diff --git a/services/inputflinger/tests/Android.bp b/services/inputflinger/tests/Android.bp
index c0353af..0922354 100644
--- a/services/inputflinger/tests/Android.bp
+++ b/services/inputflinger/tests/Android.bp
@@ -66,7 +66,6 @@
"SyncQueue_test.cpp",
"TimerProvider_test.cpp",
"TestInputListener.cpp",
- "TestInputListenerMatchers.cpp",
"TouchpadInputMapper_test.cpp",
"KeyboardInputMapper_test.cpp",
"UinputDevice.cpp",
diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp
index 77d5391..24c586c 100644
--- a/services/inputflinger/tests/InputDispatcher_test.cpp
+++ b/services/inputflinger/tests/InputDispatcher_test.cpp
@@ -134,16 +134,6 @@
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 @@
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 {
diff --git a/services/inputflinger/tests/TestInputListenerMatchers.cpp b/services/inputflinger/tests/TestInputListenerMatchers.cpp
deleted file mode 100644
index 1464e60..0000000
--- a/services/inputflinger/tests/TestInputListenerMatchers.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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
diff --git a/services/inputflinger/tests/TestInputListenerMatchers.h b/services/inputflinger/tests/TestInputListenerMatchers.h
index 31ad569..ee6ff53 100644
--- a/services/inputflinger/tests/TestInputListenerMatchers.h
+++ b/services/inputflinger/tests/TestInputListenerMatchers.h
@@ -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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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)