tests: add a gesture test to ensure our unaccel deltas are in a sane range

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

1 files changed, 102 insertions, 0 deletions

diff --git a/test/test-gestures.c b/test/test-gestures.c
index b8d5c146..cf378389 100644
--- a/test/test-gestures.c
+++ b/test/test-gestures.c
@@ -25,6 +25,7 @@
 
 #include <check.h>
 #include <libinput.h>
+#include <valgrind/valgrind.h>
 
 #include "libinput-util.h"
 #include "litest.h"
@@ -1062,6 +1063,103 @@ START_TEST(gestures_3fg_buttonarea_scroll_btntool)
 }
 END_TEST
 
+START_TEST(gestures_swipe_3fg_unaccel)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event *event;
+	double reference_ux = 0, reference_uy = 0;
+
+	/**
+	 * This magic number is an artifact of the acceleration code.
+	 * The maximum factor in the touchpad accel profile is 4.8 times the
+	 * speed setting (1.000875 at default setting 0). The factor
+	 * applied to the const acceleration is the 0.9 baseline.
+	 * So our two sets of coordinates are:
+	 * accel = 4.8 * delta * normalize_magic
+	 * unaccel = 0.9 * delta * normalize_magic
+	 *
+	 * Since delta and the normalization magic are the same for both,
+	 * our accelerated deltas can be a maximum of 4.8/0.9 bigger than
+	 * the unaccelerated deltas.
+	 *
+	 * If any of the accel methods numbers change, this will have to
+	 * change here too.
+	 */
+	const double max_factor = 5.34;
+
+	if (litest_slot_count(dev) < 3)
+		return;
+
+	litest_drain_events(li);
+	litest_touch_down(dev, 0, 40, 20);
+	litest_touch_down(dev, 1, 50, 20);
+	litest_touch_down(dev, 2, 60, 20);
+	libinput_dispatch(li);
+	litest_touch_move_three_touches(dev,
+					40, 20,
+					50, 20,
+					60, 20,
+					30, 40,
+					10);
+	libinput_dispatch(li);
+
+	event = libinput_get_event(li);
+	litest_is_gesture_event(event,
+				LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
+				3);
+	libinput_event_destroy(event);
+	event = libinput_get_event(li);
+	do {
+		struct libinput_event_gesture *gevent;
+		double dx, dy;
+		double ux, uy;
+
+		gevent = litest_is_gesture_event(event,
+						 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
+						 3);
+		dx = libinput_event_gesture_get_dx(gevent);
+		dy = libinput_event_gesture_get_dy(gevent);
+		ux = libinput_event_gesture_get_dx_unaccelerated(gevent);
+		uy = libinput_event_gesture_get_dy_unaccelerated(gevent);
+
+		ck_assert_double_ne(ux, 0.0);
+		ck_assert_double_ne(uy, 0.0);
+
+		if (!reference_ux)
+			reference_ux = ux;
+		if (!reference_uy)
+			reference_uy = uy;
+
+		/* The unaccelerated delta should be the same for every
+		 * event, but we have rounding errors since we only control
+		 * input data as percentage of the touchpad size.
+		 * so we just eyeball it */
+		ck_assert_double_gt(ux, reference_ux - 2);
+		ck_assert_double_lt(ux, reference_ux + 2);
+		ck_assert_double_gt(uy, reference_uy - 2);
+		ck_assert_double_lt(uy, reference_uy + 2);
+
+		/* All our touchpads are large enough to make this is a fast
+		 * swipe, we don't expect deceleration, unaccel should
+		 * always be less than accel delta */
+		ck_assert_double_lt(ux, dx);
+		ck_assert_double_lt(ux, dx);
+
+		/* Check our accelerated delta is within the expected
+		 * maximum. */
+		ck_assert_double_lt(dx, ux * max_factor);
+		ck_assert_double_lt(dy, uy * max_factor);
+
+		libinput_event_destroy(event);
+	} while ((event = libinput_get_event(li)));
+
+	litest_touch_up(dev, 0);
+	litest_touch_up(dev, 1);
+	litest_touch_up(dev, 2);
+}
+END_TEST
+
 TEST_COLLECTION(gestures)
 {
 	struct range cardinals = { N, N + NCARDINALS };
@@ -1083,4 +1181,8 @@ TEST_COLLECTION(gestures)
 	litest_add(gestures_3fg_buttonarea_scroll_btntool, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
 
 	litest_add(gestures_time_usec, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
+
+	/* Timing-sensitive test, valgrind is too slow */
+	if (!RUNNING_ON_VALGRIND)
+		litest_add(gestures_swipe_3fg_unaccel, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
 }