Debian Codegraph @

test/test-pointer.c

raw
1 /*
2 * Copyright © 2013 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #include <config.h>
25
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <libinput.h>
29 #include <math.h>
30 #include <stdio.h>
31 #include <unistd.h>
32 #include <valgrind/valgrind.h>
33
34 #include "libinput-util.h"
35 #include "litest.h"
36
37 enum cardinal { N, NE, E, SE, S, SW, W, NW };
38
39 static void
40 test_relative_event(struct litest_device *dev, double dx, double dy)
41 {
42 struct libinput *li = dev->libinput;
43 struct libinput_event_pointer *ptrev;
44 struct libinput_event *event;
45 double ev_dx, ev_dy;
46 double expected_dir;
47 double expected_length;
48 double actual_dir;
49 double actual_length;
50 const char *prop;
51 int dpi = 1000;
52
53 litest_event(dev, EV_REL, REL_X, dx);
54 litest_event(dev, EV_REL, REL_Y, dy);
55 litest_event(dev, EV_SYN, SYN_REPORT, 0);
56
57 litest_dispatch(li);
58
59 event = libinput_get_event(li);
60 ptrev = litest_is_motion_event(event);
61
62 /* low-dpi devices scale up, not down, especially for slow motion.
63 * so a 1 unit movement in a 200dpi mouse still sends a 1 pixel
64 * movement. Work aorund this here by checking for the MOUSE_DPI
65 * property.
66 */
67 _unref_(udev_device) *ud =
68 libinput_device_get_udev_device(dev->libinput_device);
69 litest_assert_ptr_notnull(ud);
70 prop = udev_device_get_property_value(ud, "MOUSE_DPI");
71 if (prop) {
72 dpi = parse_mouse_dpi_property(prop);
73 litest_assert_int_ne(dpi, 0);
74
75 dx *= 1000.0 / dpi;
76 dy *= 1000.0 / dpi;
77 }
78
79 expected_length = sqrt(4 * dx * dx + 4 * dy * dy);
80 expected_dir = atan2(dx, dy);
81
82 ev_dx = libinput_event_pointer_get_dx(ptrev);
83 ev_dy = libinput_event_pointer_get_dy(ptrev);
84 actual_length = sqrt(ev_dx * ev_dx + ev_dy * ev_dy);
85 actual_dir = atan2(ev_dx, ev_dy);
86
87 /* Check the length of the motion vector (tolerate 1.0 indifference). */
88 litest_assert_double_ge(fabs(expected_length), actual_length);
89
90 /* Check the direction of the motion vector (tolerate 2π/4 radians
91 * indifference). */
92 litest_assert_double_lt(fabs(expected_dir - actual_dir), M_PI_2);
93
94 libinput_event_destroy(event);
95
96 litest_drain_events(dev->libinput);
97 }
98
99 static void
100 disable_button_scrolling(struct litest_device *device)
101 {
102 struct libinput_device *dev = device->libinput_device;
103 enum libinput_config_status status, expected;
104
105 status = libinput_device_config_scroll_set_method(
106 dev,
107 LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
108
109 expected = LIBINPUT_CONFIG_STATUS_SUCCESS;
110 litest_assert_int_eq(status, expected);
111 }
112
113 START_TEST(pointer_motion_relative)
114 {
115 struct litest_device *dev = litest_current_device();
116
117 /* send a single event, the first movement
118 is always decelerated by 0.3 */
119 litest_event(dev, EV_REL, REL_X, 1);
120 litest_event(dev, EV_REL, REL_Y, 0);
121 litest_event(dev, EV_SYN, SYN_REPORT, 0);
122 litest_dispatch(dev->libinput);
123
124 litest_drain_events(dev->libinput);
125
126 test_relative_event(dev, 1, 0);
127 test_relative_event(dev, 1, 1);
128 test_relative_event(dev, 1, -1);
129 test_relative_event(dev, 0, 1);
130
131 test_relative_event(dev, -1, 0);
132 test_relative_event(dev, -1, 1);
133 test_relative_event(dev, -1, -1);
134 test_relative_event(dev, 0, -1);
135 }
136 END_TEST
137
138 START_TEST(pointer_motion_relative_zero)
139 {
140 struct litest_device *dev = litest_current_device();
141 struct libinput *li = dev->libinput;
142 int i;
143
144 /* NOTE: this test does virtually nothing. The kernel should not
145 * allow 0/0 events to be passed to userspace. If it ever happens,
146 * let's hope this test fails if we do the wrong thing.
147 */
148 litest_drain_events(li);
149
150 for (i = 0; i < 5; i++) {
151 litest_event(dev, EV_REL, REL_X, 0);
152 litest_event(dev, EV_REL, REL_Y, 0);
153 litest_event(dev, EV_SYN, SYN_REPORT, 0);
154 litest_dispatch(li);
155 }
156 litest_assert_empty_queue(li);
157
158 /* send a single event, the first movement
159 is always decelerated by 0.3 */
160 litest_event(dev, EV_REL, REL_X, 1);
161 litest_event(dev, EV_REL, REL_Y, 0);
162 litest_event(dev, EV_SYN, SYN_REPORT, 0);
163 litest_dispatch(li);
164
165 libinput_event_destroy(libinput_get_event(li));
166 litest_assert_empty_queue(li);
167
168 for (i = 0; i < 5; i++) {
169 litest_event(dev, EV_REL, REL_X, 0);
170 litest_event(dev, EV_REL, REL_Y, 0);
171 litest_event(dev, EV_SYN, SYN_REPORT, 0);
172 litest_dispatch(dev->libinput);
173 }
174 litest_assert_empty_queue(li);
175 }
176 END_TEST
177
178 START_TEST(pointer_motion_relative_min_decel)
179 {
180 struct litest_device *dev = litest_current_device();
181 struct libinput *li = dev->libinput;
182 struct libinput_event_pointer *ptrev;
183 struct libinput_event *event;
184 double evx, evy;
185 int dx, dy;
186 double len;
187 enum cardinal direction =
188 litest_test_param_get_i32(test_env->params, "direction");
189
190 switch (direction) {
191 case N:
192 dx = 0;
193 dy = 1;
194 break;
195 case NE:
196 dx = 1;
197 dy = 1;
198 break;
199 case E:
200 dx = 1;
201 dy = 0;
202 break;
203 case SE:
204 dx = 1;
205 dy = -1;
206 break;
207 case S:
208 dx = 0;
209 dy = -1;
210 break;
211 case SW:
212 dx = -1;
213 dy = -1;
214 break;
215 case W:
216 dx = -1;
217 dy = 0;
218 break;
219 case NW:
220 dx = -1;
221 dy = 1;
222 break;
223 default:
224 litest_abort_msg("Invalid direction %d", direction);
225 }
226
227 litest_drain_events(dev->libinput);
228
229 litest_event(dev, EV_REL, REL_X, dx);
230 litest_event(dev, EV_REL, REL_Y, dy);
231 litest_event(dev, EV_SYN, SYN_REPORT, 0);
232 litest_dispatch(li);
233
234 event = libinput_get_event(li);
235 ptrev = litest_is_motion_event(event);
236 evx = libinput_event_pointer_get_dx(ptrev);
237 evy = libinput_event_pointer_get_dy(ptrev);
238
239 litest_assert((evx == 0.0) == (dx == 0));
240 litest_assert((evy == 0.0) == (dy == 0));
241
242 len = hypot(evx, evy);
243 litest_assert_double_ge(fabs(len), 0.3);
244
245 libinput_event_destroy(event);
246 }
247 END_TEST
248
249 static void
250 test_absolute_event(struct litest_device *dev, double x, double y)
251 {
252 struct libinput *li = dev->libinput;
253 struct libinput_event *event;
254 struct libinput_event_pointer *ptrev;
255 double ex, ey;
256 enum libinput_event_type type = LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE;
257
258 litest_touch_down(dev, 0, x, y);
259 litest_dispatch(li);
260
261 event = libinput_get_event(li);
262 litest_assert_notnull(event);
263 litest_assert_int_eq(libinput_event_get_type(event), type);
264
265 ptrev = libinput_event_get_pointer_event(event);
266 litest_assert_ptr_notnull(ptrev);
267
268 ex = libinput_event_pointer_get_absolute_x_transformed(ptrev, 100);
269 ey = libinput_event_pointer_get_absolute_y_transformed(ptrev, 100);
270 litest_assert_int_eq((int)(ex + 0.5), (int)x);
271 litest_assert_int_eq((int)(ey + 0.5), (int)y);
272
273 libinput_event_destroy(event);
274 }
275
276 START_TEST(pointer_motion_absolute)
277 {
278 struct litest_device *dev = litest_current_device();
279
280 litest_drain_events(dev->libinput);
281
282 test_absolute_event(dev, 0, 100);
283 test_absolute_event(dev, 100, 0);
284 test_absolute_event(dev, 50, 50);
285 }
286 END_TEST
287
288 START_TEST(pointer_absolute_initial_state)
289 {
290 struct litest_device *dev = litest_current_device();
291 struct libinput *libinput1;
292 struct libinput_event *ev1, *ev2;
293 struct libinput_event_pointer *p1, *p2;
294 int axis = litest_test_param_get_i32(test_env->params, "axis");
295
296 libinput1 = dev->libinput;
297 litest_touch_down(dev, 0, 40, 60);
298 litest_touch_up(dev, 0);
299
300 /* device is now on some x/y value */
301 litest_drain_events(libinput1);
302
303 _litest_context_destroy_ struct libinput *libinput2 = litest_create_context();
304 libinput_path_add_device(libinput2, libevdev_uinput_get_devnode(dev->uinput));
305 litest_drain_events(libinput2);
306
307 if (axis == ABS_X)
308 litest_touch_down(dev, 0, 40, 70);
309 else
310 litest_touch_down(dev, 0, 70, 60);
311 litest_touch_up(dev, 0);
312
313 litest_wait_for_event(libinput1);
314 litest_wait_for_event(libinput2);
315
316 while (libinput_next_event_type(libinput1)) {
317 ev1 = libinput_get_event(libinput1);
318 ev2 = libinput_get_event(libinput2);
319
320 litest_assert_enum_eq(libinput_event_get_type(ev1),
321 LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE);
322 litest_assert_enum_eq(libinput_event_get_type(ev1),
323 libinput_event_get_type(ev2));
324
325 p1 = libinput_event_get_pointer_event(ev1);
326 p2 = libinput_event_get_pointer_event(ev2);
327
328 litest_assert_double_eq(libinput_event_pointer_get_absolute_x(p1),
329 libinput_event_pointer_get_absolute_x(p2));
330 litest_assert_double_eq(libinput_event_pointer_get_absolute_y(p1),
331 libinput_event_pointer_get_absolute_y(p2));
332
333 libinput_event_destroy(ev1);
334 libinput_event_destroy(ev2);
335 }
336 }
337 END_TEST
338
339 static void
340 test_unaccel_event(struct litest_device *dev, int dx, int dy)
341 {
342 struct libinput *li = dev->libinput;
343 struct libinput_event *event;
344 struct libinput_event_pointer *ptrev;
345 double ev_dx, ev_dy;
346
347 litest_event(dev, EV_REL, REL_X, dx);
348 litest_event(dev, EV_REL, REL_Y, dy);
349 litest_event(dev, EV_SYN, SYN_REPORT, 0);
350
351 litest_dispatch(li);
352
353 event = libinput_get_event(li);
354 ptrev = litest_is_motion_event(event);
355
356 ev_dx = libinput_event_pointer_get_dx_unaccelerated(ptrev);
357 ev_dy = libinput_event_pointer_get_dy_unaccelerated(ptrev);
358
359 litest_assert_int_eq(dx, ev_dx);
360 litest_assert_int_eq(dy, ev_dy);
361
362 libinput_event_destroy(event);
363
364 litest_drain_events(dev->libinput);
365 }
366
367 START_TEST(pointer_motion_unaccel)
368 {
369 struct litest_device *dev = litest_current_device();
370
371 litest_drain_events(dev->libinput);
372
373 test_unaccel_event(dev, 10, 0);
374 test_unaccel_event(dev, 10, 10);
375 test_unaccel_event(dev, 10, -10);
376 test_unaccel_event(dev, 0, 10);
377
378 test_unaccel_event(dev, -10, 0);
379 test_unaccel_event(dev, -10, 10);
380 test_unaccel_event(dev, -10, -10);
381 test_unaccel_event(dev, 0, -10);
382 }
383 END_TEST
384
385 static void
386 test_button_event(struct litest_device *dev, unsigned int button, int state)
387 {
388 struct libinput *li = dev->libinput;
389
390 litest_button_click_debounced(dev, li, button, state);
391 litest_event(dev, EV_SYN, SYN_REPORT, 0);
392
393 litest_assert_button_event(li,
394 button,
395 state ? LIBINPUT_BUTTON_STATE_PRESSED
396 : LIBINPUT_BUTTON_STATE_RELEASED);
397 }
398
399 START_TEST(pointer_button)
400 {
401 struct litest_device *dev = litest_current_device();
402
403 disable_button_scrolling(dev);
404
405 litest_drain_events(dev->libinput);
406
407 test_button_event(dev, BTN_LEFT, 1);
408 test_button_event(dev, BTN_LEFT, 0);
409
410 /* press it twice for good measure */
411 test_button_event(dev, BTN_LEFT, 1);
412 test_button_event(dev, BTN_LEFT, 0);
413
414 if (libinput_device_pointer_has_button(dev->libinput_device, BTN_RIGHT)) {
415 test_button_event(dev, BTN_RIGHT, 1);
416 test_button_event(dev, BTN_RIGHT, 0);
417 }
418
419 /* Skip middle button test on trackpoints (used for scrolling) */
420 if (libinput_device_pointer_has_button(dev->libinput_device, BTN_MIDDLE)) {
421 test_button_event(dev, BTN_MIDDLE, 1);
422 test_button_event(dev, BTN_MIDDLE, 0);
423 }
424 }
425 END_TEST
426
427 START_TEST(pointer_button_auto_release)
428 {
429 struct litest_device *dev;
430 struct libinput_event *event;
431 enum libinput_event_type type;
432 struct libinput_event_pointer *pevent;
433 struct {
434 int code;
435 int released;
436 } buttons[] = {
437 {
438 .code = BTN_LEFT,
439 },
440 {
441 .code = BTN_MIDDLE,
442 },
443 {
444 .code = BTN_EXTRA,
445 },
446 {
447 .code = BTN_SIDE,
448 },
449 {
450 .code = BTN_BACK,
451 },
452 {
453 .code = BTN_FORWARD,
454 },
455 {
456 .code = BTN_4,
457 },
458 };
459 int events[2 * (ARRAY_LENGTH(buttons) + 1)];
460 unsigned i;
461 int button;
462 int valid_code;
463
464 /* Enable all tested buttons on the device */
465 for (i = 0; i < 2 * ARRAY_LENGTH(buttons);) {
466 button = buttons[i / 2].code;
467 events[i++] = EV_KEY;
468 events[i++] = button;
469 }
470 events[i++] = -1;
471 events[i++] = -1;
472
473 _litest_context_destroy_ struct libinput *libinput = litest_create_context();
474 dev = litest_add_device_with_overrides(libinput,
475 LITEST_MOUSE,
476 "Generic mouse",
477 NULL,
478 NULL,
479 events);
480
481 litest_drain_events(libinput);
482
483 /* Send pressed events, without releasing */
484 for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
485 test_button_event(dev, buttons[i].code, 1);
486 }
487
488 litest_drain_events(libinput);
489
490 /* "Disconnect" device */
491 litest_device_destroy(dev);
492
493 /* Mark all released buttons until device is removed */
494 while (1) {
495 event = libinput_get_event(libinput);
496 litest_assert_notnull(event);
497 type = libinput_event_get_type(event);
498
499 if (type == LIBINPUT_EVENT_DEVICE_REMOVED) {
500 libinput_event_destroy(event);
501 break;
502 }
503
504 litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_BUTTON);
505 pevent = libinput_event_get_pointer_event(event);
506 litest_assert_enum_eq(libinput_event_pointer_get_button_state(pevent),
507 LIBINPUT_BUTTON_STATE_RELEASED);
508 button = libinput_event_pointer_get_button(pevent);
509
510 valid_code = 0;
511 for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
512 if (buttons[i].code == button) {
513 litest_assert_int_eq(buttons[i].released, 0);
514 buttons[i].released = 1;
515 valid_code = 1;
516 }
517 }
518 litest_assert_int_eq(valid_code, 1);
519 libinput_event_destroy(event);
520 }
521
522 /* Check that all pressed buttons has been released. */
523 for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
524 litest_assert_int_eq(buttons[i].released, 1);
525 }
526 }
527 END_TEST
528
529 START_TEST(pointer_button_has_no_button)
530 {
531 struct litest_device *dev = litest_current_device();
532 struct libinput_device *device = dev->libinput_device;
533 unsigned int code;
534
535 litest_assert(
536 !libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER));
537
538 for (code = BTN_LEFT; code < KEY_OK; code++)
539 litest_assert_int_eq(-1,
540 libinput_device_pointer_has_button(device, code));
541 }
542 END_TEST
543
544 START_TEST(pointer_recover_from_lost_button_count)
545 {
546 struct litest_device *dev = litest_current_device();
547 struct libinput *li = dev->libinput;
548 struct libevdev *evdev = dev->evdev;
549
550 disable_button_scrolling(dev);
551
552 litest_drain_events(dev->libinput);
553
554 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
555
556 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
557
558 /* Grab for the release to make libinput lose count */
559 libevdev_grab(evdev, LIBEVDEV_GRAB);
560 litest_button_click_debounced(dev, li, BTN_LEFT, 0);
561 libevdev_grab(evdev, LIBEVDEV_UNGRAB);
562
563 litest_assert_empty_queue(li);
564
565 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
566 litest_assert_empty_queue(li);
567
568 litest_button_click_debounced(dev, li, BTN_LEFT, 0);
569 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
570 litest_assert_empty_queue(li);
571 }
572 END_TEST
573
574 static inline double
575 wheel_click_count(struct litest_device *dev, int which)
576 {
577 const char *prop = NULL;
578 int count;
579 double angle = 0.0;
580
581 _unref_(udev_device) *d = libinput_device_get_udev_device(dev->libinput_device);
582 litest_assert_ptr_notnull(d);
583
584 if (which == REL_HWHEEL)
585 prop = udev_device_get_property_value(
586 d,
587 "MOUSE_WHEEL_CLICK_COUNT_HORIZONTAL");
588 if (!prop)
589 prop = udev_device_get_property_value(d, "MOUSE_WHEEL_CLICK_COUNT");
590 if (prop) {
591 count = parse_mouse_wheel_click_count_property(prop);
592 litest_assert_int_ne(count, 0);
593 angle = 360.0 / count;
594 }
595
596 return angle;
597 }
598
599 static inline double
600 wheel_click_angle(struct litest_device *dev, int which)
601 {
602 const char *prop = NULL;
603 const int default_angle = 15;
604 double angle;
605
606 angle = wheel_click_count(dev, which);
607 if (angle != 0.0)
608 return angle;
609
610 angle = default_angle;
611 _unref_(udev_device) *d = libinput_device_get_udev_device(dev->libinput_device);
612 litest_assert_ptr_notnull(d);
613
614 if (which == REL_HWHEEL)
615 prop = udev_device_get_property_value(
616 d,
617 "MOUSE_WHEEL_CLICK_ANGLE_HORIZONTAL");
618 if (!prop)
619 prop = udev_device_get_property_value(d, "MOUSE_WHEEL_CLICK_ANGLE");
620 if (prop) {
621 angle = parse_mouse_wheel_click_angle_property(prop);
622 if (angle == 0.0)
623 angle = default_angle;
624 }
625
626 return angle;
627 }
628
629 static void
630 test_high_and_low_wheel_events_value(struct litest_device *dev,
631 int which,
632 int v120_amount)
633 {
634 struct libinput *li = dev->libinput;
635 struct libinput_event *event;
636 struct libinput_event_pointer *ptrev;
637 enum libinput_pointer_axis axis;
638 enum libinput_pointer_axis_source source;
639
640 double scroll_step, expected, discrete, v120;
641
642 scroll_step = wheel_click_angle(dev, which);
643 source = LIBINPUT_POINTER_AXIS_SOURCE_WHEEL;
644 expected = scroll_step * (v120_amount / 120);
645 discrete = v120_amount / 120;
646 v120 = v120_amount;
647
648 if (libinput_device_config_scroll_get_natural_scroll_enabled(
649 dev->libinput_device)) {
650 expected *= -1;
651 discrete *= -1;
652 v120 *= -1;
653 }
654
655 double angle = libinput_device_config_rotation_get_angle(dev->libinput_device);
656 if (angle >= 160.0 && angle <= 220.0) {
657 expected *= -1;
658 discrete *= -1;
659 v120 *= -1;
660 }
661
662 axis = (which == REL_WHEEL || which == REL_WHEEL_HI_RES)
663 ? LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL
664 : LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
665
666 event = libinput_get_event(li);
667 litest_assert_notnull(event);
668
669 bool have_lores = false, have_hires = false;
670
671 while (event) {
672 ptrev = litest_is_axis_event(event,
673 LIBINPUT_EVENT_POINTER_SCROLL_WHEEL,
674 axis,
675 source);
676
677 if (litest_is_high_res_axis_event(event)) {
678 have_hires = true;
679 litest_assert_double_eq(
680 libinput_event_pointer_get_scroll_value_v120(ptrev,
681 axis),
682 v120);
683 } else {
684 have_lores = true;
685 litest_assert_double_eq(
686 libinput_event_pointer_get_axis_value(ptrev, axis),
687 expected);
688 litest_assert_double_eq(
689 libinput_event_pointer_get_axis_value_discrete(ptrev,
690 axis),
691 discrete);
692 }
693 libinput_event_destroy(event);
694 event = libinput_get_event(li);
695 }
696
697 if (have_lores)
698 litest_assert_msg(have_hires, "Missing high-res wheels events");
699 }
700
701 static void
702 test_wheel_event(struct litest_device *dev, int which, int amount)
703 {
704 struct libinput *li = dev->libinput;
705 int event_amount = amount;
706
707 switch (which) {
708 case REL_WHEEL:
709 case REL_HWHEEL:
710 break;
711 default:
712 litest_assert_msg("Invalid axis for %s", __func__);
713 break;
714 }
715
716 /* mouse scroll wheels are 'upside down' */
717 if (which == REL_WHEEL)
718 event_amount *= -1;
719 litest_event(dev, EV_REL, which, event_amount);
720 litest_event(dev, EV_SYN, SYN_REPORT, 0);
721
722 litest_dispatch(li);
723
724 test_high_and_low_wheel_events_value(dev, which, amount * 120);
725 }
726
727 START_TEST(pointer_scroll_wheel)
728 {
729 struct litest_device *dev = litest_current_device();
730
731 litest_drain_events(dev->libinput);
732
733 /* make sure we hit at least one of the below two conditions */
734 litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
735 libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
736
737 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
738 test_wheel_event(dev, REL_WHEEL, -1);
739 test_wheel_event(dev, REL_WHEEL, 1);
740
741 test_wheel_event(dev, REL_WHEEL, -5);
742 test_wheel_event(dev, REL_WHEEL, 6);
743 }
744
745 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL)) {
746 test_wheel_event(dev, REL_HWHEEL, -1);
747 test_wheel_event(dev, REL_HWHEEL, 1);
748
749 test_wheel_event(dev, REL_HWHEEL, -5);
750 test_wheel_event(dev, REL_HWHEEL, 6);
751 }
752 }
753 END_TEST
754
755 static void
756 test_hi_res_wheel_event(struct litest_device *dev, int which, int v120_amount)
757 {
758 struct libinput *li = dev->libinput;
759
760 switch (which) {
761 case REL_WHEEL_HI_RES:
762 /* mouse scroll wheels are 'upside down' */
763 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -1 * v120_amount);
764 litest_event(dev, EV_REL, REL_WHEEL, -1 * v120_amount / 120);
765 litest_event(dev, EV_SYN, SYN_REPORT, 0);
766 break;
767 case REL_HWHEEL_HI_RES:
768 litest_event(dev, EV_REL, REL_HWHEEL_HI_RES, v120_amount);
769 litest_event(dev, EV_REL, REL_HWHEEL, v120_amount / 120);
770 litest_event(dev, EV_SYN, SYN_REPORT, 0);
771 break;
772 default:
773 abort();
774 }
775
776 litest_dispatch(li);
777
778 test_high_and_low_wheel_events_value(dev, which, v120_amount);
779 }
780
781 START_TEST(pointer_scroll_wheel_hires)
782 {
783 struct litest_device *dev = litest_current_device();
784 unsigned int axis = litest_test_param_get_i32(test_env->params, "axis");
785
786 if (!libevdev_has_event_code(dev->evdev, EV_REL, axis))
787 return LITEST_NOT_APPLICABLE;
788
789 litest_drain_events(dev->libinput);
790
791 test_hi_res_wheel_event(dev, axis, -120);
792 test_hi_res_wheel_event(dev, axis, 120);
793
794 test_hi_res_wheel_event(dev, axis, -5 * 120);
795 test_hi_res_wheel_event(dev, axis, 6 * 120);
796
797 if (dev->which == LITEST_MOUSE_WHEEL_HIRES_DISABLED)
798 return LITEST_NOT_APPLICABLE;
799
800 test_hi_res_wheel_event(dev, axis, 30);
801 test_hi_res_wheel_event(dev, axis, -60);
802 test_hi_res_wheel_event(dev, axis, -40);
803 test_hi_res_wheel_event(dev, axis, 180);
804 }
805 END_TEST
806
807 START_TEST(pointer_scroll_wheel_hires_send_only_lores)
808 {
809 struct litest_device *dev = litest_current_device();
810 struct libinput *li = dev->libinput;
811 unsigned int lores_code, hires_code;
812 int direction;
813 enum libinput_pointer_axis axis =
814 litest_test_param_get_i32(test_env->params, "axis");
815
816 switch (axis) {
817 case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
818 lores_code = REL_WHEEL;
819 hires_code = REL_WHEEL_HI_RES;
820 direction = -1;
821 break;
822 case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
823 lores_code = REL_HWHEEL;
824 hires_code = REL_HWHEEL_HI_RES;
825 direction = 1;
826 break;
827 default:
828 litest_abort_msg("Invalid test axis '%d'", axis);
829 }
830
831 if (dev->which == LITEST_MOUSE_WHEEL_HIRES_DISABLED)
832 return LITEST_NOT_APPLICABLE;
833
834 if (!libevdev_has_event_code(dev->evdev, EV_REL, lores_code) ||
835 !libevdev_has_event_code(dev->evdev, EV_REL, hires_code))
836 return LITEST_NOT_APPLICABLE;
837
838 /* Device claims to have HI_RES, but doesn't send events for it. Make
839 * sure we handle this correctly.
840 */
841 litest_drain_events(dev->libinput);
842 litest_with_logcapture(li, capture) {
843 litest_event(dev, EV_REL, lores_code, 1);
844 litest_event(dev, EV_SYN, SYN_REPORT, 0);
845 litest_dispatch(li);
846 test_high_and_low_wheel_events_value(dev, lores_code, direction * 120);
847
848 litest_event(dev, EV_REL, lores_code, -1);
849 litest_event(dev, EV_SYN, SYN_REPORT, 0);
850 litest_dispatch(li);
851 test_high_and_low_wheel_events_value(dev, lores_code, direction * -120);
852
853 litest_event(dev, EV_REL, lores_code, 2);
854 litest_event(dev, EV_SYN, SYN_REPORT, 0);
855 litest_dispatch(li);
856 test_high_and_low_wheel_events_value(dev, lores_code, direction * 240);
857
858 litest_assert_empty_queue(li);
859
860 litest_assert_strv_substring(
861 capture->bugs,
862 "only low-resolution events have been received.");
863 }
864 }
865 END_TEST
866
867 START_TEST(pointer_scroll_wheel_hires_disabled)
868 {
869 struct litest_device *dev = litest_current_device();
870 struct libinput *li = dev->libinput;
871 int direction;
872 unsigned int lores_code, hires_code;
873 enum libinput_pointer_axis axis =
874 litest_test_param_get_i32(test_env->params, "axis");
875
876 switch (axis) {
877 case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
878 lores_code = REL_WHEEL;
879 hires_code = REL_WHEEL_HI_RES;
880 direction = -1;
881 break;
882 case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
883 lores_code = REL_HWHEEL;
884 hires_code = REL_HWHEEL_HI_RES;
885 direction = 1;
886 break;
887 default:
888 litest_abort_msg("Invalid test axis '%d'", axis);
889 }
890
891 litest_drain_events(li);
892
893 litest_log_group("High-res events on this device should be ignored") {
894 for (size_t i = 0; i < 4; i++) {
895 litest_event(dev, EV_REL, hires_code, 60);
896 litest_event(dev, EV_SYN, SYN_REPORT, 0);
897 }
898 litest_assert_empty_queue(li);
899 }
900
901 litest_log_group("Only low-res events should be handled") {
902 for (size_t i = 0; i < 4; i++) {
903 litest_event(dev, EV_REL, hires_code, 60);
904 litest_event(dev, EV_REL, lores_code, 1);
905 litest_event(dev, EV_SYN, SYN_REPORT, 0);
906 litest_dispatch(li);
907
908 litest_drain_events_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
909 _destroy_(libinput_event) *ev = libinput_get_event(li);
910 struct libinput_event_pointer *pev = litest_is_axis_event(
911 ev,
912 LIBINPUT_EVENT_POINTER_SCROLL_WHEEL,
913 axis,
914 0);
915 int v120 =
916 libinput_event_pointer_get_scroll_value_v120(pev, axis);
917 litest_assert_int_eq(v120, direction * 120);
918 }
919 litest_drain_events_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
920 litest_assert_empty_queue(li);
921 }
922 }
923 END_TEST
924
925 START_TEST(pointer_scroll_wheel_inhibit_small_deltas)
926 {
927 struct litest_device *dev = litest_current_device();
928 struct libinput *li = dev->libinput;
929 uint32_t delta = litest_test_param_get_u32(test_env->params, "hires-delta");
930
931 if (!libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL_HI_RES) ||
932 !libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL_HI_RES))
933 return LITEST_NOT_APPLICABLE;
934
935 if (dev->which == LITEST_MOUSE_WHEEL_HIRES_DISABLED)
936 return LITEST_NOT_APPLICABLE;
937
938 litest_drain_events(dev->libinput);
939
940 /* A single delta (below the hardcoded threshold 60) is ignored */
941 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, delta);
942 litest_event(dev, EV_SYN, SYN_REPORT, 0);
943 litest_dispatch(li);
944 litest_assert_empty_queue(li);
945
946 /* Once we get two events in the same direction trigger scroll */
947 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, delta);
948 litest_event(dev, EV_SYN, SYN_REPORT, 0);
949 litest_dispatch(li);
950
951 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -2 * delta);
952
953 /* Once the threshold is reached, every scroll deltas are reported */
954 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, delta);
955 litest_event(dev, EV_SYN, SYN_REPORT, 0);
956 litest_dispatch(li);
957 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -delta);
958
959 /* When the scroll timeout is triggered, ignore small deltas again */
960 litest_timeout_wheel_scroll(li);
961
962 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -delta);
963 litest_event(dev, EV_SYN, SYN_REPORT, 0);
964 litest_dispatch(li);
965 litest_assert_empty_queue(li);
966
967 litest_event(dev, EV_REL, REL_HWHEEL_HI_RES, delta);
968 litest_event(dev, EV_SYN, SYN_REPORT, 0);
969 litest_dispatch(li);
970 litest_assert_empty_queue(li);
971 }
972 END_TEST
973
974 START_TEST(pointer_scroll_wheel_inhibit_small_deltas_reduce_delta)
975 {
976 struct litest_device *dev = litest_current_device();
977 struct libinput *li = dev->libinput;
978
979 if (!libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL_HI_RES) ||
980 !libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL_HI_RES))
981 return LITEST_NOT_APPLICABLE;
982
983 if (dev->which == LITEST_MOUSE_WHEEL_HIRES_DISABLED)
984 return LITEST_NOT_APPLICABLE;
985
986 litest_drain_events(dev->libinput);
987
988 /* A single delta (below the hardcoded threshold 30) is ignored */
989 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 29);
990 litest_event(dev, EV_SYN, SYN_REPORT, 0);
991 litest_dispatch(li);
992 litest_assert_empty_queue(li);
993
994 /* A second smaller delta changes the internal threshold */
995 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 5);
996 litest_event(dev, EV_SYN, SYN_REPORT, 0);
997 litest_dispatch(li);
998
999 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -34);
1000
1001 litest_timeout_wheel_scroll(li);
1002
1003 /* Internal threshold is now 5 so two deltas of 5 trigger */
1004 litest_log_group("Internal threshold is now 5 so two deltas of 5 trigger") {
1005 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 5);
1006 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1007 litest_dispatch(li);
1008 litest_assert_empty_queue(li);
1009 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 5);
1010 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1011 litest_dispatch(li);
1012 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -10);
1013 }
1014
1015 litest_timeout_wheel_scroll(li);
1016
1017 litest_log_group("Internal threshold is now 5 so one delta of 10 trigger") {
1018 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 10);
1019 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1020 litest_dispatch(li);
1021 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -10);
1022 }
1023 }
1024 END_TEST
1025
1026 START_TEST(pointer_scroll_wheel_inhibit_dir_change)
1027 {
1028 struct litest_device *dev = litest_current_device();
1029 struct libinput *li = dev->libinput;
1030 uint32_t delta = litest_test_param_get_u32(test_env->params, "hires-delta");
1031
1032 if (!libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL_HI_RES))
1033 return LITEST_NOT_APPLICABLE;
1034
1035 if (dev->which == LITEST_MOUSE_WHEEL_HIRES_DISABLED)
1036 return LITEST_NOT_APPLICABLE;
1037
1038 litest_drain_events(dev->libinput);
1039
1040 /* Scroll one detent and a bit */
1041 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 120 + delta);
1042 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1043 litest_dispatch(li);
1044 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -120 - delta);
1045
1046 /* Scroll below the threshold in the oposite direction should be ignored */
1047 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -delta);
1048 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1049 litest_dispatch(li);
1050 litest_assert_empty_queue(li);
1051
1052 /* But should be triggered if the scroll continues in the same direction */
1053 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -2 * delta);
1054 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1055 litest_dispatch(li);
1056 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, 3 * delta);
1057
1058 /* Scroll above the threshold in the same dir should be triggered */
1059 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 2 * delta);
1060 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1061 litest_dispatch(li);
1062 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -2 * delta);
1063 }
1064 END_TEST
1065
1066 START_TEST(pointer_scroll_wheel_no_inhibit_small_deltas_when_virtual)
1067 {
1068 struct litest_device *dev = litest_current_device();
1069 struct libinput *li = dev->libinput;
1070
1071 litest_drain_events(li);
1072
1073 /* Scroll deltas below the threshold (60) must *not* be ignored */
1074 litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 15);
1075 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1076 litest_dispatch(li);
1077 test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -15);
1078 }
1079 END_TEST
1080
1081 START_TEST(pointer_scroll_wheel_lenovo_scrollpoint)
1082 {
1083 struct litest_device *dev = litest_current_device();
1084 struct libinput *li = dev->libinput;
1085 struct libinput_event *event;
1086 struct libinput_event_pointer *ptrev;
1087 double v;
1088
1089 litest_drain_events(dev->libinput);
1090
1091 /* Lenovo ScrollPoint has a trackstick instead of a wheel, data sent
1092 * via REL_WHEEL is close to x/y coordinate space.
1093 */
1094 litest_event(dev, EV_REL, REL_WHEEL, 30);
1095 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1096 litest_event(dev, EV_REL, REL_WHEEL, -60);
1097 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1098 litest_dispatch(li);
1099
1100 /* Hi-res scroll event first */
1101 event = libinput_get_event(li);
1102 litest_assert(litest_is_high_res_axis_event(event));
1103 ptrev = litest_is_axis_event(event,
1104 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1105 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1106 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
1107
1108 v = libinput_event_pointer_get_scroll_value(
1109 ptrev,
1110 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
1111 litest_assert_double_eq(v, -30.0);
1112 libinput_event_destroy(event);
1113
1114 /* legacy lo-res scroll event */
1115 event = libinput_get_event(li);
1116 litest_assert(!litest_is_high_res_axis_event(event));
1117 ptrev = litest_is_axis_event(event,
1118 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1119 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1120 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
1121 v = libinput_event_pointer_get_axis_value(
1122 ptrev,
1123 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
1124 litest_assert_double_eq(v, -30.0);
1125 libinput_event_destroy(event);
1126
1127 /* Hi-res scroll event first */
1128 event = libinput_get_event(li);
1129 ptrev = litest_is_axis_event(event,
1130 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1131 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1132 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
1133
1134 v = libinput_event_pointer_get_scroll_value(
1135 ptrev,
1136 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
1137 litest_assert_double_eq(v, 60.0);
1138 libinput_event_destroy(event);
1139
1140 /* legacy lo-res scroll event */
1141 event = libinput_get_event(li);
1142 litest_assert(!litest_is_high_res_axis_event(event));
1143 ptrev = litest_is_axis_event(event,
1144 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1145 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1146 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
1147 v = libinput_event_pointer_get_axis_value(
1148 ptrev,
1149 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
1150 litest_assert_double_eq(v, 60.0);
1151 libinput_event_destroy(event);
1152 }
1153 END_TEST
1154
1155 START_TEST(pointer_scroll_natural_defaults)
1156 {
1157 struct litest_device *dev = litest_current_device();
1158
1159 litest_assert_int_ge(
1160 libinput_device_config_scroll_has_natural_scroll(dev->libinput_device),
1161 1);
1162 litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(
1163 dev->libinput_device),
1164 0);
1165 litest_assert_int_eq(
1166 libinput_device_config_scroll_get_default_natural_scroll_enabled(
1167 dev->libinput_device),
1168 0);
1169 }
1170 END_TEST
1171
1172 START_TEST(pointer_scroll_natural_defaults_noscroll)
1173 {
1174 struct litest_device *dev = litest_current_device();
1175
1176 if (libinput_device_config_scroll_has_natural_scroll(dev->libinput_device))
1177 return LITEST_NOT_APPLICABLE;
1178
1179 litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(
1180 dev->libinput_device),
1181 0);
1182 litest_assert_int_eq(
1183 libinput_device_config_scroll_get_default_natural_scroll_enabled(
1184 dev->libinput_device),
1185 0);
1186 }
1187 END_TEST
1188
1189 START_TEST(pointer_scroll_natural_enable_config)
1190 {
1191 struct litest_device *dev = litest_current_device();
1192 enum libinput_config_status status;
1193
1194 status = libinput_device_config_scroll_set_natural_scroll_enabled(
1195 dev->libinput_device,
1196 1);
1197 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1198 litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(
1199 dev->libinput_device),
1200 1);
1201
1202 status = libinput_device_config_scroll_set_natural_scroll_enabled(
1203 dev->libinput_device,
1204 0);
1205 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1206 litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(
1207 dev->libinput_device),
1208 0);
1209 }
1210 END_TEST
1211
1212 START_TEST(pointer_scroll_natural_wheel)
1213 {
1214 struct litest_device *dev = litest_current_device();
1215 struct libinput_device *device = dev->libinput_device;
1216
1217 litest_drain_events(dev->libinput);
1218
1219 libinput_device_config_scroll_set_natural_scroll_enabled(device, 1);
1220
1221 /* make sure we hit at least one of the below two conditions */
1222 litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
1223 libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
1224
1225 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
1226 test_wheel_event(dev, REL_WHEEL, -1);
1227 test_wheel_event(dev, REL_WHEEL, 1);
1228
1229 test_wheel_event(dev, REL_WHEEL, -5);
1230 test_wheel_event(dev, REL_WHEEL, 6);
1231 }
1232
1233 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL)) {
1234 test_wheel_event(dev, REL_HWHEEL, -1);
1235 test_wheel_event(dev, REL_HWHEEL, 1);
1236
1237 test_wheel_event(dev, REL_HWHEEL, -5);
1238 test_wheel_event(dev, REL_HWHEEL, 6);
1239 }
1240 }
1241 END_TEST
1242
1243 START_TEST(pointer_scroll_has_axis_invalid)
1244 {
1245 struct litest_device *dev = litest_current_device();
1246 struct libinput *li = dev->libinput;
1247 struct libinput_event *event;
1248 struct libinput_event_pointer *pev;
1249
1250 litest_drain_events(dev->libinput);
1251
1252 if (!libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL))
1253 return LITEST_NOT_APPLICABLE;
1254
1255 litest_event(dev, EV_REL, REL_WHEEL, 1);
1256 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1257
1258 litest_dispatch(li);
1259 event = libinput_get_event(li);
1260 pev = litest_is_axis_event(event,
1261 LIBINPUT_EVENT_POINTER_SCROLL_WHEEL,
1262 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1263 0);
1264
1265 litest_assert_int_eq(libinput_event_pointer_has_axis(pev, -1), 0);
1266 litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 2), 0);
1267 litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 3), 0);
1268 litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 0xffff), 0);
1269 libinput_event_destroy(event);
1270 }
1271 END_TEST
1272
1273 START_TEST(pointer_scroll_with_rotation)
1274 {
1275 struct litest_device *dev = litest_current_device();
1276 struct libinput *li = dev->libinput;
1277 struct libinput_device *device = dev->libinput_device;
1278 double angle = litest_test_param_get_double(test_env->params, "angle");
1279
1280 litest_drain_events(li);
1281 libinput_device_config_rotation_set_angle(device, angle);
1282
1283 /* make sure we hit at least one of the below two conditions */
1284 litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
1285 libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
1286
1287 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
1288 test_wheel_event(dev, REL_WHEEL, -1);
1289 test_wheel_event(dev, REL_WHEEL, 1);
1290
1291 test_wheel_event(dev, REL_WHEEL, -5);
1292 test_wheel_event(dev, REL_WHEEL, 6);
1293 }
1294
1295 if (libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL)) {
1296 test_wheel_event(dev, REL_HWHEEL, -1);
1297 test_wheel_event(dev, REL_HWHEEL, 1);
1298
1299 test_wheel_event(dev, REL_HWHEEL, -5);
1300 test_wheel_event(dev, REL_HWHEEL, 6);
1301 }
1302 }
1303 END_TEST
1304
1305 START_TEST(pointer_seat_button_count)
1306 {
1307 struct litest_device *devices[4];
1308 const int num_devices = ARRAY_LENGTH(devices);
1309 struct libinput_event *ev;
1310 struct libinput_event_pointer *tev;
1311 int i;
1312 int seat_button_count = 0;
1313 int expected_seat_button_count = 0;
1314 char device_name[255];
1315
1316 _litest_context_destroy_ struct libinput *libinput = litest_create_context();
1317 for (i = 0; i < num_devices; ++i) {
1318 sprintf(device_name, "litest Generic mouse (%d)", i);
1319 devices[i] = litest_add_device_with_overrides(libinput,
1320 LITEST_MOUSE,
1321 device_name,
1322 NULL,
1323 NULL,
1324 NULL);
1325 }
1326
1327 for (i = 0; i < num_devices; ++i)
1328 litest_button_click_debounced(devices[i], libinput, BTN_LEFT, true);
1329
1330 litest_dispatch(libinput);
1331 while ((ev = libinput_get_event(libinput))) {
1332 if (libinput_event_get_type(ev) != LIBINPUT_EVENT_POINTER_BUTTON) {
1333 libinput_event_destroy(ev);
1334 litest_dispatch(libinput);
1335 continue;
1336 }
1337
1338 tev = libinput_event_get_pointer_event(ev);
1339 litest_assert_notnull(tev);
1340 litest_assert_int_eq(libinput_event_pointer_get_button(tev),
1341 (unsigned int)BTN_LEFT);
1342 litest_assert_enum_eq(libinput_event_pointer_get_button_state(tev),
1343 LIBINPUT_BUTTON_STATE_PRESSED);
1344
1345 ++expected_seat_button_count;
1346 seat_button_count = libinput_event_pointer_get_seat_button_count(tev);
1347 litest_assert_int_eq(expected_seat_button_count, seat_button_count);
1348
1349 libinput_event_destroy(ev);
1350 litest_dispatch(libinput);
1351 }
1352
1353 litest_assert_int_eq(seat_button_count, num_devices);
1354
1355 for (i = 0; i < num_devices; ++i)
1356 litest_button_click_debounced(devices[i], libinput, BTN_LEFT, false);
1357
1358 litest_dispatch(libinput);
1359 while ((ev = libinput_get_event(libinput))) {
1360 if (libinput_event_get_type(ev) != LIBINPUT_EVENT_POINTER_BUTTON) {
1361 libinput_event_destroy(ev);
1362 litest_dispatch(libinput);
1363 continue;
1364 }
1365
1366 tev = libinput_event_get_pointer_event(ev);
1367 litest_assert_notnull(tev);
1368 litest_assert_int_eq(libinput_event_pointer_get_button(tev),
1369 (unsigned int)BTN_LEFT);
1370 litest_assert_enum_eq(libinput_event_pointer_get_button_state(tev),
1371 LIBINPUT_BUTTON_STATE_RELEASED);
1372
1373 --expected_seat_button_count;
1374 seat_button_count = libinput_event_pointer_get_seat_button_count(tev);
1375 litest_assert_int_eq(expected_seat_button_count, seat_button_count);
1376
1377 libinput_event_destroy(ev);
1378 litest_dispatch(libinput);
1379 }
1380
1381 litest_assert_int_eq(seat_button_count, 0);
1382
1383 for (i = 0; i < num_devices; ++i)
1384 litest_device_destroy(devices[i]);
1385 }
1386 END_TEST
1387
1388 START_TEST(pointer_no_calibration)
1389 {
1390 struct litest_device *dev = litest_current_device();
1391 struct libinput_device *d = dev->libinput_device;
1392 enum libinput_config_status status;
1393 int rc;
1394 float calibration[6] = { 0 };
1395
1396 rc = libinput_device_config_calibration_has_matrix(d);
1397 litest_assert_int_eq(rc, 0);
1398 rc = libinput_device_config_calibration_get_matrix(d, calibration);
1399 litest_assert_int_eq(rc, 0);
1400 rc = libinput_device_config_calibration_get_default_matrix(d, calibration);
1401 litest_assert_int_eq(rc, 0);
1402
1403 status = libinput_device_config_calibration_set_matrix(d, calibration);
1404 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
1405 }
1406 END_TEST
1407
1408 START_TEST(pointer_left_handed_defaults)
1409 {
1410 struct litest_device *dev = litest_current_device();
1411 struct libinput_device *d = dev->libinput_device;
1412 int rc;
1413
1414 if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_APPLE &&
1415 libevdev_get_id_product(dev->evdev) == PRODUCT_ID_APPLE_APPLETOUCH)
1416 return LITEST_NOT_APPLICABLE;
1417
1418 rc = libinput_device_config_left_handed_is_available(d);
1419 litest_assert_int_ne(rc, 0);
1420
1421 rc = libinput_device_config_left_handed_get(d);
1422 litest_assert_int_eq(rc, 0);
1423
1424 rc = libinput_device_config_left_handed_get_default(d);
1425 litest_assert_int_eq(rc, 0);
1426 }
1427 END_TEST
1428
1429 START_TEST(pointer_left_handed)
1430 {
1431 struct litest_device *dev = litest_current_device();
1432 struct libinput_device *d = dev->libinput_device;
1433 struct libinput *li = dev->libinput;
1434 enum libinput_config_status status;
1435
1436 status = libinput_device_config_left_handed_set(d, 1);
1437 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1438
1439 litest_drain_events(li);
1440 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
1441 litest_button_click_debounced(dev, li, BTN_LEFT, 0);
1442
1443 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1444 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1445
1446 litest_button_click_debounced(dev, li, BTN_RIGHT, 1);
1447 litest_button_click_debounced(dev, li, BTN_RIGHT, 0);
1448 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1449 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1450
1451 if (libinput_device_pointer_has_button(d, BTN_MIDDLE)) {
1452 litest_button_click_debounced(dev, li, BTN_MIDDLE, 1);
1453 litest_button_click_debounced(dev, li, BTN_MIDDLE, 0);
1454 litest_assert_button_event(li,
1455 BTN_MIDDLE,
1456 LIBINPUT_BUTTON_STATE_PRESSED);
1457 litest_assert_button_event(li,
1458 BTN_MIDDLE,
1459 LIBINPUT_BUTTON_STATE_RELEASED);
1460 }
1461 }
1462 END_TEST
1463
1464 START_TEST(pointer_left_handed_during_click)
1465 {
1466 struct litest_device *dev = litest_current_device();
1467 struct libinput_device *d = dev->libinput_device;
1468 struct libinput *li = dev->libinput;
1469 enum libinput_config_status status;
1470
1471 litest_drain_events(li);
1472 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
1473 litest_dispatch(li);
1474
1475 /* Change while button is down, expect correct release event */
1476 status = libinput_device_config_left_handed_set(d, 1);
1477 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1478
1479 litest_button_click_debounced(dev, li, BTN_LEFT, 0);
1480
1481 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1482 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1483 }
1484 END_TEST
1485
1486 START_TEST(pointer_left_handed_during_click_multiple_buttons)
1487 {
1488 struct litest_device *dev = litest_current_device();
1489 struct libinput_device *d = dev->libinput_device;
1490 struct libinput *li = dev->libinput;
1491 enum libinput_config_status status;
1492
1493 if (!libinput_device_pointer_has_button(d, BTN_MIDDLE))
1494 return LITEST_NOT_APPLICABLE;
1495
1496 litest_disable_middleemu(dev);
1497
1498 litest_drain_events(li);
1499 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
1500 litest_dispatch(li);
1501
1502 status = libinput_device_config_left_handed_set(d, 1);
1503 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1504
1505 /* No left-handed until all buttons were down */
1506 litest_button_click_debounced(dev, li, BTN_RIGHT, 1);
1507 litest_button_click_debounced(dev, li, BTN_RIGHT, 0);
1508 litest_button_click_debounced(dev, li, BTN_LEFT, 0);
1509
1510 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1511 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1512 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1513 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1514 }
1515 END_TEST
1516
1517 START_TEST(pointer_left_handed_disable_with_button_down)
1518 {
1519 _litest_context_destroy_ struct libinput *li = litest_create_context();
1520 struct litest_device *dev = litest_add_device(li, LITEST_MOUSE);
1521
1522 enum libinput_config_status status;
1523 status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
1524 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1525
1526 litest_drain_events(li);
1527 litest_button_click_debounced(dev, li, BTN_LEFT, 1);
1528 litest_dispatch(li);
1529 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1530
1531 litest_device_destroy(dev);
1532 litest_dispatch(li);
1533
1534 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1535
1536 struct libinput_event *event = libinput_get_event(li);
1537 litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
1538 litest_assert_empty_queue(li);
1539 libinput_event_destroy(event);
1540 }
1541 END_TEST
1542
1543 START_TEST(pointer_scroll_button)
1544 {
1545 struct litest_device *dev = litest_current_device();
1546 struct libinput *li = dev->libinput;
1547
1548 /* Make left button switch to scrolling mode */
1549 libinput_device_config_scroll_set_method(dev->libinput_device,
1550 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1551 libinput_device_config_scroll_set_button(dev->libinput_device, BTN_LEFT);
1552
1553 litest_drain_events(li);
1554
1555 litest_button_scroll(dev, BTN_LEFT, 1, 6);
1556 litest_assert_scroll(li,
1557 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1558 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1559 6);
1560 litest_button_scroll(dev, BTN_LEFT, 1, -7);
1561 litest_assert_scroll(li,
1562 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1563 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1564 -7);
1565 litest_button_scroll(dev, BTN_LEFT, 8, 1);
1566 litest_assert_scroll(li,
1567 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1568 LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
1569 8);
1570 litest_button_scroll(dev, BTN_LEFT, -9, 1);
1571 litest_assert_scroll(li,
1572 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1573 LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
1574 -9);
1575
1576 /* scroll smaller than the threshold should not generate axis events */
1577 litest_button_scroll(dev, BTN_LEFT, 1, 1);
1578
1579 litest_button_scroll(dev, BTN_LEFT, 0, 0);
1580 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1581 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1582 litest_assert_empty_queue(li);
1583
1584 /* Restore default scroll behavior */
1585 libinput_device_config_scroll_set_method(
1586 dev->libinput_device,
1587 libinput_device_config_scroll_get_default_method(dev->libinput_device));
1588 libinput_device_config_scroll_set_button(
1589 dev->libinput_device,
1590 libinput_device_config_scroll_get_default_button(dev->libinput_device));
1591 }
1592 END_TEST
1593
1594 START_TEST(pointer_scroll_button_noscroll)
1595 {
1596 struct litest_device *dev = litest_current_device();
1597 struct libinput_device *device = dev->libinput_device;
1598 uint32_t methods, button;
1599 enum libinput_config_status status;
1600
1601 methods = libinput_device_config_scroll_get_method(device);
1602 litest_assert_int_eq(methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN, 0U);
1603 button = libinput_device_config_scroll_get_button(device);
1604 litest_assert_int_eq(button, 0U);
1605 button = libinput_device_config_scroll_get_default_button(device);
1606 litest_assert_int_eq(button, 0U);
1607
1608 status = libinput_device_config_scroll_set_method(
1609 device,
1610 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1611 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
1612 status = libinput_device_config_scroll_set_button(device, BTN_LEFT);
1613 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
1614 }
1615 END_TEST
1616
1617 START_TEST(pointer_scroll_button_no_event_before_timeout)
1618 {
1619 struct litest_device *device = litest_current_device();
1620 struct libinput *li = device->libinput;
1621 int i;
1622
1623 if (!libinput_device_pointer_has_button(device->libinput_device, BTN_MIDDLE))
1624 return LITEST_NOT_APPLICABLE;
1625
1626 litest_disable_middleemu(device);
1627 disable_button_scrolling(device);
1628
1629 libinput_device_config_scroll_set_method(device->libinput_device,
1630 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1631 libinput_device_config_scroll_set_button(device->libinput_device, BTN_LEFT);
1632 litest_drain_events(li);
1633
1634 litest_button_click_debounced(device, li, BTN_LEFT, true);
1635 litest_assert_empty_queue(li);
1636
1637 for (i = 0; i < 10; i++) {
1638 litest_event(device, EV_REL, REL_Y, 1);
1639 litest_event(device, EV_SYN, SYN_REPORT, 0);
1640 }
1641 litest_assert_empty_queue(li);
1642
1643 litest_timeout_buttonscroll(li);
1644 litest_button_click_debounced(device, li, BTN_LEFT, false);
1645
1646 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1647 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1648 litest_assert_empty_queue(li);
1649 }
1650 END_TEST
1651
1652 START_TEST(pointer_scroll_button_middle_emulation)
1653 {
1654 struct litest_device *dev = litest_current_device();
1655 struct libinput_device *device = dev->libinput_device;
1656 struct libinput *li = dev->libinput;
1657 enum libinput_config_status status;
1658 int i;
1659
1660 status = libinput_device_config_middle_emulation_set_enabled(
1661 device,
1662 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
1663
1664 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
1665 return LITEST_NOT_APPLICABLE;
1666
1667 status = libinput_device_config_scroll_set_method(
1668 device,
1669 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1670 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1671 status = libinput_device_config_scroll_set_button(device, BTN_MIDDLE);
1672 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1673
1674 litest_drain_events(li);
1675
1676 litest_button_click(dev, BTN_LEFT, 1);
1677 litest_button_click(dev, BTN_RIGHT, 1);
1678 litest_timeout_buttonscroll(li);
1679
1680 for (i = 0; i < 10; i++) {
1681 litest_event(dev, EV_REL, REL_Y, -1);
1682 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1683 }
1684
1685 litest_dispatch(li);
1686
1687 litest_button_click(dev, BTN_LEFT, 0);
1688 litest_button_click(dev, BTN_RIGHT, 0);
1689 litest_dispatch(li);
1690
1691 litest_assert_scroll(li,
1692 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1693 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1694 -1);
1695 litest_assert_empty_queue(li);
1696
1697 /* Restore default scroll behavior */
1698 libinput_device_config_scroll_set_method(
1699 dev->libinput_device,
1700 libinput_device_config_scroll_get_default_method(dev->libinput_device));
1701 libinput_device_config_scroll_set_button(
1702 dev->libinput_device,
1703 libinput_device_config_scroll_get_default_button(dev->libinput_device));
1704 }
1705 END_TEST
1706
1707 START_TEST(pointer_scroll_button_device_remove_while_down)
1708 {
1709 struct litest_device *dev;
1710
1711 _litest_context_destroy_ struct libinput *li = litest_create_context();
1712
1713 dev = litest_add_device(li, LITEST_MOUSE);
1714 libinput_device_config_scroll_set_method(dev->libinput_device,
1715 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1716 libinput_device_config_scroll_set_button(dev->libinput_device, BTN_LEFT);
1717 litest_drain_events(li);
1718
1719 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1720 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1721 litest_dispatch(li);
1722
1723 /* delete the device while the timer is still active */
1724 litest_device_destroy(dev);
1725 litest_dispatch(li);
1726 }
1727 END_TEST
1728
1729 static void
1730 litest_enable_scroll_button_lock(struct litest_device *dev, unsigned int button)
1731 {
1732 struct libinput_device *device = dev->libinput_device;
1733 enum libinput_config_status status;
1734
1735 status = libinput_device_config_scroll_set_method(
1736 device,
1737 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1738 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1739
1740 status = libinput_device_config_scroll_set_button(device, button);
1741 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1742
1743 status = libinput_device_config_scroll_set_button_lock(
1744 device,
1745 LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
1746 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1747 }
1748
1749 START_TEST(pointer_scroll_button_lock)
1750 {
1751 struct litest_device *dev = litest_current_device();
1752 struct libinput *li = dev->libinput;
1753
1754 litest_enable_scroll_button_lock(dev, BTN_LEFT);
1755 litest_disable_middleemu(dev);
1756
1757 litest_drain_events(li);
1758
1759 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1760 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1761
1762 litest_assert_empty_queue(li);
1763
1764 litest_timeout_buttonscroll(li);
1765
1766 for (int i = 0; i < 10; i++) {
1767 litest_event(dev, EV_REL, REL_X, 1);
1768 litest_event(dev, EV_REL, REL_Y, 6);
1769 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1770 }
1771
1772 litest_dispatch(li);
1773
1774 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1775 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1776 litest_dispatch(li);
1777
1778 litest_assert_scroll(li,
1779 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1780 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1781 6);
1782
1783 litest_assert_empty_queue(li);
1784
1785 /* back to motion */
1786 for (int i = 0; i < 10; i++) {
1787 litest_event(dev, EV_REL, REL_X, 1);
1788 litest_event(dev, EV_REL, REL_Y, 6);
1789 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1790 }
1791 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1792 }
1793 END_TEST
1794
1795 START_TEST(pointer_scroll_button_lock_defaults)
1796 {
1797 struct litest_device *dev = litest_current_device();
1798 enum libinput_config_scroll_button_lock_state state;
1799
1800 state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
1801 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1802 state = libinput_device_config_scroll_get_default_button_lock(
1803 dev->libinput_device);
1804 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1805 }
1806 END_TEST
1807
1808 START_TEST(pointer_scroll_button_lock_config)
1809 {
1810 struct litest_device *dev = litest_current_device();
1811 enum libinput_config_status status;
1812 enum libinput_config_scroll_button_lock_state state;
1813
1814 state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
1815 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1816 state = libinput_device_config_scroll_get_default_button_lock(
1817 dev->libinput_device);
1818 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1819
1820 status = libinput_device_config_scroll_set_button_lock(
1821 dev->libinput_device,
1822 LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1823 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1824 state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
1825 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
1826
1827 status = libinput_device_config_scroll_set_button_lock(
1828 dev->libinput_device,
1829 LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
1830 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1831 state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
1832 litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
1833
1834 status = libinput_device_config_scroll_set_button_lock(
1835 dev->libinput_device,
1836 LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED + 1);
1837 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
1838 }
1839 END_TEST
1840
1841 START_TEST(pointer_scroll_button_lock_enable_while_down)
1842 {
1843 struct litest_device *dev = litest_current_device();
1844 struct libinput *li = dev->libinput;
1845
1846 litest_disable_middleemu(dev);
1847 litest_drain_events(li);
1848
1849 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1850
1851 /* Enable lock while button is down */
1852 litest_enable_scroll_button_lock(dev, BTN_LEFT);
1853
1854 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1855 litest_assert_empty_queue(li);
1856
1857 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1858 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1859 litest_assert_empty_queue(li);
1860
1861 for (int i = 0; i < 10; i++) {
1862 litest_event(dev, EV_REL, REL_X, 1);
1863 litest_event(dev, EV_REL, REL_Y, 6);
1864 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1865 }
1866
1867 /* no scrolling yet */
1868 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1869
1870 /* but on the next button press we scroll lock */
1871 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1872 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1873 litest_timeout_buttonscroll(li);
1874
1875 for (int i = 0; i < 10; i++) {
1876 litest_event(dev, EV_REL, REL_X, 1);
1877 litest_event(dev, EV_REL, REL_Y, 6);
1878 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1879 }
1880
1881 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1882 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1883
1884 litest_assert_scroll(li,
1885 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1886 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1887 6);
1888
1889 litest_assert_empty_queue(li);
1890
1891 /* back to motion */
1892 for (int i = 0; i < 10; i++) {
1893 litest_event(dev, EV_REL, REL_X, 1);
1894 litest_event(dev, EV_REL, REL_Y, 6);
1895 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1896 }
1897 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1898 }
1899 END_TEST
1900
1901 START_TEST(pointer_scroll_button_lock_enable_while_down_just_lock)
1902 {
1903 struct litest_device *dev = litest_current_device();
1904 struct libinput *li = dev->libinput;
1905
1906 litest_disable_middleemu(dev);
1907 litest_drain_events(li);
1908
1909 /* switch method first, but enable lock when we already have a
1910 * button down */
1911 libinput_device_config_scroll_set_method(dev->libinput_device,
1912 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
1913 libinput_device_config_scroll_set_button(dev->libinput_device, BTN_LEFT);
1914
1915 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1916 libinput_device_config_scroll_set_button_lock(
1917 dev->libinput_device,
1918 LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
1919
1920 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1921 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1922 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1923 litest_assert_empty_queue(li);
1924
1925 for (int i = 0; i < 10; i++) {
1926 litest_event(dev, EV_REL, REL_X, 1);
1927 litest_event(dev, EV_REL, REL_Y, 6);
1928 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1929 }
1930
1931 /* no scrolling yet */
1932 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1933
1934 /* but on the next button press we scroll lock */
1935 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1936 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1937 litest_timeout_buttonscroll(li);
1938
1939 for (int i = 0; i < 10; i++) {
1940 litest_event(dev, EV_REL, REL_X, 1);
1941 litest_event(dev, EV_REL, REL_Y, 6);
1942 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1943 }
1944
1945 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1946 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1947
1948 litest_assert_scroll(li,
1949 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
1950 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1951 6);
1952
1953 litest_assert_empty_queue(li);
1954
1955 /* back to motion */
1956 for (int i = 0; i < 10; i++) {
1957 litest_event(dev, EV_REL, REL_X, 1);
1958 litest_event(dev, EV_REL, REL_Y, 6);
1959 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1960 }
1961 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1962 }
1963 END_TEST
1964
1965 START_TEST(pointer_scroll_button_lock_otherbutton)
1966 {
1967 struct litest_device *dev = litest_current_device();
1968 struct libinput *li = dev->libinput;
1969
1970 litest_disable_middleemu(dev);
1971 litest_drain_events(li);
1972
1973 litest_enable_scroll_button_lock(dev, BTN_LEFT);
1974
1975 litest_button_click_debounced(dev, li, BTN_LEFT, true);
1976 litest_button_click_debounced(dev, li, BTN_LEFT, false);
1977 litest_assert_empty_queue(li);
1978 litest_timeout_buttonscroll(li);
1979
1980 /* other button passes on normally */
1981 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
1982 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
1983 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1984 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1985 litest_assert_empty_queue(li);
1986
1987 for (int i = 0; i < 10; i++) {
1988 litest_event(dev, EV_REL, REL_X, 1);
1989 litest_event(dev, EV_REL, REL_Y, 6);
1990 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1991 }
1992 litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS);
1993
1994 /* other button passes on normally */
1995 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
1996 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
1997 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1998 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1999
2000 /* stop scroll lock */
2001 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2002 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2003 litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS);
2004
2005 /* other button passes on normally */
2006 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2007 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2008 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2009 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2010
2011 litest_assert_empty_queue(li);
2012 }
2013 END_TEST
2014
2015 START_TEST(pointer_scroll_button_lock_enable_while_otherbutton_down)
2016 {
2017 struct litest_device *dev = litest_current_device();
2018 struct libinput *li = dev->libinput;
2019
2020 litest_disable_middleemu(dev);
2021 litest_drain_events(li);
2022
2023 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2024 litest_timeout_middlebutton(li);
2025 litest_drain_events(li);
2026
2027 /* Enable lock while button is down */
2028 litest_enable_scroll_button_lock(dev, BTN_LEFT);
2029
2030 /* We only enable once we go to a neutral state so this still counts
2031 * as normal button event */
2032 for (int twice = 0; twice < 2; twice++) {
2033 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2034 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2035 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2036 litest_assert_button_event(li,
2037 BTN_LEFT,
2038 LIBINPUT_BUTTON_STATE_RELEASED);
2039
2040 for (int i = 0; i < 10; i++) {
2041 litest_event(dev, EV_REL, REL_X, 1);
2042 litest_event(dev, EV_REL, REL_Y, 6);
2043 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2044 }
2045 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
2046 }
2047
2048 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2049 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2050 litest_assert_empty_queue(li);
2051
2052 /* now we should trigger it */
2053 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2054 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2055 litest_timeout_buttonscroll(li);
2056 litest_assert_empty_queue(li);
2057
2058 for (int i = 0; i < 10; i++) {
2059 litest_event(dev, EV_REL, REL_X, 1);
2060 litest_event(dev, EV_REL, REL_Y, 6);
2061 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2062 }
2063
2064 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2065 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2066 litest_assert_scroll(li,
2067 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
2068 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
2069 6);
2070 litest_assert_empty_queue(li);
2071
2072 /* back to motion */
2073 for (int i = 0; i < 10; i++) {
2074 litest_event(dev, EV_REL, REL_X, 1);
2075 litest_event(dev, EV_REL, REL_Y, 6);
2076 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2077 }
2078 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
2079 }
2080 END_TEST
2081
2082 enum mb_buttonorder {
2083 LLRR, /* left down, left up, r down, r up */
2084 LRLR, /* left down, right down, left up, right up */
2085 LRRL,
2086 RRLL,
2087 RLRL,
2088 RLLR
2089 };
2090
2091 START_TEST(pointer_scroll_button_lock_middlebutton)
2092 {
2093 struct litest_device *dev = litest_current_device();
2094 struct libinput *li = dev->libinput;
2095 enum mb_buttonorder buttonorder =
2096 litest_test_param_get_i32(test_env->params, "buttonorder");
2097
2098 if (!libinput_device_config_middle_emulation_is_available(dev->libinput_device))
2099 return LITEST_NOT_APPLICABLE;
2100
2101 litest_enable_middleemu(dev);
2102
2103 litest_enable_scroll_button_lock(dev, BTN_LEFT);
2104 litest_drain_events(li);
2105
2106 /* We expect scroll lock to work only where left and right are never
2107 * held down simultaneously. Everywhere else we expect middle button
2108 * instead.
2109 */
2110 switch (buttonorder) {
2111 case LLRR:
2112 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2113 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2114 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2115 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2116 break;
2117 case LRLR:
2118 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2119 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2120 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2121 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2122 break;
2123 case LRRL:
2124 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2125 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2126 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2127 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2128 break;
2129 case RRLL:
2130 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2131 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2132 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2133 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2134 break;
2135 case RLRL:
2136 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2137 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2138 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2139 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2140 break;
2141 case RLLR:
2142 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2143 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2144 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2145 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2146 break;
2147 default:
2148 abort();
2149 }
2150
2151 litest_timeout_middlebutton(li);
2152 litest_timeout_buttonscroll(li);
2153
2154 /* motion events are the same for all of them */
2155 for (int i = 0; i < 10; i++) {
2156 litest_event(dev, EV_REL, REL_X, 1);
2157 litest_event(dev, EV_REL, REL_Y, 6);
2158 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2159 }
2160
2161 litest_dispatch(li);
2162
2163 switch (buttonorder) {
2164 case LLRR:
2165 case RRLL:
2166 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2167 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2168 break;
2169 default:
2170 break;
2171 }
2172
2173 litest_dispatch(li);
2174
2175 switch (buttonorder) {
2176 case LLRR:
2177 case RRLL:
2178 litest_assert_button_event(li,
2179 BTN_RIGHT,
2180 LIBINPUT_BUTTON_STATE_PRESSED);
2181 litest_assert_button_event(li,
2182 BTN_RIGHT,
2183 LIBINPUT_BUTTON_STATE_RELEASED);
2184 litest_assert_scroll(li,
2185 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
2186 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
2187 6);
2188 litest_assert_empty_queue(li);
2189 break;
2190 case LRLR:
2191 case LRRL:
2192 case RLRL:
2193 case RLLR:
2194 litest_assert_button_event(li,
2195 BTN_MIDDLE,
2196 LIBINPUT_BUTTON_STATE_PRESSED);
2197 litest_assert_button_event(li,
2198 BTN_MIDDLE,
2199 LIBINPUT_BUTTON_STATE_RELEASED);
2200 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
2201 break;
2202 default:
2203 abort();
2204 }
2205 }
2206 END_TEST
2207
2208 START_TEST(pointer_scroll_button_lock_doubleclick_nomove)
2209 {
2210 struct litest_device *dev = litest_current_device();
2211 struct libinput *li = dev->libinput;
2212
2213 litest_disable_middleemu(dev);
2214 litest_enable_scroll_button_lock(dev, BTN_LEFT);
2215 litest_drain_events(li);
2216
2217 /* double click without move in between counts as single click */
2218 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2219 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2220 litest_assert_empty_queue(li);
2221 litest_button_click_debounced(dev, li, BTN_LEFT, true);
2222 litest_button_click_debounced(dev, li, BTN_LEFT, false);
2223
2224 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2225 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2226 litest_assert_empty_queue(li);
2227
2228 /* But a non-scroll button it should work normally */
2229 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2230 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2231 litest_button_click_debounced(dev, li, BTN_RIGHT, true);
2232 litest_button_click_debounced(dev, li, BTN_RIGHT, false);
2233 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2234 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2235 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2236 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2237 litest_assert_empty_queue(li);
2238 }
2239 END_TEST
2240
2241 START_TEST(pointer_scroll_nowheel_defaults)
2242 {
2243 struct litest_device *dev = litest_current_device();
2244 struct libinput_device *device = dev->libinput_device;
2245 enum libinput_config_scroll_method method, expected;
2246 uint32_t button;
2247
2248 /* button scrolling is only enabled if there is a
2249 middle button present */
2250 if (libinput_device_pointer_has_button(device, BTN_MIDDLE) &&
2251 dev->which != LITEST_LENOVO_SCROLLPOINT)
2252 expected = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
2253 else
2254 expected = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
2255
2256 method = libinput_device_config_scroll_get_method(device);
2257 litest_assert_int_eq(method, expected);
2258
2259 method = libinput_device_config_scroll_get_default_method(device);
2260 litest_assert_int_eq(method, expected);
2261
2262 if (method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) {
2263 button = libinput_device_config_scroll_get_button(device);
2264 litest_assert_int_eq(button, (unsigned int)BTN_MIDDLE);
2265 button = libinput_device_config_scroll_get_default_button(device);
2266 litest_assert_int_eq(button, (unsigned int)BTN_MIDDLE);
2267 }
2268 }
2269 END_TEST
2270
2271 START_TEST(pointer_scroll_defaults_logitech_marble)
2272 {
2273 struct litest_device *dev = litest_current_device();
2274 struct libinput_device *device = dev->libinput_device;
2275 enum libinput_config_scroll_method method;
2276 uint32_t button;
2277
2278 method = libinput_device_config_scroll_get_method(device);
2279 litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
2280 method = libinput_device_config_scroll_get_default_method(device);
2281 litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
2282
2283 button = libinput_device_config_scroll_get_button(device);
2284 litest_assert_int_eq(button, (unsigned int)BTN_SIDE);
2285 }
2286 END_TEST
2287
2288 START_TEST(pointer_accel_defaults)
2289 {
2290 struct litest_device *dev = litest_current_device();
2291 struct libinput_device *device = dev->libinput_device;
2292 enum libinput_config_status status;
2293 double speed;
2294
2295 litest_assert(libinput_device_config_accel_is_available(device));
2296 litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
2297 0.0);
2298 litest_assert_double_eq(libinput_device_config_accel_get_speed(device), 0.0);
2299
2300 for (speed = -2.0; speed < -1.0; speed += 0.2) {
2301 status = libinput_device_config_accel_set_speed(device, speed);
2302 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2303 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2304 0.0);
2305 }
2306
2307 for (speed = -1.0; speed <= 1.0; speed += 0.2) {
2308 status = libinput_device_config_accel_set_speed(device, speed);
2309 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2310 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2311 speed);
2312 }
2313
2314 for (speed = 1.2; speed <= 2.0; speed += 0.2) {
2315 status = libinput_device_config_accel_set_speed(device, speed);
2316 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2317 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2318 1.0);
2319 }
2320 }
2321 END_TEST
2322
2323 START_TEST(pointer_accel_invalid)
2324 {
2325 struct litest_device *dev = litest_current_device();
2326 struct libinput_device *device = dev->libinput_device;
2327 enum libinput_config_status status;
2328
2329 litest_assert(libinput_device_config_accel_is_available(device));
2330
2331 status = libinput_device_config_accel_set_speed(device, NAN);
2332 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2333 status = libinput_device_config_accel_set_speed(device, INFINITY);
2334 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2335 }
2336 END_TEST
2337
2338 START_TEST(pointer_accel_defaults_absolute)
2339 {
2340 struct litest_device *dev = litest_current_device();
2341 struct libinput_device *device = dev->libinput_device;
2342 enum libinput_config_status status;
2343 double speed;
2344
2345 litest_assert(!libinput_device_config_accel_is_available(device));
2346 litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
2347 0.0);
2348 litest_assert_double_eq(libinput_device_config_accel_get_speed(device), 0.0);
2349
2350 for (speed = -2.0; speed <= 2.0; speed += 0.2) {
2351 status = libinput_device_config_accel_set_speed(device, speed);
2352 if (speed >= -1.0 && speed <= 1.0)
2353 litest_assert_enum_eq(status,
2354 LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2355 else
2356 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2357 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2358 0.0);
2359 }
2360 }
2361 END_TEST
2362
2363 START_TEST(pointer_accel_defaults_absolute_relative)
2364 {
2365 struct litest_device *dev = litest_current_device();
2366 struct libinput_device *device = dev->libinput_device;
2367
2368 litest_assert(libinput_device_config_accel_is_available(device));
2369 litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
2370 0.0);
2371 litest_assert_double_eq(libinput_device_config_accel_get_speed(device), 0.0);
2372 }
2373 END_TEST
2374
2375 START_TEST(pointer_accel_direction_change)
2376 {
2377 struct litest_device *dev = litest_current_device();
2378 struct libinput *li = dev->libinput;
2379 struct libinput_event *event;
2380 struct libinput_event_pointer *pev;
2381 int i;
2382 double delta;
2383
2384 litest_drain_events(li);
2385
2386 for (i = 0; i < 10; i++) {
2387 litest_event(dev, EV_REL, REL_X, -1);
2388 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2389 }
2390 litest_event(dev, EV_REL, REL_X, 1);
2391 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2392 litest_dispatch(li);
2393
2394 event = libinput_get_event(li);
2395 do {
2396 pev = libinput_event_get_pointer_event(event);
2397
2398 delta = libinput_event_pointer_get_dx(pev);
2399 litest_assert_double_le(delta, 0.0);
2400 libinput_event_destroy(event);
2401 event = libinput_get_event(li);
2402 } while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE);
2403
2404 pev = libinput_event_get_pointer_event(event);
2405 delta = libinput_event_pointer_get_dx(pev);
2406 litest_assert_double_gt(delta, 0.0);
2407 libinput_event_destroy(event);
2408 }
2409 END_TEST
2410
2411 START_TEST(pointer_accel_profile_defaults)
2412 {
2413 struct litest_device *dev = litest_current_device();
2414 struct libinput_device *device = dev->libinput_device;
2415 enum libinput_config_status status;
2416 enum libinput_config_accel_profile profile;
2417 uint32_t profiles;
2418
2419 litest_assert(libinput_device_config_accel_is_available(device));
2420
2421 profile = libinput_device_config_accel_get_default_profile(device);
2422 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2423
2424 profile = libinput_device_config_accel_get_profile(device);
2425 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2426
2427 profiles = libinput_device_config_accel_get_profiles(device);
2428 litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2429 litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2430 litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2431
2432 status = libinput_device_config_accel_set_profile(
2433 device,
2434 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2435 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2436 profile = libinput_device_config_accel_get_profile(device);
2437 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2438
2439 profile = libinput_device_config_accel_get_default_profile(device);
2440 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2441
2442 status = libinput_device_config_accel_set_profile(
2443 device,
2444 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2445 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2446 profile = libinput_device_config_accel_get_profile(device);
2447 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2448
2449 status = libinput_device_config_accel_set_profile(
2450 device,
2451 LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2452 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2453 profile = libinput_device_config_accel_get_profile(device);
2454 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2455 }
2456 END_TEST
2457
2458 START_TEST(pointer_accel_config_reset_to_defaults)
2459 {
2460 struct litest_device *dev = litest_current_device();
2461 struct libinput_device *device = dev->libinput_device;
2462 double default_speed = libinput_device_config_accel_get_default_speed(device);
2463
2464 /* There are no settings for these profiles to toggle, so we expect it
2465 * to simply reset to defaults */
2466 enum libinput_config_accel_profile profiles[] = {
2467 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
2468 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
2469 };
2470
2471 ARRAY_FOR_EACH(profiles, profile) {
2472 litest_assert_enum_eq(
2473 libinput_device_config_accel_set_speed(device, 1.0),
2474 LIBINPUT_CONFIG_STATUS_SUCCESS);
2475
2476 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2477 1.0);
2478
2479 struct libinput_config_accel *config = libinput_config_accel_create(
2480 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
2481 litest_assert_enum_eq(
2482 libinput_device_config_accel_apply(device, config),
2483 LIBINPUT_CONFIG_STATUS_SUCCESS);
2484 litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
2485 default_speed);
2486 libinput_config_accel_destroy(config);
2487 }
2488 }
2489 END_TEST
2490
2491 START_TEST(pointer_accel_config)
2492 {
2493 struct litest_device *dev = litest_current_device();
2494 struct libinput_device *device = dev->libinput_device;
2495 enum libinput_config_status status;
2496 enum libinput_config_accel_profile profile;
2497 enum libinput_config_status valid = LIBINPUT_CONFIG_STATUS_SUCCESS,
2498 invalid = LIBINPUT_CONFIG_STATUS_INVALID;
2499 enum libinput_config_accel_type accel_types[] = {
2500 LIBINPUT_ACCEL_TYPE_FALLBACK,
2501 LIBINPUT_ACCEL_TYPE_MOTION,
2502 LIBINPUT_ACCEL_TYPE_SCROLL,
2503 };
2504 struct custom_config_test {
2505 double step;
2506 double points[4];
2507 enum libinput_config_status expected_status;
2508 } tests[] = {
2509 { 0.5, { 1.0, 2.0, 2.5, 2.6 }, valid },
2510 { 0.003, { 0.1, 0.3, 0.4, 0.45 }, valid },
2511 { 2.7, { 1.0, 3.0, 4.5, 4.5 }, valid },
2512 { 0, { 1.0, 2.0, 2.5, 2.6 }, invalid },
2513 { -1, { 1.0, 2.0, 2.5, 2.6 }, invalid },
2514 { 1e10, { 1.0, 2.0, 2.5, 2.6 }, invalid },
2515 { 1, { 1.0, 2.0, -2.5, 2.6 }, invalid },
2516 { 1, { 1.0, 2.0, 1e10, 2.6 }, invalid },
2517 };
2518
2519 litest_assert(libinput_device_config_accel_is_available(device));
2520
2521 struct libinput_config_accel *config_custom_default =
2522 libinput_config_accel_create(LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2523 struct libinput_config_accel *config_custom_changed =
2524 libinput_config_accel_create(LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2525
2526 litest_assert_ptr_notnull(config_custom_default);
2527 litest_assert_ptr_notnull(config_custom_changed);
2528
2529 ARRAY_FOR_EACH(tests, t) {
2530 ARRAY_FOR_EACH(accel_types, accel_type) {
2531 status = libinput_config_accel_set_points(
2532 config_custom_changed,
2533 *accel_type,
2534 t->step,
2535 ARRAY_LENGTH(t->points),
2536 t->points);
2537 litest_assert_int_eq(status, t->expected_status);
2538
2539 status = libinput_device_config_accel_apply(
2540 device,
2541 config_custom_changed);
2542 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2543 profile = libinput_device_config_accel_get_profile(device);
2544 litest_assert_enum_eq(profile,
2545 LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2546
2547 status = libinput_device_config_accel_apply(
2548 device,
2549 config_custom_default);
2550 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2551 profile = libinput_device_config_accel_get_profile(device);
2552 litest_assert_enum_eq(profile,
2553 LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
2554 }
2555 }
2556
2557 libinput_config_accel_destroy(config_custom_default);
2558 libinput_config_accel_destroy(config_custom_changed);
2559 }
2560 END_TEST
2561
2562 START_TEST(pointer_accel_profile_invalid)
2563 {
2564 struct litest_device *dev = litest_current_device();
2565 struct libinput_device *device = dev->libinput_device;
2566 enum libinput_config_status status;
2567
2568 litest_assert(libinput_device_config_accel_is_available(device));
2569
2570 status = libinput_device_config_accel_set_profile(
2571 device,
2572 LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
2573 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2574
2575 status = libinput_device_config_accel_set_profile(
2576 device,
2577 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
2578 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2579
2580 status = libinput_device_config_accel_set_profile(
2581 device,
2582 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |
2583 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2584 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2585
2586 status = libinput_device_config_accel_set_profile(
2587 device,
2588 LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM |
2589 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2590 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2591 }
2592 END_TEST
2593
2594 START_TEST(pointer_accel_profile_noaccel)
2595 {
2596 struct litest_device *dev = litest_current_device();
2597 struct libinput_device *device = dev->libinput_device;
2598 enum libinput_config_status status;
2599 enum libinput_config_accel_profile profile;
2600
2601 litest_assert(!libinput_device_config_accel_is_available(device));
2602
2603 profile = libinput_device_config_accel_get_default_profile(device);
2604 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
2605
2606 profile = libinput_device_config_accel_get_profile(device);
2607 litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
2608
2609 status = libinput_device_config_accel_set_profile(
2610 device,
2611 LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
2612 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2613
2614 status = libinput_device_config_accel_set_profile(
2615 device,
2616 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
2617 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2618
2619 status = libinput_device_config_accel_set_profile(
2620 device,
2621 LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |
2622 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2623 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2624 }
2625 END_TEST
2626
2627 START_TEST(pointer_accel_profile_flat_motion_relative)
2628 {
2629 struct litest_device *dev = litest_current_device();
2630 struct libinput_device *device = dev->libinput_device;
2631
2632 libinput_device_config_accel_set_profile(device,
2633 LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
2634 litest_drain_events(dev->libinput);
2635
2636 test_relative_event(dev, 1, 0);
2637 test_relative_event(dev, 1, 1);
2638 test_relative_event(dev, 1, -1);
2639 test_relative_event(dev, 0, 1);
2640
2641 test_relative_event(dev, -1, 0);
2642 test_relative_event(dev, -1, 1);
2643 test_relative_event(dev, -1, -1);
2644 test_relative_event(dev, 0, -1);
2645 }
2646 END_TEST
2647
2648 START_TEST(middlebutton)
2649 {
2650 struct litest_device *device = litest_current_device();
2651 struct libinput *li = device->libinput;
2652 enum libinput_config_status status;
2653 unsigned int i;
2654 const int btn[][4] = {
2655 { BTN_LEFT, BTN_RIGHT, BTN_LEFT, BTN_RIGHT },
2656 { BTN_LEFT, BTN_RIGHT, BTN_RIGHT, BTN_LEFT },
2657 { BTN_RIGHT, BTN_LEFT, BTN_LEFT, BTN_RIGHT },
2658 { BTN_RIGHT, BTN_LEFT, BTN_RIGHT, BTN_LEFT },
2659 };
2660
2661 disable_button_scrolling(device);
2662
2663 status = libinput_device_config_middle_emulation_set_enabled(
2664 device->libinput_device,
2665 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2666 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2667 return LITEST_NOT_APPLICABLE;
2668
2669 litest_drain_events(li);
2670
2671 for (i = 0; i < ARRAY_LENGTH(btn); i++) {
2672 litest_button_click_debounced(device, li, btn[i][0], true);
2673 litest_button_click_debounced(device, li, btn[i][1], true);
2674
2675 litest_assert_button_event(li,
2676 BTN_MIDDLE,
2677 LIBINPUT_BUTTON_STATE_PRESSED);
2678 litest_assert_empty_queue(li);
2679
2680 litest_button_click_debounced(device, li, btn[i][2], false);
2681 litest_button_click_debounced(device, li, btn[i][3], false);
2682 litest_assert_button_event(li,
2683 BTN_MIDDLE,
2684 LIBINPUT_BUTTON_STATE_RELEASED);
2685 litest_assert_empty_queue(li);
2686 }
2687 }
2688 END_TEST
2689
2690 START_TEST(middlebutton_nostart_while_down)
2691 {
2692 struct litest_device *device = litest_current_device();
2693 struct libinput *li = device->libinput;
2694 enum libinput_config_status status;
2695 unsigned int i;
2696 const int btn[][4] = {
2697 { BTN_LEFT, BTN_RIGHT, BTN_LEFT, BTN_RIGHT },
2698 { BTN_LEFT, BTN_RIGHT, BTN_RIGHT, BTN_LEFT },
2699 { BTN_RIGHT, BTN_LEFT, BTN_LEFT, BTN_RIGHT },
2700 { BTN_RIGHT, BTN_LEFT, BTN_RIGHT, BTN_LEFT },
2701 };
2702
2703 if (!libinput_device_pointer_has_button(device->libinput_device, BTN_MIDDLE))
2704 return LITEST_NOT_APPLICABLE;
2705
2706 disable_button_scrolling(device);
2707
2708 status = libinput_device_config_middle_emulation_set_enabled(
2709 device->libinput_device,
2710 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2711 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2712 return LITEST_NOT_APPLICABLE;
2713
2714 litest_button_click_debounced(device, li, BTN_MIDDLE, true);
2715 litest_drain_events(li);
2716
2717 for (i = 0; i < ARRAY_LENGTH(btn); i++) {
2718 litest_button_click_debounced(device, li, btn[i][0], true);
2719 litest_assert_button_event(li,
2720 btn[i][0],
2721 LIBINPUT_BUTTON_STATE_PRESSED);
2722 litest_button_click_debounced(device, li, btn[i][1], true);
2723 litest_assert_button_event(li,
2724 btn[i][1],
2725 LIBINPUT_BUTTON_STATE_PRESSED);
2726
2727 litest_assert_empty_queue(li);
2728
2729 litest_button_click_debounced(device, li, btn[i][2], false);
2730 litest_assert_button_event(li,
2731 btn[i][2],
2732 LIBINPUT_BUTTON_STATE_RELEASED);
2733 litest_button_click_debounced(device, li, btn[i][3], false);
2734 litest_assert_button_event(li,
2735 btn[i][3],
2736 LIBINPUT_BUTTON_STATE_RELEASED);
2737 litest_assert_empty_queue(li);
2738 }
2739
2740 litest_button_click_debounced(device, li, BTN_MIDDLE, false);
2741 litest_drain_events(li);
2742 }
2743 END_TEST
2744
2745 START_TEST(middlebutton_timeout)
2746 {
2747 struct litest_device *device = litest_current_device();
2748 struct libinput *li = device->libinput;
2749 enum libinput_config_status status;
2750 unsigned int button;
2751
2752 disable_button_scrolling(device);
2753
2754 status = libinput_device_config_middle_emulation_set_enabled(
2755 device->libinput_device,
2756 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2757 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2758 return LITEST_NOT_APPLICABLE;
2759
2760 for (button = BTN_LEFT; button <= BTN_RIGHT; button++) {
2761 litest_drain_events(li);
2762 litest_button_click_debounced(device, li, button, true);
2763 litest_assert_empty_queue(li);
2764 litest_timeout_middlebutton(li);
2765
2766 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2767
2768 litest_button_click_debounced(device, li, button, false);
2769 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2770 litest_assert_empty_queue(li);
2771 }
2772 }
2773 END_TEST
2774
2775 START_TEST(middlebutton_doubleclick)
2776 {
2777 struct litest_device *device = litest_current_device();
2778 struct libinput *li = device->libinput;
2779 enum libinput_config_status status;
2780 unsigned int i;
2781 const int btn[][4] = {
2782 { BTN_LEFT, BTN_RIGHT, BTN_LEFT, BTN_RIGHT },
2783 { BTN_LEFT, BTN_RIGHT, BTN_RIGHT, BTN_LEFT },
2784 { BTN_RIGHT, BTN_LEFT, BTN_LEFT, BTN_RIGHT },
2785 { BTN_RIGHT, BTN_LEFT, BTN_RIGHT, BTN_LEFT },
2786 };
2787
2788 disable_button_scrolling(device);
2789
2790 status = libinput_device_config_middle_emulation_set_enabled(
2791 device->libinput_device,
2792 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2793 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2794 return LITEST_NOT_APPLICABLE;
2795
2796 litest_drain_events(li);
2797
2798 for (i = 0; i < ARRAY_LENGTH(btn); i++) {
2799 litest_button_click_debounced(device, li, btn[i][0], true);
2800 litest_button_click_debounced(device, li, btn[i][1], true);
2801 litest_assert_button_event(li,
2802 BTN_MIDDLE,
2803 LIBINPUT_BUTTON_STATE_PRESSED);
2804 litest_assert_empty_queue(li);
2805
2806 litest_button_click_debounced(device, li, btn[i][2], false);
2807 litest_button_click_debounced(device, li, btn[i][2], true);
2808 litest_assert_button_event(li,
2809 BTN_MIDDLE,
2810 LIBINPUT_BUTTON_STATE_RELEASED);
2811 litest_assert_button_event(li,
2812 BTN_MIDDLE,
2813 LIBINPUT_BUTTON_STATE_PRESSED);
2814 litest_button_click_debounced(device, li, btn[i][3], false);
2815
2816 litest_assert_button_event(li,
2817 BTN_MIDDLE,
2818 LIBINPUT_BUTTON_STATE_RELEASED);
2819 litest_assert_empty_queue(li);
2820 }
2821 }
2822 END_TEST
2823
2824 START_TEST(middlebutton_middleclick)
2825 {
2826 struct litest_device *device = litest_current_device();
2827 struct libinput *li = device->libinput;
2828 enum libinput_config_status status;
2829 unsigned int button;
2830
2831 disable_button_scrolling(device);
2832
2833 if (!libinput_device_pointer_has_button(device->libinput_device, BTN_MIDDLE))
2834 return LITEST_NOT_APPLICABLE;
2835
2836 status = libinput_device_config_middle_emulation_set_enabled(
2837 device->libinput_device,
2838 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2839 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2840 return LITEST_NOT_APPLICABLE;
2841
2842 /* one button down, then middle -> release buttons */
2843 for (button = BTN_LEFT; button <= BTN_RIGHT; button++) {
2844 /* release button before middle */
2845 litest_drain_events(li);
2846 litest_button_click_debounced(device, li, button, true);
2847 litest_button_click_debounced(device, li, BTN_MIDDLE, true);
2848 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2849 litest_assert_button_event(li,
2850 BTN_MIDDLE,
2851 LIBINPUT_BUTTON_STATE_PRESSED);
2852 litest_assert_empty_queue(li);
2853 litest_button_click_debounced(device, li, button, false);
2854 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2855 litest_button_click_debounced(device, li, BTN_MIDDLE, false);
2856 litest_assert_button_event(li,
2857 BTN_MIDDLE,
2858 LIBINPUT_BUTTON_STATE_RELEASED);
2859 litest_assert_empty_queue(li);
2860
2861 /* release middle before button */
2862 litest_button_click_debounced(device, li, button, true);
2863 litest_button_click_debounced(device, li, BTN_MIDDLE, true);
2864 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2865 litest_assert_button_event(li,
2866 BTN_MIDDLE,
2867 LIBINPUT_BUTTON_STATE_PRESSED);
2868 litest_assert_empty_queue(li);
2869 litest_button_click_debounced(device, li, BTN_MIDDLE, false);
2870 litest_assert_button_event(li,
2871 BTN_MIDDLE,
2872 LIBINPUT_BUTTON_STATE_RELEASED);
2873 litest_button_click_debounced(device, li, button, false);
2874 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2875 litest_assert_empty_queue(li);
2876 }
2877 }
2878 END_TEST
2879
2880 START_TEST(middlebutton_middleclick_during)
2881 {
2882 struct litest_device *device = litest_current_device();
2883 struct libinput *li = device->libinput;
2884 enum libinput_config_status status;
2885 unsigned int button;
2886
2887 disable_button_scrolling(device);
2888
2889 if (!libinput_device_pointer_has_button(device->libinput_device, BTN_MIDDLE))
2890 return LITEST_NOT_APPLICABLE;
2891
2892 status = libinput_device_config_middle_emulation_set_enabled(
2893 device->libinput_device,
2894 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2895 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
2896 return LITEST_NOT_APPLICABLE;
2897
2898 litest_drain_events(li);
2899
2900 /* trigger emulation, then real middle */
2901 for (button = BTN_LEFT; button <= BTN_RIGHT; button++) {
2902 litest_button_click_debounced(device, li, BTN_LEFT, true);
2903 litest_button_click_debounced(device, li, BTN_RIGHT, true);
2904
2905 litest_assert_button_event(li,
2906 BTN_MIDDLE,
2907 LIBINPUT_BUTTON_STATE_PRESSED);
2908
2909 litest_button_click_debounced(device, li, BTN_MIDDLE, true);
2910 litest_assert_button_event(li,
2911 BTN_MIDDLE,
2912 LIBINPUT_BUTTON_STATE_RELEASED);
2913 litest_assert_button_event(li,
2914 BTN_MIDDLE,
2915 LIBINPUT_BUTTON_STATE_PRESSED);
2916
2917 litest_assert_empty_queue(li);
2918
2919 /* middle still down, release left/right */
2920 litest_button_click_debounced(device, li, button, false);
2921 litest_assert_empty_queue(li);
2922 litest_button_click_debounced(device, li, button, true);
2923 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2924 litest_assert_empty_queue(li);
2925
2926 /* release both */
2927 litest_button_click_debounced(device, li, BTN_LEFT, false);
2928 litest_button_click_debounced(device, li, BTN_RIGHT, false);
2929 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2930 litest_assert_empty_queue(li);
2931
2932 litest_button_click_debounced(device, li, BTN_MIDDLE, false);
2933 litest_assert_button_event(li,
2934 BTN_MIDDLE,
2935 LIBINPUT_BUTTON_STATE_RELEASED);
2936 litest_assert_empty_queue(li);
2937 }
2938 }
2939 END_TEST
2940
2941 START_TEST(middlebutton_default_enabled)
2942 {
2943 struct litest_device *dev = litest_current_device();
2944 struct libinput_device *device = dev->libinput_device;
2945 enum libinput_config_status status;
2946 int available;
2947 enum libinput_config_middle_emulation_state state;
2948
2949 if (!libinput_device_pointer_has_button(dev->libinput_device, BTN_MIDDLE))
2950 return LITEST_NOT_APPLICABLE;
2951
2952 available = libinput_device_config_middle_emulation_is_available(device);
2953 litest_assert(available);
2954
2955 state = libinput_device_config_middle_emulation_get_enabled(device);
2956 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
2957
2958 state = libinput_device_config_middle_emulation_get_default_enabled(device);
2959 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
2960
2961 status = libinput_device_config_middle_emulation_set_enabled(
2962 device,
2963 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2964 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2965
2966 status = libinput_device_config_middle_emulation_set_enabled(
2967 device,
2968 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
2969 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2970
2971 status = libinput_device_config_middle_emulation_set_enabled(device, 3);
2972 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2973 }
2974 END_TEST
2975
2976 START_TEST(middlebutton_default_clickpad)
2977 {
2978 struct litest_device *dev = litest_current_device();
2979 struct libinput_device *device = dev->libinput_device;
2980 enum libinput_config_status status;
2981 enum libinput_config_middle_emulation_state state;
2982 int available;
2983
2984 available = libinput_device_config_middle_emulation_is_available(device);
2985 litest_assert(available);
2986
2987 state = libinput_device_config_middle_emulation_get_enabled(device);
2988 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
2989 state = libinput_device_config_middle_emulation_get_default_enabled(device);
2990 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
2991
2992 status = libinput_device_config_middle_emulation_set_enabled(
2993 device,
2994 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
2995 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2996
2997 status = libinput_device_config_middle_emulation_set_enabled(
2998 device,
2999 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3000 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
3001
3002 status = libinput_device_config_middle_emulation_set_enabled(device, 3);
3003 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
3004 }
3005 END_TEST
3006
3007 START_TEST(middlebutton_default_touchpad)
3008 {
3009 struct litest_device *dev = litest_current_device();
3010 struct libinput_device *device = dev->libinput_device;
3011 enum libinput_config_middle_emulation_state state;
3012 int available;
3013 const char *name = libinput_device_get_name(dev->libinput_device);
3014
3015 if (streq(name, "litest AlpsPS/2 ALPS GlidePoint") ||
3016 streq(name, "litest AlpsPS/2 ALPS DualPoint TouchPad"))
3017 return LITEST_NOT_APPLICABLE;
3018
3019 available = libinput_device_config_middle_emulation_is_available(device);
3020 litest_assert(!available);
3021
3022 if (libinput_device_pointer_has_button(device, BTN_MIDDLE))
3023 return LITEST_NOT_APPLICABLE;
3024
3025 state = libinput_device_config_middle_emulation_get_enabled(device);
3026 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3027 state = libinput_device_config_middle_emulation_get_default_enabled(device);
3028 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3029 }
3030 END_TEST
3031
3032 START_TEST(middlebutton_default_alps)
3033 {
3034 struct litest_device *dev = litest_current_device();
3035 struct libinput_device *device = dev->libinput_device;
3036 enum libinput_config_middle_emulation_state state;
3037 int available;
3038
3039 available = libinput_device_config_middle_emulation_is_available(device);
3040 litest_assert(available);
3041
3042 state = libinput_device_config_middle_emulation_get_enabled(device);
3043 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3044 state = libinput_device_config_middle_emulation_get_default_enabled(device);
3045 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3046 }
3047 END_TEST
3048
3049 START_TEST(middlebutton_default_disabled)
3050 {
3051 struct litest_device *dev = litest_current_device();
3052 struct libinput_device *device = dev->libinput_device;
3053 enum libinput_config_middle_emulation_state state;
3054 enum libinput_config_status status;
3055 int available;
3056
3057 available = libinput_device_config_middle_emulation_is_available(device);
3058 litest_assert(!available);
3059 state = libinput_device_config_middle_emulation_get_enabled(device);
3060 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3061 state = libinput_device_config_middle_emulation_get_default_enabled(device);
3062 litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3063 status = libinput_device_config_middle_emulation_set_enabled(
3064 device,
3065 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
3066 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
3067 status = libinput_device_config_middle_emulation_set_enabled(
3068 device,
3069 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3070 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3071 }
3072 END_TEST
3073
3074 START_TEST(middlebutton_button_scrolling)
3075 {
3076 struct litest_device *dev = litest_current_device();
3077 struct libinput_device *device = dev->libinput_device;
3078 struct libinput *li = dev->libinput;
3079 enum libinput_config_status status;
3080 struct libinput_event *ev;
3081 struct libinput_event_pointer *pev;
3082 int i;
3083
3084 status = libinput_device_config_middle_emulation_set_enabled(
3085 device,
3086 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3087 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3088 return LITEST_NOT_APPLICABLE;
3089
3090 status = libinput_device_config_scroll_set_method(
3091 device,
3092 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
3093 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3094 return LITEST_NOT_APPLICABLE;
3095
3096 status = libinput_device_config_scroll_set_button(device, BTN_LEFT);
3097 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3098 return LITEST_NOT_APPLICABLE;
3099
3100 litest_drain_events(li);
3101
3102 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3103 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3104 litest_dispatch(li);
3105
3106 /* middle emulation discards */
3107 litest_assert_empty_queue(li);
3108
3109 litest_timeout_middlebutton(li);
3110
3111 /* scroll discards */
3112 litest_assert_empty_queue(li);
3113 litest_timeout_buttonscroll(li);
3114
3115 for (i = 0; i < 10; i++) {
3116 litest_event(dev, EV_REL, REL_Y, 1);
3117 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3118 litest_dispatch(li);
3119 }
3120
3121 ev = libinput_get_event(li);
3122 do {
3123 pev = litest_is_axis_event(ev,
3124 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
3125 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
3126 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
3127 litest_assert_double_gt(litest_event_pointer_get_value(
3128 pev,
3129 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL),
3130 0.0);
3131 libinput_event_destroy(ev);
3132 ev = libinput_get_event(li);
3133 } while (ev);
3134
3135 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3136 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3137 litest_dispatch(li);
3138
3139 litest_assert_axis_end_sequence(li,
3140 LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
3141 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
3142 LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
3143
3144 /* no button release */
3145 litest_assert_empty_queue(li);
3146 }
3147 END_TEST
3148
3149 START_TEST(middlebutton_button_scrolling_middle)
3150 {
3151 struct litest_device *dev = litest_current_device();
3152 struct libinput_device *device = dev->libinput_device;
3153 struct libinput *li = dev->libinput;
3154 enum libinput_config_status status;
3155
3156 status = libinput_device_config_middle_emulation_set_enabled(
3157 device,
3158 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3159 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3160 return LITEST_NOT_APPLICABLE;
3161
3162 status = libinput_device_config_scroll_set_method(
3163 device,
3164 LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
3165 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3166 return LITEST_NOT_APPLICABLE;
3167
3168 status = libinput_device_config_scroll_set_button(device, BTN_LEFT);
3169 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3170 return LITEST_NOT_APPLICABLE;
3171
3172 litest_drain_events(li);
3173
3174 /* button scrolling should not stop middle emulation */
3175
3176 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3177 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3178 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3179 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3180 litest_dispatch(li);
3181
3182 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
3183
3184 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3185 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3186 litest_event(dev, EV_KEY, BTN_RIGHT, 0);
3187 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3188 litest_dispatch(li);
3189
3190 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_RELEASED);
3191
3192 litest_assert_empty_queue(li);
3193 }
3194 END_TEST
3195
3196 START_TEST(middlebutton_device_remove_while_down)
3197 {
3198 struct litest_device *dev = litest_current_device();
3199 struct libinput_device *device = dev->libinput_device;
3200 struct libinput *li = dev->libinput;
3201 enum libinput_config_status status;
3202
3203 libinput_device_config_scroll_set_method(device,
3204 LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
3205 status = libinput_device_config_middle_emulation_set_enabled(
3206 device,
3207 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3208 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3209 return LITEST_NOT_APPLICABLE;
3210
3211 litest_drain_events(li);
3212
3213 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3214 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3215 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3216 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3217 litest_dispatch(li);
3218
3219 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
3220
3221 litest_assert_empty_queue(li);
3222 }
3223 END_TEST
3224
3225 START_TEST(middlebutton_device_remove_while_one_is_down)
3226 {
3227 struct litest_device *dev = litest_current_device();
3228 struct libinput_device *device = dev->libinput_device;
3229 struct libinput *li = dev->libinput;
3230 enum libinput_config_status status;
3231
3232 libinput_device_config_scroll_set_method(device,
3233 LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
3234 status = libinput_device_config_middle_emulation_set_enabled(
3235 device,
3236 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
3237 if (status == LIBINPUT_CONFIG_STATUS_UNSUPPORTED)
3238 return LITEST_NOT_APPLICABLE;
3239
3240 litest_drain_events(li);
3241
3242 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3243 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3244 litest_dispatch(li);
3245
3246 litest_assert_empty_queue(li);
3247 }
3248 END_TEST
3249
3250 START_TEST(pointer_time_usec)
3251 {
3252 struct litest_device *dev = litest_current_device();
3253 struct libinput *li = dev->libinput;
3254 struct libinput_event_pointer *ptrev;
3255 struct libinput_event *event;
3256 uint64_t time_usec;
3257
3258 litest_drain_events(dev->libinput);
3259
3260 litest_event(dev, EV_REL, REL_X, 1);
3261 litest_event(dev, EV_REL, REL_Y, 1);
3262 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3263
3264 litest_wait_for_event(li);
3265
3266 event = libinput_get_event(li);
3267 ptrev = litest_is_motion_event(event);
3268
3269 time_usec = libinput_event_pointer_get_time_usec(ptrev);
3270 litest_assert_int_eq(libinput_event_pointer_get_time(ptrev),
3271 (uint32_t)(time_usec / 1000));
3272
3273 libinput_event_destroy(event);
3274 litest_drain_events(dev->libinput);
3275 }
3276 END_TEST
3277
3278 START_TEST(debounce_bounce)
3279 {
3280 struct litest_device *dev = litest_current_device();
3281 struct libinput *li = dev->libinput;
3282 unsigned int button = litest_test_param_get_i32(test_env->params, "button");
3283
3284 if (!libinput_device_pointer_has_button(dev->libinput_device, button))
3285 return LITEST_NOT_APPLICABLE;
3286
3287 litest_disable_middleemu(dev);
3288 disable_button_scrolling(dev);
3289 litest_drain_events(li);
3290
3291 litest_event(dev, EV_KEY, button, 1);
3292 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3293 litest_event(dev, EV_KEY, button, 0);
3294 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3295 litest_event(dev, EV_KEY, button, 1);
3296 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3297 litest_timeout_debounce(li);
3298
3299 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3300 litest_assert_empty_queue(li);
3301
3302 litest_event(dev, EV_KEY, button, 0);
3303 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3304 litest_event(dev, EV_KEY, button, 1);
3305 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3306 litest_event(dev, EV_KEY, button, 0);
3307 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3308 litest_timeout_debounce(li);
3309
3310 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3311
3312 litest_assert_empty_queue(li);
3313 }
3314 END_TEST
3315
3316 START_TEST(debounce_bounce_high_delay)
3317 {
3318 struct litest_device *dev = litest_current_device();
3319 struct libinput *li = dev->libinput;
3320 unsigned int button = litest_test_param_get_i32(test_env->params, "button");
3321
3322 if (!libinput_device_pointer_has_button(dev->libinput_device, button))
3323 return LITEST_NOT_APPLICABLE;
3324
3325 litest_disable_middleemu(dev);
3326 disable_button_scrolling(dev);
3327 litest_drain_events(li);
3328
3329 /* Debouncing timeout is 25ms after a button down or up. Make sure we go
3330 * over 25ms for the total bouncing duration, but stay under 25ms for
3331 * each single event. */
3332 litest_event(dev, EV_KEY, button, 1);
3333 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3334 litest_dispatch(li);
3335 msleep(15);
3336 litest_event(dev, EV_KEY, button, 0);
3337 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3338 litest_dispatch(li);
3339 msleep(15);
3340 litest_event(dev, EV_KEY, button, 1);
3341 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3342 litest_timeout_debounce(li);
3343
3344 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3345 litest_assert_empty_queue(li);
3346
3347 litest_event(dev, EV_KEY, button, 0);
3348 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3349 litest_dispatch(li);
3350 msleep(15);
3351 litest_event(dev, EV_KEY, button, 1);
3352 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3353 litest_dispatch(li);
3354 msleep(15);
3355 litest_event(dev, EV_KEY, button, 0);
3356 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3357 litest_timeout_debounce(li);
3358
3359 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3360
3361 litest_assert_empty_queue(li);
3362 }
3363 END_TEST
3364
3365 START_TEST(debounce_bounce_check_immediate)
3366 {
3367 struct litest_device *dev = litest_current_device();
3368 struct libinput *li = dev->libinput;
3369
3370 litest_disable_middleemu(dev);
3371 disable_button_scrolling(dev);
3372 litest_drain_events(li);
3373
3374 /* Press must be sent without delay */
3375 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3376 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3377 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3378 litest_timeout_debounce(li);
3379 litest_assert_empty_queue(li);
3380
3381 /* held down & past timeout, we expect releases to be immediate */
3382
3383 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3384 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3385 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3386
3387 litest_timeout_debounce(li);
3388 litest_assert_empty_queue(li);
3389 }
3390 END_TEST
3391
3392 /* Triggers the event sequence that initializes the spurious
3393 * debouncing behavior */
3394 static inline void
3395 debounce_trigger_spurious(struct litest_device *dev, struct libinput *li)
3396 {
3397 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3398 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3399 litest_timeout_debounce(li);
3400
3401 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3402
3403 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3404 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3405 litest_dispatch(li);
3406 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3407 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3408
3409 litest_timeout_debounce(li);
3410
3411 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3412 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3413
3414 /* gets filtered now */
3415 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3416 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3417 litest_timeout_debounce(li);
3418 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3419 litest_assert_empty_queue(li);
3420 }
3421
3422 START_TEST(debounce_spurious)
3423 {
3424 struct litest_device *dev = litest_current_device();
3425 struct libinput *li = dev->libinput;
3426 unsigned int button = litest_test_param_get_i32(test_env->params, "button");
3427
3428 if (!libinput_device_pointer_has_button(dev->libinput_device, button))
3429 return LITEST_NOT_APPLICABLE;
3430
3431 litest_disable_middleemu(dev);
3432 disable_button_scrolling(dev);
3433 litest_drain_events(li);
3434
3435 debounce_trigger_spurious(dev, li);
3436
3437 for (int i = 0; i < 3; i++) {
3438 litest_event(dev, EV_KEY, button, 1);
3439 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3440 litest_timeout_debounce(li);
3441
3442 /* Not all devices can disable middle button emulation, time out on
3443 * middle button here to make sure the initial button press event
3444 * was flushed.
3445 */
3446 litest_timeout_middlebutton(li);
3447
3448 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3449
3450 /* bouncy bouncy bouncy */
3451 litest_event(dev, EV_KEY, button, 0);
3452 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3453 litest_event(dev, EV_KEY, button, 1);
3454 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3455 litest_assert_empty_queue(li);
3456
3457 litest_event(dev, EV_KEY, button, 0);
3458 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3459 litest_timeout_debounce(li);
3460 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3461
3462 litest_assert_empty_queue(li);
3463 }
3464 }
3465 END_TEST
3466
3467 START_TEST(debounce_spurious_multibounce)
3468 {
3469 struct litest_device *dev = litest_current_device();
3470 struct libinput *li = dev->libinput;
3471
3472 litest_disable_middleemu(dev);
3473 litest_drain_events(li);
3474
3475 debounce_trigger_spurious(dev, li);
3476 litest_drain_events(li);
3477
3478 /* Let's assume our button has ventricular fibrilation and sends a
3479 * lot of clicks. Debouncing is now enabled, ventricular
3480 * fibrillation should cause one button down for the first press and
3481 * one release for the last release.
3482 */
3483
3484 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3485 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3486 litest_timeout_debounce(li);
3487
3488 /* Not all devices can disable middle button emulation, time out on
3489 * middle button here to make sure the initial button press event
3490 * was flushed.
3491 */
3492 litest_timeout_middlebutton(li);
3493 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3494
3495 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3496 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3497 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3498 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3499 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3500 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3501 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3502 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3503 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3504 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3505 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3506 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3507 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3508 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3509
3510 litest_assert_empty_queue(li);
3511 litest_timeout_debounce(li);
3512
3513 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3514
3515 litest_assert_empty_queue(li);
3516 }
3517 END_TEST
3518
3519 START_TEST(debounce_spurious_trigger_high_delay)
3520 {
3521 struct litest_device *dev = litest_current_device();
3522 struct libinput *li = dev->libinput;
3523
3524 litest_disable_middleemu(dev);
3525 litest_drain_events(li);
3526
3527 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3528 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3529 litest_timeout_debounce(li);
3530
3531 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3532
3533 /* Spurious timeout is 12ms after a button down or up. Make sure we go
3534 * over 12ms for the total bouncing duration, but stay under 12ms for
3535 * each single event. */
3536 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3537 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3538 litest_dispatch(li);
3539 msleep(5);
3540 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3541 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3542 litest_dispatch(li);
3543 msleep(5);
3544 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3545 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3546 litest_dispatch(li);
3547 msleep(5);
3548 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3549 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3550 litest_dispatch(li);
3551
3552 litest_timeout_debounce(li);
3553
3554 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3555 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3556
3557 /* gets filtered now */
3558 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3559 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3560 litest_dispatch(li);
3561 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3562 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3563 litest_timeout_debounce(li);
3564 litest_assert_empty_queue(li);
3565
3566 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3567 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3568 litest_timeout_debounce(li);
3569 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3570 litest_assert_empty_queue(li);
3571 }
3572 END_TEST
3573
3574 START_TEST(debounce_spurious_dont_enable_on_otherbutton)
3575 {
3576 struct litest_device *dev = litest_current_device();
3577 struct libinput_device *device = dev->libinput_device;
3578 struct libinput *li = dev->libinput;
3579
3580 if (!libinput_device_config_middle_emulation_is_available(device))
3581 return LITEST_NOT_APPLICABLE;
3582
3583 litest_disable_middleemu(dev);
3584 disable_button_scrolling(dev);
3585 litest_drain_events(li);
3586
3587 /* Don't trigger spurious debouncing on otherbutton events */
3588 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3589 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3590 litest_timeout_debounce(li);
3591
3592 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3593 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3594 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3595 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3596 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3597 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3598 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3599 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3600 litest_event(dev, EV_KEY, BTN_RIGHT, 0);
3601 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3602
3603 litest_dispatch(li);
3604
3605 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3606 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3607
3608 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
3609 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3610 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3611 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
3612
3613 litest_assert_empty_queue(li);
3614
3615 /* Expect release to be immediate */
3616 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3617 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3618 litest_timeout_debounce(li);
3619
3620 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3621 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3622 litest_dispatch(li);
3623 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3624 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3625 }
3626 END_TEST
3627
3628 START_TEST(debounce_spurious_cancel_debounce_otherbutton)
3629 {
3630 struct litest_device *dev = litest_current_device();
3631 struct libinput_device *device = dev->libinput_device;
3632 struct libinput *li = dev->libinput;
3633
3634 if (!libinput_device_config_middle_emulation_is_available(device))
3635 return LITEST_NOT_APPLICABLE;
3636
3637 litest_disable_middleemu(dev);
3638 disable_button_scrolling(dev);
3639 litest_drain_events(li);
3640
3641 debounce_trigger_spurious(dev, li);
3642
3643 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3644 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3645 litest_timeout_debounce(li);
3646
3647 /* spurious debouncing is on but the release should get flushed by
3648 * the other button */
3649 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3650 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3651 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3652 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3653 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3654 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3655 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3656 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3657 litest_event(dev, EV_KEY, BTN_RIGHT, 0);
3658 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3659
3660 litest_dispatch(li);
3661
3662 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3663 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3664
3665 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
3666 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3667 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3668 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
3669
3670 litest_assert_empty_queue(li);
3671 }
3672 END_TEST
3673
3674 START_TEST(debounce_spurious_switch_to_otherbutton)
3675 {
3676 struct litest_device *dev = litest_current_device();
3677 struct libinput_device *device = dev->libinput_device;
3678 struct libinput *li = dev->libinput;
3679
3680 if (!libinput_device_config_middle_emulation_is_available(device))
3681 return LITEST_NOT_APPLICABLE;
3682
3683 litest_drain_events(li);
3684 debounce_trigger_spurious(dev, li);
3685
3686 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3687 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3688 litest_timeout_debounce(li);
3689
3690 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3691 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3692 /* release is now held back,
3693 * other button should flush the release */
3694 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3695 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3696 litest_event(dev, EV_KEY, BTN_RIGHT, 0);
3697 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3698
3699 /* bouncing right button triggers debounce */
3700 litest_event(dev, EV_KEY, BTN_RIGHT, 1);
3701 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3702 litest_event(dev, EV_KEY, BTN_RIGHT, 0);
3703 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3704
3705 litest_dispatch(li);
3706
3707 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3708 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3709
3710 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
3711 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
3712
3713 litest_assert_empty_queue(li);
3714 }
3715 END_TEST
3716
3717 START_TEST(debounce_remove_device_button_up)
3718 {
3719 struct litest_device *dev;
3720
3721 _litest_context_destroy_ struct libinput *li = litest_create_context();
3722
3723 dev = litest_add_device(li, LITEST_MOUSE);
3724 litest_drain_events(li);
3725
3726 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3727 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3728 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3729 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3730 litest_dispatch(li);
3731
3732 /* delete the device while the timer is still active */
3733 litest_device_destroy(dev);
3734
3735 litest_timeout_debounce(li);
3736 }
3737 END_TEST
3738
3739 START_TEST(debounce_remove_device_button_down)
3740 {
3741 struct litest_device *dev;
3742
3743 _litest_context_destroy_ struct libinput *li = litest_create_context();
3744
3745 dev = litest_add_device(li, LITEST_MOUSE);
3746 litest_drain_events(li);
3747
3748 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3749 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3750 litest_dispatch(li);
3751
3752 /* delete the device the timer is still active */
3753 litest_device_destroy(dev);
3754
3755 litest_timeout_debounce(li);
3756 }
3757 END_TEST
3758
3759 TEST_COLLECTION(pointer)
3760 {
3761 /* clang-format off */
3762 litest_add(pointer_motion_relative, LITEST_RELATIVE, LITEST_POINTINGSTICK);
3763 litest_add_for_device(pointer_motion_relative_zero, LITEST_MOUSE);
3764 litest_with_parameters(params,
3765 "direction", 'I', 8, litest_named_i32(N), litest_named_i32(NE),
3766 litest_named_i32(E), litest_named_i32(SE),
3767 litest_named_i32(S), litest_named_i32(SW),
3768 litest_named_i32(W), litest_named_i32(NW)) {
3769 litest_add_parametrized(pointer_motion_relative_min_decel, LITEST_RELATIVE, LITEST_POINTINGSTICK, params);
3770 }
3771 litest_add(pointer_motion_absolute, LITEST_ABSOLUTE, LITEST_ANY);
3772 litest_add(pointer_motion_unaccel, LITEST_RELATIVE, LITEST_ANY);
3773 litest_add(pointer_button, LITEST_BUTTON, LITEST_CLICKPAD);
3774 litest_add_no_device(pointer_button_auto_release);
3775 litest_add_no_device(pointer_seat_button_count);
3776 litest_add_for_device(pointer_button_has_no_button, LITEST_KEYBOARD);
3777 litest_add(pointer_recover_from_lost_button_count, LITEST_BUTTON, LITEST_CLICKPAD);
3778 litest_add(pointer_scroll_wheel, LITEST_WHEEL, LITEST_TABLET);
3779 litest_with_parameters(params, "axis", 'I', 2, litest_named_i32(REL_WHEEL_HI_RES, "vertical"),
3780 litest_named_i32(REL_HWHEEL_HI_RES, "horizontal")) {
3781 litest_add_parametrized(pointer_scroll_wheel_hires, LITEST_WHEEL, LITEST_TABLET, params);
3782 }
3783 litest_with_parameters(params, "axis", 'I', 2, litest_named_i32(LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL, "vertical"),
3784 litest_named_i32(LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL, "horizontal")) {
3785 litest_add_parametrized(pointer_scroll_wheel_hires_send_only_lores, LITEST_WHEEL, LITEST_TABLET, params);
3786 litest_add_parametrized_for_device(pointer_scroll_wheel_hires_disabled, LITEST_MOUSE_WHEEL_HIRES_DISABLED, params);
3787 }
3788 litest_with_parameters(params, "hires-delta", 'u', 3, 5, 15, 20) {
3789 litest_add_parametrized(pointer_scroll_wheel_inhibit_small_deltas, LITEST_WHEEL, LITEST_TABLET, params);
3790 litest_add_parametrized(pointer_scroll_wheel_inhibit_dir_change, LITEST_WHEEL, LITEST_TABLET, params);
3791 }
3792 litest_add(pointer_scroll_wheel_inhibit_small_deltas_reduce_delta, LITEST_WHEEL, LITEST_TABLET);
3793 litest_add_for_device(pointer_scroll_wheel_no_inhibit_small_deltas_when_virtual, LITEST_MOUSE_VIRTUAL);
3794 litest_add_for_device(pointer_scroll_wheel_lenovo_scrollpoint, LITEST_LENOVO_SCROLLPOINT);
3795 litest_add(pointer_scroll_button, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3796 litest_add(pointer_scroll_button_noscroll, LITEST_ABSOLUTE|LITEST_BUTTON, LITEST_RELATIVE);
3797 litest_add(pointer_scroll_button_noscroll, LITEST_ANY, LITEST_RELATIVE|LITEST_BUTTON);
3798 litest_add(pointer_scroll_button_no_event_before_timeout, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3799 litest_add(pointer_scroll_button_middle_emulation, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3800 litest_add_no_device(pointer_scroll_button_device_remove_while_down);
3801
3802 litest_add(pointer_scroll_button_lock, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3803 litest_add(pointer_scroll_button_lock_defaults, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3804 litest_add(pointer_scroll_button_lock_config, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3805 litest_add(pointer_scroll_button_lock_enable_while_down, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3806 litest_add(pointer_scroll_button_lock_enable_while_down_just_lock, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3807 litest_add(pointer_scroll_button_lock_otherbutton, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3808 litest_add(pointer_scroll_button_lock_enable_while_otherbutton_down, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3809 litest_with_parameters(params, "buttonorder", 'I', 6, litest_named_i32(LLRR),
3810 litest_named_i32(LRLR),
3811 litest_named_i32(LRRL),
3812 litest_named_i32(RRLL),
3813 litest_named_i32(RLRL),
3814 litest_named_i32(RLLR)) {
3815 litest_add_parametrized(pointer_scroll_button_lock_middlebutton, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY, params);
3816 }
3817 litest_add(pointer_scroll_button_lock_doubleclick_nomove, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3818
3819 litest_add(pointer_scroll_nowheel_defaults, LITEST_RELATIVE|LITEST_BUTTON, LITEST_WHEEL);
3820 litest_add_for_device(pointer_scroll_defaults_logitech_marble , LITEST_LOGITECH_TRACKBALL);
3821 litest_add(pointer_scroll_natural_defaults, LITEST_WHEEL, LITEST_TABLET);
3822 litest_add(pointer_scroll_natural_defaults_noscroll, LITEST_ANY, LITEST_WHEEL);
3823 litest_add(pointer_scroll_natural_enable_config, LITEST_WHEEL, LITEST_TABLET);
3824 litest_add(pointer_scroll_natural_wheel, LITEST_WHEEL, LITEST_TABLET);
3825 litest_add(pointer_scroll_has_axis_invalid, LITEST_WHEEL, LITEST_TABLET);
3826 litest_with_parameters(params, "angle", 'd', 18, 0.0, 20.0, 40.0, 60.0, 80.0, 100.0, 120.0, 140.0, 160.0,
3827 180.0, 200.0, 220.0, 240.0, 260.0, 280.0, 300.0, 320.0, 340.0) {
3828 litest_add_parametrized(pointer_scroll_with_rotation, LITEST_WHEEL, LITEST_TABLET, params);
3829 }
3830
3831 litest_add(pointer_no_calibration, LITEST_ANY, LITEST_TOUCH|LITEST_SINGLE_TOUCH|LITEST_ABSOLUTE|LITEST_PROTOCOL_A|LITEST_TABLET);
3832
3833 /* tests touchpads too */
3834 litest_add(pointer_left_handed_defaults, LITEST_BUTTON, LITEST_ANY);
3835 litest_add(pointer_left_handed, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3836 litest_add(pointer_left_handed_during_click, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3837 litest_add(pointer_left_handed_during_click_multiple_buttons, LITEST_RELATIVE|LITEST_BUTTON, LITEST_ANY);
3838 litest_add_no_device(pointer_left_handed_disable_with_button_down);
3839
3840 litest_add(pointer_accel_defaults, LITEST_RELATIVE, LITEST_ANY);
3841 litest_add(pointer_accel_invalid, LITEST_RELATIVE, LITEST_ANY);
3842 litest_add(pointer_accel_defaults_absolute, LITEST_ABSOLUTE, LITEST_RELATIVE);
3843 litest_add(pointer_accel_defaults_absolute_relative, LITEST_ABSOLUTE|LITEST_RELATIVE, LITEST_ANY);
3844 litest_add(pointer_accel_direction_change, LITEST_RELATIVE, LITEST_POINTINGSTICK);
3845 litest_add(pointer_accel_profile_defaults, LITEST_RELATIVE, LITEST_TOUCHPAD);
3846 litest_add(pointer_accel_profile_defaults, LITEST_TOUCHPAD, LITEST_ANY);
3847 litest_add(pointer_accel_config_reset_to_defaults, LITEST_RELATIVE, LITEST_ANY);
3848 litest_add(pointer_accel_config, LITEST_RELATIVE, LITEST_ANY);
3849 litest_add(pointer_accel_profile_invalid, LITEST_RELATIVE, LITEST_ANY);
3850 litest_add(pointer_accel_profile_noaccel, LITEST_ANY, LITEST_TOUCHPAD|LITEST_RELATIVE|LITEST_TABLET);
3851 litest_add(pointer_accel_profile_flat_motion_relative, LITEST_RELATIVE, LITEST_TOUCHPAD);
3852
3853 litest_add(middlebutton, LITEST_BUTTON, LITEST_CLICKPAD);
3854 litest_add(middlebutton_nostart_while_down, LITEST_BUTTON, LITEST_CLICKPAD);
3855 litest_add(middlebutton_timeout, LITEST_BUTTON, LITEST_CLICKPAD);
3856 litest_add(middlebutton_doubleclick, LITEST_BUTTON, LITEST_CLICKPAD);
3857 litest_add(middlebutton_middleclick, LITEST_BUTTON, LITEST_CLICKPAD);
3858 litest_add(middlebutton_middleclick_during, LITEST_BUTTON, LITEST_CLICKPAD);
3859 litest_add(middlebutton_default_enabled, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_POINTINGSTICK);
3860 litest_add(middlebutton_default_clickpad, LITEST_CLICKPAD, LITEST_ANY);
3861 litest_add(middlebutton_default_touchpad, LITEST_TOUCHPAD, LITEST_CLICKPAD);
3862 litest_add(middlebutton_default_disabled, LITEST_ANY, LITEST_BUTTON);
3863 litest_add_for_device(middlebutton_default_alps, LITEST_ALPS_SEMI_MT);
3864 litest_add(middlebutton_button_scrolling, LITEST_RELATIVE|LITEST_BUTTON, LITEST_CLICKPAD);
3865 litest_add(middlebutton_button_scrolling_middle, LITEST_RELATIVE|LITEST_BUTTON, LITEST_CLICKPAD);
3866 litest_add(middlebutton_device_remove_while_down, LITEST_BUTTON, LITEST_CLICKPAD);
3867 litest_add(middlebutton_device_remove_while_one_is_down, LITEST_BUTTON, LITEST_CLICKPAD);
3868
3869 litest_with_parameters(params, "axis", 'I', 2, litest_named_i32(ABS_X), litest_named_i32(ABS_Y)) {
3870 litest_add_parametrized(pointer_absolute_initial_state, LITEST_ABSOLUTE, LITEST_ANY, params);
3871 }
3872
3873 litest_add(pointer_time_usec, LITEST_RELATIVE, LITEST_ANY);
3874
3875 litest_with_parameters(params, "button", 'I', 8, litest_named_i32(BTN_LEFT),
3876 litest_named_i32(BTN_RIGHT),
3877 litest_named_i32(BTN_MIDDLE),
3878 litest_named_i32(BTN_SIDE),
3879 litest_named_i32(BTN_EXTRA),
3880 litest_named_i32(BTN_FORWARD),
3881 litest_named_i32(BTN_BACK),
3882 litest_named_i32(BTN_TASK)) {
3883 litest_add_parametrized(debounce_bounce, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE, params);
3884 litest_add_parametrized(debounce_spurious, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE, params);
3885 /* Timing-sensitive test, valgrind is too slow */
3886 if (!RUNNING_ON_VALGRIND)
3887 litest_add_parametrized(debounce_bounce_high_delay, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE, params);
3888 }
3889 litest_add(debounce_bounce_check_immediate, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3890 litest_add(debounce_spurious_multibounce, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3891 if (!RUNNING_ON_VALGRIND)
3892 litest_add(debounce_spurious_trigger_high_delay, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3893 litest_add(debounce_spurious_dont_enable_on_otherbutton, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3894 litest_add(debounce_spurious_cancel_debounce_otherbutton, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3895 litest_add(debounce_spurious_switch_to_otherbutton, LITEST_BUTTON, LITEST_TOUCHPAD|LITEST_NO_DEBOUNCE);
3896 litest_add_no_device(debounce_remove_device_button_down);
3897 litest_add_no_device(debounce_remove_device_button_up);
3898 /* clang-format off */
3899 }