Debian Codegraph @

test/test-touchpad-tap.c

raw
1 /*
2 * Copyright © 2014-2015 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 <unistd.h>
30
31 #include "libinput-util.h"
32 #include "litest.h"
33
34 START_TEST(touchpad_1fg_tap)
35 {
36 struct litest_device *dev = litest_current_device();
37 struct libinput *li = dev->libinput;
38
39 litest_enable_tap(dev->libinput_device);
40 litest_disable_hold_gestures(dev->libinput_device);
41 litest_drain_events(li);
42
43 litest_touch_down(dev, 0, 50, 50);
44 litest_touch_up(dev, 0);
45
46 litest_dispatch(li);
47
48 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
49 litest_timeout_tap(li);
50 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
51
52 litest_assert_empty_queue(li);
53 }
54 END_TEST
55
56 START_TEST(touchpad_doubletap)
57 {
58 struct litest_device *dev = litest_current_device();
59 struct libinput *li = dev->libinput;
60 struct libinput_event *event;
61 struct libinput_event_pointer *ptrev;
62 uint32_t oldtime, curtime;
63 int nfingers = litest_test_param_get_i32(test_env->params, "fingers_1st"),
64 nfingers2 = litest_test_param_get_i32(test_env->params, "fingers_2nd");
65 unsigned int button = 0, button2 = 0;
66
67 if (nfingers > litest_slot_count(dev))
68 return LITEST_NOT_APPLICABLE;
69 if (nfingers2 > litest_slot_count(dev))
70 return LITEST_NOT_APPLICABLE;
71
72 litest_enable_tap(dev->libinput_device);
73 litest_disable_hold_gestures(dev->libinput_device);
74
75 switch (nfingers) {
76 case 1:
77 button = BTN_LEFT;
78 break;
79 case 2:
80 button = BTN_RIGHT;
81 break;
82 case 3:
83 button = BTN_MIDDLE;
84 break;
85 default:
86 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
87 }
88 switch (nfingers2) {
89 case 1:
90 button2 = BTN_LEFT;
91 break;
92 case 2:
93 button2 = BTN_RIGHT;
94 break;
95 case 3:
96 button2 = BTN_MIDDLE;
97 break;
98 default:
99 litest_abort_msg("Unexpected number of fingers (%d)", nfingers2);
100 }
101
102 litest_drain_events(li);
103
104 /* one to three finger down, all fingers up, repeat with possibly
105 different number of fingers -> two button event pairs */
106 switch (nfingers) {
107 case 3:
108 litest_touch_down(dev, 2, 60, 30);
109 _fallthrough_;
110 case 2:
111 litest_touch_down(dev, 1, 50, 30);
112 _fallthrough_;
113 case 1:
114 litest_touch_down(dev, 0, 40, 30);
115 break;
116 }
117 msleep(10);
118 switch (nfingers) {
119 case 3:
120 litest_touch_up(dev, 2);
121 _fallthrough_;
122 case 2:
123 litest_touch_up(dev, 1);
124 _fallthrough_;
125 case 1:
126 litest_touch_up(dev, 0);
127 break;
128 }
129 msleep(10);
130
131 switch (nfingers2) {
132 case 3:
133 litest_touch_down(dev, 2, 60, 30);
134 _fallthrough_;
135 case 2:
136 litest_touch_down(dev, 1, 50, 30);
137 _fallthrough_;
138 case 1:
139 litest_touch_down(dev, 0, 40, 30);
140 break;
141 }
142 msleep(10);
143 switch (nfingers2) {
144 case 3:
145 litest_touch_up(dev, 2);
146 _fallthrough_;
147 case 2:
148 litest_touch_up(dev, 1);
149 _fallthrough_;
150 case 1:
151 litest_touch_up(dev, 0);
152 break;
153 }
154
155 litest_timeout_tap(li);
156
157 event = libinput_get_event(li);
158 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
159 oldtime = libinput_event_pointer_get_time(ptrev);
160 libinput_event_destroy(event);
161
162 event = libinput_get_event(li);
163 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_RELEASED);
164 curtime = libinput_event_pointer_get_time(ptrev);
165 libinput_event_destroy(event);
166 litest_assert_int_lt(oldtime, curtime);
167
168 event = libinput_get_event(li);
169 ptrev = litest_is_button_event(event, button2, LIBINPUT_BUTTON_STATE_PRESSED);
170 curtime = libinput_event_pointer_get_time(ptrev);
171 libinput_event_destroy(event);
172 litest_assert_int_lt(oldtime, curtime);
173 oldtime = curtime;
174
175 event = libinput_get_event(li);
176 ptrev = litest_is_button_event(event, button2, LIBINPUT_BUTTON_STATE_RELEASED);
177 curtime = libinput_event_pointer_get_time(ptrev);
178 libinput_event_destroy(event);
179 litest_assert_int_lt(oldtime, curtime);
180
181 litest_assert_empty_queue(li);
182 }
183 END_TEST
184
185 START_TEST(touchpad_multitap)
186 {
187 struct litest_device *dev = litest_current_device();
188 struct libinput *li = dev->libinput;
189 struct libinput_event *event;
190 struct libinput_event_pointer *ptrev;
191 uint32_t oldtime = 0, curtime;
192 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
193 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
194 unsigned int button = 0;
195
196 if (nfingers > litest_slot_count(dev))
197 return LITEST_NOT_APPLICABLE;
198
199 litest_enable_tap(dev->libinput_device);
200 litest_enable_drag_lock(dev->libinput_device);
201 litest_disable_hold_gestures(dev->libinput_device);
202
203 switch (nfingers) {
204 case 1:
205 button = BTN_LEFT;
206 break;
207 case 2:
208 button = BTN_RIGHT;
209 break;
210 case 3:
211 button = BTN_MIDDLE;
212 break;
213 default:
214 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
215 }
216
217 litest_drain_events(li);
218
219 for (ntaps = 0; ntaps <= range; ntaps++) {
220 switch (nfingers) {
221 case 3:
222 litest_touch_down(dev, 2, 60, 30);
223 _fallthrough_;
224 case 2:
225 litest_touch_down(dev, 1, 50, 30);
226 _fallthrough_;
227 case 1:
228 litest_touch_down(dev, 0, 40, 30);
229 break;
230 }
231 switch (nfingers) {
232 case 3:
233 litest_touch_up(dev, 2);
234 _fallthrough_;
235 case 2:
236 litest_touch_up(dev, 1);
237 _fallthrough_;
238 case 1:
239 litest_touch_up(dev, 0);
240 break;
241 }
242
243 litest_dispatch(li);
244 msleep(10);
245 }
246
247 litest_timeout_tapndrag(li);
248
249 for (ntaps = 0; ntaps <= range; ntaps++) {
250 event = libinput_get_event(li);
251 ptrev = litest_is_button_event(event,
252 button,
253 LIBINPUT_BUTTON_STATE_PRESSED);
254 curtime = libinput_event_pointer_get_time(ptrev);
255 libinput_event_destroy(event);
256 litest_assert_int_gt(curtime, oldtime);
257
258 event = libinput_get_event(li);
259 ptrev = litest_is_button_event(event,
260 button,
261 LIBINPUT_BUTTON_STATE_RELEASED);
262 curtime = libinput_event_pointer_get_time(ptrev);
263 libinput_event_destroy(event);
264 litest_assert_int_ge(curtime, oldtime);
265 oldtime = curtime;
266 }
267 litest_timeout_tapndrag(li);
268 litest_assert_empty_queue(li);
269 }
270 END_TEST
271
272 START_TEST(touchpad_multitap_n_drag_move)
273 {
274 struct litest_device *dev = litest_current_device();
275 struct libinput *li = dev->libinput;
276 struct libinput_event *event;
277 struct libinput_event_pointer *ptrev;
278 uint32_t oldtime = 0, curtime;
279 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
280 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
281 unsigned int button = 0;
282
283 if (nfingers > litest_slot_count(dev))
284 return LITEST_NOT_APPLICABLE;
285
286 litest_enable_tap(dev->libinput_device);
287 litest_enable_drag_lock(dev->libinput_device);
288 litest_disable_hold_gestures(dev->libinput_device);
289
290 switch (nfingers) {
291 case 1:
292 button = BTN_LEFT;
293 break;
294 case 2:
295 button = BTN_RIGHT;
296 break;
297 case 3:
298 button = BTN_MIDDLE;
299 break;
300 default:
301 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
302 }
303
304 litest_drain_events(li);
305
306 for (ntaps = 0; ntaps <= range; ntaps++) {
307 switch (nfingers) {
308 case 3:
309 litest_touch_down(dev, 2, 60, 30);
310 _fallthrough_;
311 case 2:
312 litest_touch_down(dev, 1, 50, 30);
313 _fallthrough_;
314 case 1:
315 litest_touch_down(dev, 0, 40, 30);
316 break;
317 }
318 switch (nfingers) {
319 case 3:
320 litest_touch_up(dev, 2);
321 _fallthrough_;
322 case 2:
323 litest_touch_up(dev, 1);
324 _fallthrough_;
325 case 1:
326 litest_touch_up(dev, 0);
327 break;
328 }
329 litest_dispatch(li);
330 msleep(10);
331 }
332
333 litest_dispatch(li);
334 litest_touch_down(dev, 0, 50, 50);
335 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
336 litest_dispatch(li);
337
338 for (ntaps = 0; ntaps < range; ntaps++) {
339 event = libinput_get_event(li);
340 ptrev = litest_is_button_event(event,
341 button,
342 LIBINPUT_BUTTON_STATE_PRESSED);
343 curtime = libinput_event_pointer_get_time(ptrev);
344 libinput_event_destroy(event);
345 litest_assert_int_gt(curtime, oldtime);
346
347 event = libinput_get_event(li);
348 ptrev = litest_is_button_event(event,
349 button,
350 LIBINPUT_BUTTON_STATE_RELEASED);
351 curtime = libinput_event_pointer_get_time(ptrev);
352 libinput_event_destroy(event);
353 litest_assert_int_ge(curtime, oldtime);
354 oldtime = curtime;
355 }
356
357 event = libinput_get_event(li);
358 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
359 curtime = libinput_event_pointer_get_time(ptrev);
360 libinput_event_destroy(event);
361 litest_assert_int_gt(curtime, oldtime);
362
363 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
364
365 litest_touch_up(dev, 0);
366 litest_timeout_tapndrag(li);
367 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
368
369 litest_assert_empty_queue(li);
370 }
371 END_TEST
372
373 START_TEST(touchpad_multitap_n_drag_2fg)
374 {
375 struct litest_device *dev = litest_current_device();
376 struct libinput *li = dev->libinput;
377 struct libinput_event *event;
378 struct libinput_event_pointer *ptrev;
379 uint32_t oldtime = 0, curtime;
380 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
381 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
382 unsigned int button = 0;
383
384 if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT))
385 return LITEST_NOT_APPLICABLE;
386
387 if (nfingers > litest_slot_count(dev))
388 return LITEST_NOT_APPLICABLE;
389
390 litest_enable_tap(dev->libinput_device);
391 litest_enable_drag_lock(dev->libinput_device);
392 litest_disable_hold_gestures(dev->libinput_device);
393
394 switch (nfingers) {
395 case 1:
396 button = BTN_LEFT;
397 break;
398 case 2:
399 button = BTN_RIGHT;
400 break;
401 case 3:
402 button = BTN_MIDDLE;
403 break;
404 default:
405 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
406 }
407
408 litest_drain_events(li);
409
410 for (ntaps = 0; ntaps <= range; ntaps++) {
411 switch (nfingers) {
412 case 3:
413 litest_touch_down(dev, 2, 60, 30);
414 _fallthrough_;
415 case 2:
416 litest_touch_down(dev, 1, 50, 30);
417 _fallthrough_;
418 case 1:
419 litest_touch_down(dev, 0, 40, 30);
420 break;
421 }
422 switch (nfingers) {
423 case 3:
424 litest_touch_up(dev, 2);
425 _fallthrough_;
426 case 2:
427 litest_touch_up(dev, 1);
428 _fallthrough_;
429 case 1:
430 litest_touch_up(dev, 0);
431 break;
432 }
433
434 litest_dispatch(li);
435 msleep(10);
436 }
437
438 litest_dispatch(li);
439 litest_touch_down(dev, 0, 50, 50);
440 litest_touch_move_to(dev, 0, 50, 50, 30, 50, 10);
441 litest_touch_down(dev, 1, 70, 50);
442 litest_dispatch(li);
443
444 for (ntaps = 0; ntaps < range; ntaps++) {
445 event = libinput_get_event(li);
446 ptrev = litest_is_button_event(event,
447 button,
448 LIBINPUT_BUTTON_STATE_PRESSED);
449 curtime = libinput_event_pointer_get_time(ptrev);
450 libinput_event_destroy(event);
451 litest_assert_int_gt(curtime, oldtime);
452
453 event = libinput_get_event(li);
454 ptrev = litest_is_button_event(event,
455 button,
456 LIBINPUT_BUTTON_STATE_RELEASED);
457 curtime = libinput_event_pointer_get_time(ptrev);
458 libinput_event_destroy(event);
459 litest_assert_int_ge(curtime, oldtime);
460 oldtime = curtime;
461 }
462
463 event = libinput_get_event(li);
464 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
465 curtime = libinput_event_pointer_get_time(ptrev);
466 libinput_event_destroy(event);
467 litest_assert_int_gt(curtime, oldtime);
468
469 litest_touch_move_to(dev, 1, 70, 50, 90, 50, 10);
470
471 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
472
473 litest_touch_up(dev, 1);
474 litest_touch_up(dev, 0);
475 litest_timeout_tapndrag(li);
476 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
477
478 litest_assert_empty_queue(li);
479 }
480 END_TEST
481
482 START_TEST(touchpad_multitap_n_drag_click)
483 {
484 struct litest_device *dev = litest_current_device();
485 struct libinput *li = dev->libinput;
486 struct libinput_event *event;
487 struct libinput_event_pointer *ptrev;
488 uint32_t oldtime = 0, curtime;
489 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
490 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
491 unsigned int button = 0;
492
493 if (nfingers > litest_slot_count(dev))
494 return LITEST_NOT_APPLICABLE;
495
496 litest_enable_tap(dev->libinput_device);
497 litest_enable_drag_lock(dev->libinput_device);
498 litest_disable_hold_gestures(dev->libinput_device);
499
500 switch (nfingers) {
501 case 1:
502 button = BTN_LEFT;
503 break;
504 case 2:
505 button = BTN_RIGHT;
506 break;
507 case 3:
508 button = BTN_MIDDLE;
509 break;
510 default:
511 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
512 }
513
514 litest_drain_events(li);
515
516 for (ntaps = 0; ntaps <= range; ntaps++) {
517 switch (nfingers) {
518 case 3:
519 litest_touch_down(dev, 2, 60, 30);
520 _fallthrough_;
521 case 2:
522 litest_touch_down(dev, 1, 50, 30);
523 _fallthrough_;
524 case 1:
525 litest_touch_down(dev, 0, 40, 30);
526 break;
527 }
528 switch (nfingers) {
529 case 3:
530 litest_touch_up(dev, 2);
531 _fallthrough_;
532 case 2:
533 litest_touch_up(dev, 1);
534 _fallthrough_;
535 case 1:
536 litest_touch_up(dev, 0);
537 break;
538 }
539
540 litest_dispatch(li);
541 msleep(10);
542 }
543
544 litest_touch_down(dev, 0, 50, 50);
545 litest_dispatch(li);
546 litest_button_click(dev, BTN_LEFT, true);
547 litest_button_click(dev, BTN_LEFT, false);
548 litest_dispatch(li);
549
550 for (ntaps = 0; ntaps <= range; ntaps++) {
551 event = libinput_get_event(li);
552 ptrev = litest_is_button_event(event,
553 button,
554 LIBINPUT_BUTTON_STATE_PRESSED);
555 curtime = libinput_event_pointer_get_time(ptrev);
556 libinput_event_destroy(event);
557 litest_assert_int_gt(curtime, oldtime);
558
559 event = libinput_get_event(li);
560 ptrev = litest_is_button_event(event,
561 button,
562 LIBINPUT_BUTTON_STATE_RELEASED);
563 curtime = libinput_event_pointer_get_time(ptrev);
564 libinput_event_destroy(event);
565 litest_assert_int_ge(curtime, oldtime);
566 oldtime = curtime;
567 }
568
569 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
570 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
571 litest_touch_up(dev, 0);
572 litest_timeout_tapndrag(li);
573
574 litest_assert_empty_queue(li);
575 }
576 END_TEST
577
578 START_TEST(touchpad_multitap_timeout)
579 {
580 struct litest_device *dev = litest_current_device();
581 struct libinput *li = dev->libinput;
582 struct libinput_event *event;
583 struct libinput_event_pointer *ptrev;
584 uint32_t ptime, rtime;
585 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
586 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
587 unsigned int button = 0;
588
589 if (nfingers > litest_slot_count(dev))
590 return LITEST_NOT_APPLICABLE;
591
592 litest_enable_tap(dev->libinput_device);
593 litest_enable_drag_lock(dev->libinput_device);
594 litest_disable_hold_gestures(dev->libinput_device);
595
596 switch (nfingers) {
597 case 1:
598 button = BTN_LEFT;
599 break;
600 case 2:
601 button = BTN_RIGHT;
602 break;
603 case 3:
604 button = BTN_MIDDLE;
605 break;
606 default:
607 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
608 }
609
610 litest_drain_events(li);
611
612 for (ntaps = 0; ntaps <= range; ntaps++) {
613 switch (nfingers) {
614 case 3:
615 litest_touch_down(dev, 2, 60, 30);
616 _fallthrough_;
617 case 2:
618 litest_touch_down(dev, 1, 50, 30);
619 _fallthrough_;
620 case 1:
621 litest_touch_down(dev, 0, 40, 30);
622 break;
623 }
624 msleep(10);
625 switch (nfingers) {
626 case 3:
627 litest_touch_up(dev, 2);
628 _fallthrough_;
629 case 2:
630 litest_touch_up(dev, 1);
631 _fallthrough_;
632 case 1:
633 litest_touch_up(dev, 0);
634 break;
635 }
636
637 litest_dispatch(li);
638 msleep(10);
639 }
640
641 litest_timeout_tapndrag(li);
642
643 for (ntaps = 0; ntaps <= range; ntaps++) {
644 event = libinput_get_event(li);
645 ptrev = litest_is_button_event(event,
646 button,
647 LIBINPUT_BUTTON_STATE_PRESSED);
648 ptime = libinput_event_pointer_get_time(ptrev);
649 libinput_event_destroy(event);
650
651 event = libinput_get_event(li);
652 ptrev = litest_is_button_event(event,
653 button,
654 LIBINPUT_BUTTON_STATE_RELEASED);
655 rtime = libinput_event_pointer_get_time(ptrev);
656 libinput_event_destroy(event);
657 litest_assert_int_lt(ptime, rtime);
658 }
659
660 litest_assert_empty_queue(li);
661 }
662 END_TEST
663
664 START_TEST(touchpad_multitap_n_drag_timeout)
665 {
666 struct litest_device *dev = litest_current_device();
667 struct libinput *li = dev->libinput;
668 struct libinput_event *event;
669 struct libinput_event_pointer *ptrev;
670 uint32_t oldtime = 0, curtime;
671 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
672 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
673 unsigned int button = 0;
674
675 if (nfingers > litest_slot_count(dev))
676 return LITEST_NOT_APPLICABLE;
677
678 litest_enable_tap(dev->libinput_device);
679 litest_enable_drag_lock(dev->libinput_device);
680 litest_disable_hold_gestures(dev->libinput_device);
681
682 switch (nfingers) {
683 case 1:
684 button = BTN_LEFT;
685 break;
686 case 2:
687 button = BTN_RIGHT;
688 break;
689 case 3:
690 button = BTN_MIDDLE;
691 break;
692 default:
693 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
694 }
695
696 litest_drain_events(li);
697
698 for (ntaps = 0; ntaps <= range; ntaps++) {
699 switch (nfingers) {
700 case 3:
701 litest_touch_down(dev, 2, 60, 30);
702 _fallthrough_;
703 case 2:
704 litest_touch_down(dev, 1, 50, 30);
705 _fallthrough_;
706 case 1:
707 litest_touch_down(dev, 0, 40, 30);
708 break;
709 }
710 msleep(10);
711 switch (nfingers) {
712 case 3:
713 litest_touch_up(dev, 2);
714 _fallthrough_;
715 case 2:
716 litest_touch_up(dev, 1);
717 _fallthrough_;
718 case 1:
719 litest_touch_up(dev, 0);
720 break;
721 }
722
723 litest_dispatch(li);
724 msleep(10);
725 }
726
727 litest_dispatch(li);
728 litest_touch_down(dev, 0, 50, 50);
729
730 litest_timeout_tap(li);
731
732 for (ntaps = 0; ntaps < range; ntaps++) {
733 event = libinput_get_event(li);
734 ptrev = litest_is_button_event(event,
735 button,
736 LIBINPUT_BUTTON_STATE_PRESSED);
737 curtime = libinput_event_pointer_get_time(ptrev);
738 libinput_event_destroy(event);
739 litest_assert_int_gt(curtime, oldtime);
740
741 event = libinput_get_event(li);
742 ptrev = litest_is_button_event(event,
743 button,
744 LIBINPUT_BUTTON_STATE_RELEASED);
745 curtime = libinput_event_pointer_get_time(ptrev);
746 libinput_event_destroy(event);
747 litest_assert_int_gt(curtime, oldtime);
748 oldtime = curtime;
749 }
750
751 event = libinput_get_event(li);
752 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
753 curtime = libinput_event_pointer_get_time(ptrev);
754 libinput_event_destroy(event);
755 litest_assert_int_gt(curtime, oldtime);
756
757 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
758
759 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
760
761 litest_touch_up(dev, 0);
762 litest_timeout_tapndrag(li);
763 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
764
765 litest_assert_empty_queue(li);
766 }
767 END_TEST
768
769 START_TEST(touchpad_multitap_n_drag_high_delay)
770 {
771 struct litest_device *dev = litest_current_device();
772 struct libinput *li = dev->libinput;
773 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
774 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
775 unsigned int button = 0;
776
777 if (nfingers > litest_slot_count(dev))
778 return LITEST_NOT_APPLICABLE;
779
780 litest_enable_tap(dev->libinput_device);
781 litest_enable_drag_lock(dev->libinput_device);
782 litest_disable_hold_gestures(dev->libinput_device);
783
784 switch (nfingers) {
785 case 1:
786 button = BTN_LEFT;
787 break;
788 case 2:
789 button = BTN_RIGHT;
790 break;
791 case 3:
792 button = BTN_MIDDLE;
793 break;
794 default:
795 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
796 }
797
798 litest_drain_events(li);
799
800 for (ntaps = 0; ntaps <= range; ntaps++) {
801 /* Tap timeout is 180ms after a touch or release. Make sure we
802 * go over 180ms for touch+release, but stay under 180ms for
803 * each single event. */
804 switch (nfingers) {
805 case 3:
806 litest_touch_down(dev, 2, 60, 30);
807 _fallthrough_;
808 case 2:
809 litest_touch_down(dev, 1, 50, 30);
810 _fallthrough_;
811 case 1:
812 litest_touch_down(dev, 0, 40, 30);
813 break;
814 }
815 litest_dispatch(li);
816 msleep(100);
817
818 switch (nfingers) {
819 case 3:
820 litest_touch_up(dev, 2);
821 _fallthrough_;
822 case 2:
823 litest_touch_up(dev, 1);
824 _fallthrough_;
825 case 1:
826 litest_touch_up(dev, 0);
827 break;
828 }
829 litest_dispatch(li);
830 msleep(100);
831 }
832
833 litest_dispatch(li);
834 litest_touch_down(dev, 0, 50, 50);
835 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
836 litest_dispatch(li);
837
838 for (ntaps = 0; ntaps < range; ntaps++) {
839 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
840 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
841 }
842
843 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
844 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
845
846 litest_touch_up(dev, 0);
847 litest_timeout_tapndrag(li);
848 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
849
850 litest_assert_empty_queue(li);
851 }
852 END_TEST
853
854 START_TEST(touchpad_multitap_n_drag_tap)
855 {
856 struct litest_device *dev = litest_current_device();
857 struct libinput *li = dev->libinput;
858 struct libinput_event *event;
859 struct libinput_event_pointer *ptrev;
860 uint32_t oldtime = 0, curtime;
861 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
862 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
863 unsigned int button = 0;
864
865 if (nfingers > litest_slot_count(dev))
866 return LITEST_NOT_APPLICABLE;
867
868 litest_enable_tap(dev->libinput_device);
869 litest_enable_drag_lock(dev->libinput_device);
870 litest_disable_hold_gestures(dev->libinput_device);
871
872 switch (nfingers) {
873 case 1:
874 button = BTN_LEFT;
875 break;
876 case 2:
877 button = BTN_RIGHT;
878 break;
879 case 3:
880 button = BTN_MIDDLE;
881 break;
882 default:
883 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
884 }
885
886 litest_drain_events(li);
887
888 for (ntaps = 0; ntaps <= range; ntaps++) {
889 switch (nfingers) {
890 case 3:
891 litest_touch_down(dev, 2, 60, 30);
892 _fallthrough_;
893 case 2:
894 litest_touch_down(dev, 1, 50, 30);
895 _fallthrough_;
896 case 1:
897 litest_touch_down(dev, 0, 40, 30);
898 break;
899 }
900 msleep(10);
901 switch (nfingers) {
902 case 3:
903 litest_touch_up(dev, 2);
904 _fallthrough_;
905 case 2:
906 litest_touch_up(dev, 1);
907 _fallthrough_;
908 case 1:
909 litest_touch_up(dev, 0);
910 break;
911 }
912
913 litest_dispatch(li);
914 msleep(10);
915 }
916
917 litest_dispatch(li);
918 litest_touch_down(dev, 0, 50, 50);
919 litest_timeout_tap(li);
920
921 for (ntaps = 0; ntaps < range; ntaps++) {
922 event = libinput_get_event(li);
923 ptrev = litest_is_button_event(event,
924 button,
925 LIBINPUT_BUTTON_STATE_PRESSED);
926 curtime = libinput_event_pointer_get_time(ptrev);
927 libinput_event_destroy(event);
928 litest_assert_int_gt(curtime, oldtime);
929
930 event = libinput_get_event(li);
931 ptrev = litest_is_button_event(event,
932 button,
933 LIBINPUT_BUTTON_STATE_RELEASED);
934 curtime = libinput_event_pointer_get_time(ptrev);
935 libinput_event_destroy(event);
936 litest_assert_int_ge(curtime, oldtime);
937 oldtime = curtime;
938 }
939
940 event = libinput_get_event(li);
941 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
942 curtime = libinput_event_pointer_get_time(ptrev);
943 libinput_event_destroy(event);
944 litest_assert_int_gt(curtime, oldtime);
945
946 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
947
948 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
949
950 litest_touch_up(dev, 0);
951 litest_touch_down(dev, 0, 70, 50);
952 litest_touch_up(dev, 0);
953 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
954
955 litest_assert_empty_queue(li);
956 }
957 END_TEST
958
959 START_TEST(touchpad_multitap_n_drag_tap_click)
960 {
961 struct litest_device *dev = litest_current_device();
962 struct libinput *li = dev->libinput;
963 struct libinput_event *event;
964 struct libinput_event_pointer *ptrev;
965 uint32_t oldtime = 0, curtime;
966 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
967 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
968 unsigned int button = 0;
969
970 if (nfingers > litest_slot_count(dev))
971 return LITEST_NOT_APPLICABLE;
972
973 litest_enable_tap(dev->libinput_device);
974 litest_enable_drag_lock(dev->libinput_device);
975 litest_disable_hold_gestures(dev->libinput_device);
976
977 switch (nfingers) {
978 case 1:
979 button = BTN_LEFT;
980 break;
981 case 2:
982 button = BTN_RIGHT;
983 break;
984 case 3:
985 button = BTN_MIDDLE;
986 break;
987 default:
988 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
989 }
990
991 litest_drain_events(li);
992
993 for (ntaps = 0; ntaps <= range; ntaps++) {
994 switch (nfingers) {
995 case 3:
996 litest_touch_down(dev, 2, 60, 30);
997 _fallthrough_;
998 case 2:
999 litest_touch_down(dev, 1, 50, 30);
1000 _fallthrough_;
1001 case 1:
1002 litest_touch_down(dev, 0, 40, 30);
1003 break;
1004 }
1005 msleep(10);
1006 switch (nfingers) {
1007 case 3:
1008 litest_touch_up(dev, 2);
1009 _fallthrough_;
1010 case 2:
1011 litest_touch_up(dev, 1);
1012 _fallthrough_;
1013 case 1:
1014 litest_touch_up(dev, 0);
1015 break;
1016 }
1017
1018 litest_dispatch(li);
1019 msleep(10);
1020 }
1021
1022 litest_dispatch(li);
1023 litest_touch_down(dev, 0, 50, 50);
1024 litest_timeout_tap(li);
1025
1026 for (ntaps = 0; ntaps < range; ntaps++) {
1027 event = libinput_get_event(li);
1028 ptrev = litest_is_button_event(event,
1029 button,
1030 LIBINPUT_BUTTON_STATE_PRESSED);
1031 curtime = libinput_event_pointer_get_time(ptrev);
1032 libinput_event_destroy(event);
1033 litest_assert_int_gt(curtime, oldtime);
1034
1035 event = libinput_get_event(li);
1036 ptrev = litest_is_button_event(event,
1037 button,
1038 LIBINPUT_BUTTON_STATE_RELEASED);
1039 curtime = libinput_event_pointer_get_time(ptrev);
1040 libinput_event_destroy(event);
1041 litest_assert_int_ge(curtime, oldtime);
1042 oldtime = curtime;
1043 }
1044
1045 event = libinput_get_event(li);
1046 ptrev = litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_PRESSED);
1047 curtime = libinput_event_pointer_get_time(ptrev);
1048 libinput_event_destroy(event);
1049 litest_assert_int_gt(curtime, oldtime);
1050
1051 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
1052
1053 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1054
1055 litest_touch_up(dev, 0);
1056 litest_touch_down(dev, 0, 70, 50);
1057 litest_button_click(dev, BTN_LEFT, true);
1058 litest_button_click(dev, BTN_LEFT, false);
1059 litest_dispatch(li);
1060
1061 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1062
1063 /* the physical click */
1064 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1065 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1066 litest_touch_up(dev, 0);
1067
1068 litest_assert_empty_queue(li);
1069 }
1070 END_TEST
1071
1072 START_TEST(touchpad_tap_n_drag)
1073 {
1074 struct litest_device *dev = litest_current_device();
1075 struct libinput *li = dev->libinput;
1076 struct libinput_event *event;
1077 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1078 unsigned int button = 0;
1079
1080 if (nfingers > litest_slot_count(dev))
1081 return LITEST_NOT_APPLICABLE;
1082
1083 litest_enable_tap(dev->libinput_device);
1084 litest_disable_drag_lock(dev->libinput_device);
1085 litest_disable_hold_gestures(dev->libinput_device);
1086
1087 switch (nfingers) {
1088 case 1:
1089 button = BTN_LEFT;
1090 break;
1091 case 2:
1092 button = BTN_RIGHT;
1093 break;
1094 case 3:
1095 button = BTN_MIDDLE;
1096 break;
1097 default:
1098 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1099 }
1100
1101 litest_drain_events(li);
1102
1103 switch (nfingers) {
1104 case 3:
1105 litest_touch_down(dev, 2, 60, 30);
1106 _fallthrough_;
1107 case 2:
1108 litest_touch_down(dev, 1, 50, 30);
1109 _fallthrough_;
1110 case 1:
1111 litest_touch_down(dev, 0, 40, 30);
1112 break;
1113 }
1114 switch (nfingers) {
1115 case 3:
1116 litest_touch_up(dev, 2);
1117 _fallthrough_;
1118 case 2:
1119 litest_touch_up(dev, 1);
1120 _fallthrough_;
1121 case 1:
1122 litest_touch_up(dev, 0);
1123 break;
1124 }
1125 litest_touch_down(dev, 0, 50, 50);
1126 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1127
1128 litest_dispatch(li);
1129
1130 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1131
1132 litest_dispatch(li);
1133
1134 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1135
1136 litest_touch_up(dev, 0);
1137
1138 /* don't use helper functions here, we expect the event be available
1139 * immediately, not after a timeout that the helper functions may
1140 * trigger.
1141 */
1142 litest_dispatch(li);
1143 event = libinput_get_event(li);
1144 litest_assert_notnull(event);
1145 litest_is_button_event(event, button, LIBINPUT_BUTTON_STATE_RELEASED);
1146 libinput_event_destroy(event);
1147
1148 litest_assert_empty_queue(li);
1149 }
1150 END_TEST
1151
1152 START_TEST(touchpad_tap_n_drag_draglock)
1153 {
1154 struct litest_device *dev = litest_current_device();
1155 struct libinput *li = dev->libinput;
1156 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1157 unsigned int button = 0;
1158
1159 if (nfingers > litest_slot_count(dev))
1160 return LITEST_NOT_APPLICABLE;
1161
1162 litest_enable_tap(dev->libinput_device);
1163 litest_enable_drag_lock(dev->libinput_device);
1164 litest_disable_hold_gestures(dev->libinput_device);
1165
1166 switch (nfingers) {
1167 case 1:
1168 button = BTN_LEFT;
1169 break;
1170 case 2:
1171 button = BTN_RIGHT;
1172 break;
1173 case 3:
1174 button = BTN_MIDDLE;
1175 break;
1176 default:
1177 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1178 }
1179
1180 litest_drain_events(li);
1181
1182 switch (nfingers) {
1183 case 3:
1184 litest_touch_down(dev, 2, 60, 30);
1185 _fallthrough_;
1186 case 2:
1187 litest_touch_down(dev, 1, 50, 30);
1188 _fallthrough_;
1189 case 1:
1190 litest_touch_down(dev, 0, 40, 30);
1191 break;
1192 }
1193 switch (nfingers) {
1194 case 3:
1195 litest_touch_up(dev, 2);
1196 _fallthrough_;
1197 case 2:
1198 litest_touch_up(dev, 1);
1199 _fallthrough_;
1200 case 1:
1201 litest_touch_up(dev, 0);
1202 break;
1203 }
1204 litest_touch_down(dev, 0, 50, 50);
1205 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1206 litest_touch_up(dev, 0);
1207
1208 litest_dispatch(li);
1209
1210 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1211
1212 litest_dispatch(li);
1213
1214 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1215
1216 /* lift finger, set down again, should continue dragging */
1217 litest_touch_down(dev, 0, 50, 50);
1218 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1219 litest_touch_up(dev, 0);
1220
1221 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1222
1223 litest_timeout_tap(li);
1224
1225 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1226
1227 litest_assert_empty_queue(li);
1228 }
1229 END_TEST
1230
1231 START_TEST(touchpad_tap_n_drag_draglock_tap)
1232 {
1233 struct litest_device *dev = litest_current_device();
1234 struct libinput *li = dev->libinput;
1235 int nfingers = litest_test_param_get_i32(test_env->params, "fingers_1st"),
1236 nfingers2 = litest_test_param_get_i32(test_env->params, "fingers_2nd");
1237 unsigned int button = 0;
1238
1239 if (nfingers > litest_slot_count(dev))
1240 return LITEST_NOT_APPLICABLE;
1241
1242 if (nfingers2 > litest_slot_count(dev))
1243 return LITEST_NOT_APPLICABLE;
1244
1245 litest_enable_tap(dev->libinput_device);
1246 litest_enable_drag_lock(dev->libinput_device);
1247 litest_disable_hold_gestures(dev->libinput_device);
1248
1249 switch (nfingers) {
1250 case 1:
1251 button = BTN_LEFT;
1252 break;
1253 case 2:
1254 button = BTN_RIGHT;
1255 break;
1256 case 3:
1257 button = BTN_MIDDLE;
1258 break;
1259 default:
1260 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1261 }
1262
1263 litest_drain_events(li);
1264
1265 switch (nfingers) {
1266 case 3:
1267 litest_touch_down(dev, 2, 60, 30);
1268 _fallthrough_;
1269 case 2:
1270 litest_touch_down(dev, 1, 50, 30);
1271 _fallthrough_;
1272 case 1:
1273 litest_touch_down(dev, 0, 40, 30);
1274 break;
1275 }
1276 switch (nfingers) {
1277 case 3:
1278 litest_touch_up(dev, 2);
1279 _fallthrough_;
1280 case 2:
1281 litest_touch_up(dev, 1);
1282 _fallthrough_;
1283 case 1:
1284 litest_touch_up(dev, 0);
1285 break;
1286 }
1287 litest_touch_down(dev, 0, 50, 50);
1288 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1289 litest_touch_up(dev, 0);
1290
1291 litest_dispatch(li);
1292
1293 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1294
1295 litest_dispatch(li);
1296
1297 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1298
1299 /* lift finger, set down again, should continue dragging */
1300 litest_touch_down(dev, 0, 50, 50);
1301 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1302
1303 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1304
1305 litest_touch_up(dev, 0);
1306
1307 switch (nfingers2) {
1308 case 3:
1309 litest_touch_down(dev, 2, 60, 30);
1310 _fallthrough_;
1311 case 2:
1312 litest_touch_down(dev, 1, 50, 30);
1313 _fallthrough_;
1314 case 1:
1315 litest_touch_down(dev, 0, 40, 30);
1316 break;
1317 }
1318 switch (nfingers2) {
1319 case 3:
1320 litest_touch_up(dev, 2);
1321 _fallthrough_;
1322 case 2:
1323 litest_touch_up(dev, 1);
1324 _fallthrough_;
1325 case 1:
1326 litest_touch_up(dev, 0);
1327 break;
1328 }
1329
1330 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1331
1332 litest_assert_empty_queue(li);
1333 }
1334 END_TEST
1335
1336 START_TEST(touchpad_tap_n_drag_draglock_tap_click)
1337 {
1338 struct litest_device *dev = litest_current_device();
1339 struct libinput *li = dev->libinput;
1340 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1341 unsigned int button = 0;
1342
1343 if (nfingers > litest_slot_count(dev))
1344 return LITEST_NOT_APPLICABLE;
1345
1346 litest_enable_tap(dev->libinput_device);
1347 litest_enable_drag_lock(dev->libinput_device);
1348 litest_disable_hold_gestures(dev->libinput_device);
1349
1350 switch (nfingers) {
1351 case 1:
1352 button = BTN_LEFT;
1353 break;
1354 case 2:
1355 button = BTN_RIGHT;
1356 break;
1357 case 3:
1358 button = BTN_MIDDLE;
1359 break;
1360 default:
1361 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1362 }
1363
1364 litest_drain_events(li);
1365
1366 switch (nfingers) {
1367 case 3:
1368 litest_touch_down(dev, 2, 60, 30);
1369 _fallthrough_;
1370 case 2:
1371 litest_touch_down(dev, 1, 50, 30);
1372 _fallthrough_;
1373 case 1:
1374 litest_touch_down(dev, 0, 40, 30);
1375 break;
1376 }
1377 switch (nfingers) {
1378 case 3:
1379 litest_touch_up(dev, 2);
1380 _fallthrough_;
1381 case 2:
1382 litest_touch_up(dev, 1);
1383 _fallthrough_;
1384 case 1:
1385 litest_touch_up(dev, 0);
1386 break;
1387 }
1388 litest_touch_down(dev, 0, 50, 50);
1389 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1390 litest_dispatch(li);
1391
1392 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1393
1394 litest_dispatch(li);
1395
1396 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1397
1398 litest_touch_up(dev, 0);
1399 litest_touch_down(dev, 0, 50, 50);
1400 litest_button_click(dev, BTN_LEFT, true);
1401 litest_button_click(dev, BTN_LEFT, false);
1402 litest_dispatch(li);
1403
1404 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1405
1406 /* the physical click */
1407 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1408 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1409 litest_touch_up(dev, 0);
1410
1411 litest_assert_empty_queue(li);
1412 }
1413 END_TEST
1414
1415 START_TEST(touchpad_tap_n_drag_draglock_timeout)
1416 {
1417 struct litest_device *dev = litest_current_device();
1418 struct libinput *li = dev->libinput;
1419 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1420 unsigned int button = 0;
1421
1422 if (nfingers > litest_slot_count(dev))
1423 return LITEST_NOT_APPLICABLE;
1424
1425 litest_enable_tap(dev->libinput_device);
1426 litest_enable_drag_lock(dev->libinput_device);
1427 litest_disable_hold_gestures(dev->libinput_device);
1428
1429 switch (nfingers) {
1430 case 1:
1431 button = BTN_LEFT;
1432 break;
1433 case 2:
1434 button = BTN_RIGHT;
1435 break;
1436 case 3:
1437 button = BTN_MIDDLE;
1438 break;
1439 default:
1440 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1441 }
1442
1443 litest_drain_events(li);
1444
1445 switch (nfingers) {
1446 case 3:
1447 litest_touch_down(dev, 2, 60, 30);
1448 _fallthrough_;
1449 case 2:
1450 litest_touch_down(dev, 1, 50, 30);
1451 _fallthrough_;
1452 case 1:
1453 litest_touch_down(dev, 0, 40, 30);
1454 break;
1455 }
1456 switch (nfingers) {
1457 case 3:
1458 litest_touch_up(dev, 2);
1459 _fallthrough_;
1460 case 2:
1461 litest_touch_up(dev, 1);
1462 _fallthrough_;
1463 case 1:
1464 litest_touch_up(dev, 0);
1465 break;
1466 }
1467 litest_touch_down(dev, 0, 50, 50);
1468 litest_timeout_tap(li);
1469
1470 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1471
1472 litest_assert_empty_queue(li);
1473 litest_touch_up(dev, 0);
1474 litest_timeout_tapndrag(li);
1475 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1476
1477 litest_assert_empty_queue(li);
1478 }
1479 END_TEST
1480
1481 START_TEST(touchpad_tap_n_drag_draglock_sticky)
1482 {
1483 struct litest_device *dev = litest_current_device();
1484 struct libinput *li = dev->libinput;
1485 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1486 unsigned int button = 0;
1487
1488 if (nfingers > litest_slot_count(dev))
1489 return LITEST_NOT_APPLICABLE;
1490
1491 litest_enable_tap(dev->libinput_device);
1492 litest_enable_drag_lock_sticky(dev->libinput_device);
1493 litest_disable_hold_gestures(dev->libinput_device);
1494
1495 switch (nfingers) {
1496 case 1:
1497 button = BTN_LEFT;
1498 break;
1499 case 2:
1500 button = BTN_RIGHT;
1501 break;
1502 case 3:
1503 button = BTN_MIDDLE;
1504 break;
1505 default:
1506 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1507 }
1508
1509 litest_drain_events(li);
1510
1511 switch (nfingers) {
1512 case 3:
1513 litest_touch_down(dev, 2, 60, 30);
1514 _fallthrough_;
1515 case 2:
1516 litest_touch_down(dev, 1, 50, 30);
1517 _fallthrough_;
1518 case 1:
1519 litest_touch_down(dev, 0, 40, 30);
1520 break;
1521 }
1522 switch (nfingers) {
1523 case 3:
1524 litest_touch_up(dev, 2);
1525 _fallthrough_;
1526 case 2:
1527 litest_touch_up(dev, 1);
1528 _fallthrough_;
1529 case 1:
1530 litest_touch_up(dev, 0);
1531 break;
1532 }
1533 litest_touch_down(dev, 0, 50, 50);
1534 litest_timeout_tap(li);
1535
1536 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1537
1538 litest_assert_empty_queue(li);
1539 litest_touch_up(dev, 0);
1540
1541 litest_timeout_tapndrag(li);
1542 litest_assert_empty_queue(li);
1543
1544 litest_touch_down(dev, 0, 50, 50);
1545 litest_touch_up(dev, 0);
1546 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1547
1548 litest_assert_empty_queue(li);
1549 }
1550 END_TEST
1551
1552 START_TEST(touchpad_tap_n_drag_2fg)
1553 {
1554 /* Test: tap with 1-3 fingers (multiple times), then a 1fg move
1555 * followed by a second finger down and *both* fingers moving.
1556 * This is a special behavior catering for the use-case when a user
1557 * needs a second finger down to "hold" the drag while resetting the
1558 * first finger.
1559 * Even though it's 2fg movement, we expect it to behave like a 1fg
1560 * drag. This behavior may change in the future.
1561 */
1562 struct litest_device *dev = litest_current_device();
1563 struct libinput *li = dev->libinput;
1564 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1565 unsigned int button = 0;
1566
1567 if (nfingers > litest_slot_count(dev))
1568 return LITEST_NOT_APPLICABLE;
1569
1570 litest_enable_tap(dev->libinput_device);
1571 litest_disable_drag_lock(dev->libinput_device);
1572 litest_disable_hold_gestures(dev->libinput_device);
1573
1574 switch (nfingers) {
1575 case 1:
1576 button = BTN_LEFT;
1577 break;
1578 case 2:
1579 button = BTN_RIGHT;
1580 break;
1581 case 3:
1582 button = BTN_MIDDLE;
1583 break;
1584 default:
1585 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1586 }
1587
1588 litest_drain_events(li);
1589
1590 switch (nfingers) {
1591 case 3:
1592 litest_touch_down(dev, 2, 60, 30);
1593 _fallthrough_;
1594 case 2:
1595 litest_touch_down(dev, 1, 50, 30);
1596 _fallthrough_;
1597 case 1:
1598 litest_touch_down(dev, 0, 40, 30);
1599 break;
1600 }
1601 switch (nfingers) {
1602 case 3:
1603 litest_touch_up(dev, 2);
1604 _fallthrough_;
1605 case 2:
1606 litest_touch_up(dev, 1);
1607 _fallthrough_;
1608 case 1:
1609 litest_touch_up(dev, 0);
1610 break;
1611 }
1612 litest_touch_down(dev, 0, 30, 70);
1613 litest_timeout_tap(li);
1614 litest_touch_down(dev, 1, 80, 70);
1615 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
1616 litest_dispatch(li);
1617
1618 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1619
1620 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1621
1622 litest_touch_up(dev, 0);
1623 litest_touch_up(dev, 1);
1624
1625 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1626
1627 litest_assert_empty_queue(li);
1628 }
1629 END_TEST
1630
1631 START_TEST(touchpad_tap_n_drag_2fg_scroll)
1632 {
1633 /* Test: tap with 1-3 fingers, then immediate 2fg scroll.
1634 * We expect this to be a tap followed by a scroll.
1635 */
1636 struct litest_device *dev = litest_current_device();
1637 struct libinput *li = dev->libinput;
1638 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1639 unsigned int button = 0;
1640
1641 if (nfingers > litest_slot_count(dev))
1642 return LITEST_NOT_APPLICABLE;
1643
1644 litest_enable_2fg_scroll(dev);
1645 litest_enable_tap(dev->libinput_device);
1646 litest_disable_drag_lock(dev->libinput_device);
1647 litest_disable_hold_gestures(dev->libinput_device);
1648
1649 switch (nfingers) {
1650 case 1:
1651 button = BTN_LEFT;
1652 break;
1653 case 2:
1654 button = BTN_RIGHT;
1655 break;
1656 case 3:
1657 button = BTN_MIDDLE;
1658 break;
1659 default:
1660 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1661 }
1662
1663 litest_drain_events(li);
1664
1665 switch (nfingers) {
1666 case 3:
1667 litest_touch_down(dev, 2, 60, 30);
1668 _fallthrough_;
1669 case 2:
1670 litest_touch_down(dev, 1, 50, 30);
1671 _fallthrough_;
1672 case 1:
1673 litest_touch_down(dev, 0, 40, 30);
1674 break;
1675 }
1676 switch (nfingers) {
1677 case 3:
1678 litest_touch_up(dev, 2);
1679 _fallthrough_;
1680 case 2:
1681 litest_touch_up(dev, 1);
1682 _fallthrough_;
1683 case 1:
1684 litest_touch_up(dev, 0);
1685 break;
1686 }
1687
1688 /* Two fingers down + move to trigger scrolling */
1689 litest_dispatch(li);
1690 litest_touch_down(dev, 0, 50, 50);
1691 litest_touch_down(dev, 1, 70, 50);
1692 litest_dispatch(li);
1693 litest_touch_move_two_touches(dev, 50, 50, 70, 50, 0, 20, 10);
1694 litest_dispatch(li);
1695 litest_touch_up(dev, 0);
1696 litest_touch_up(dev, 1);
1697 litest_dispatch(li);
1698
1699 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1700 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1701
1702 litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
1703
1704 litest_assert_empty_queue(li);
1705 }
1706 END_TEST
1707
1708 START_TEST(touchpad_tap_n_drag_draglock_2fg_scroll)
1709 {
1710 /* Test: tap with 1-3 fingers, trigger drag-lock,
1711 * then immediate 2fg scroll.
1712 * We expect this to be a tap-and-drag followed by a scroll.
1713 */
1714 struct litest_device *dev = litest_current_device();
1715 struct libinput *li = dev->libinput;
1716 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1717 unsigned int button = 0;
1718
1719 if (nfingers > litest_slot_count(dev))
1720 return LITEST_NOT_APPLICABLE;
1721
1722 litest_enable_2fg_scroll(dev);
1723 litest_enable_tap(dev->libinput_device);
1724 litest_enable_drag_lock(dev->libinput_device);
1725 litest_disable_hold_gestures(dev->libinput_device);
1726
1727 switch (nfingers) {
1728 case 1:
1729 button = BTN_LEFT;
1730 break;
1731 case 2:
1732 button = BTN_RIGHT;
1733 break;
1734 case 3:
1735 button = BTN_MIDDLE;
1736 break;
1737 default:
1738 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1739 }
1740
1741 litest_drain_events(li);
1742
1743 switch (nfingers) {
1744 case 3:
1745 litest_touch_down(dev, 2, 60, 30);
1746 _fallthrough_;
1747 case 2:
1748 litest_touch_down(dev, 1, 50, 30);
1749 _fallthrough_;
1750 case 1:
1751 litest_touch_down(dev, 0, 40, 30);
1752 break;
1753 }
1754 switch (nfingers) {
1755 case 3:
1756 litest_touch_up(dev, 2);
1757 _fallthrough_;
1758 case 2:
1759 litest_touch_up(dev, 1);
1760 _fallthrough_;
1761 case 1:
1762 litest_touch_up(dev, 0);
1763 break;
1764 }
1765
1766 /* Drag with one finger */
1767 litest_touch_down(dev, 0, 50, 50);
1768 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
1769
1770 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1771 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1772
1773 /* Release finger to trigger drag-lock */
1774 litest_touch_up(dev, 0);
1775
1776 /* Two fingers down + move to trigger scrolling */
1777 litest_dispatch(li);
1778 litest_touch_down(dev, 0, 50, 50);
1779 litest_touch_down(dev, 1, 70, 50);
1780 litest_dispatch(li);
1781 litest_touch_move_two_touches(dev, 50, 50, 70, 50, 0, 20, 10);
1782 litest_dispatch(li);
1783 litest_touch_up(dev, 0);
1784 litest_touch_up(dev, 1);
1785 litest_dispatch(li);
1786
1787 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1788
1789 litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
1790
1791 litest_assert_empty_queue(li);
1792 }
1793 END_TEST
1794
1795 START_TEST(touchpad_tap_n_drag_3fg_btntool)
1796 {
1797 struct litest_device *dev = litest_current_device();
1798 struct libinput *li = dev->libinput;
1799 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1800 unsigned int button = 0;
1801
1802 if (litest_slot_count(dev) > 2 ||
1803 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
1804 return LITEST_NOT_APPLICABLE;
1805
1806 litest_enable_tap(dev->libinput_device);
1807 litest_disable_hold_gestures(dev->libinput_device);
1808
1809 switch (nfingers) {
1810 case 1:
1811 button = BTN_LEFT;
1812 break;
1813 case 2:
1814 button = BTN_RIGHT;
1815 break;
1816 case 3:
1817 button = BTN_MIDDLE;
1818 break;
1819 default:
1820 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1821 }
1822
1823 litest_drain_events(li);
1824
1825 switch (nfingers) {
1826 case 3:
1827 litest_touch_down(dev, 0, 40, 30);
1828 litest_touch_down(dev, 1, 50, 30);
1829 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1830 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1831 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1832 break;
1833 case 2:
1834 litest_touch_down(dev, 1, 50, 30);
1835 _fallthrough_;
1836 case 1:
1837 litest_touch_down(dev, 0, 40, 30);
1838 break;
1839 }
1840 switch (nfingers) {
1841 case 3:
1842 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1843 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1844 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1845 _fallthrough_;
1846 case 2:
1847 litest_touch_up(dev, 1);
1848 _fallthrough_;
1849 case 1:
1850 litest_touch_up(dev, 0);
1851 break;
1852 }
1853 litest_touch_down(dev, 0, 30, 70);
1854 litest_timeout_tap(li);
1855 litest_touch_down(dev, 1, 80, 90);
1856 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 5);
1857 litest_dispatch(li);
1858
1859 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1860
1861 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1862
1863 /* Putting down a third finger should end the drag */
1864 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1865 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1866 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1867 litest_dispatch(li);
1868
1869 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1870
1871 /* Releasing the fingers should not cause any events */
1872 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1873 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1874 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1875 litest_touch_up(dev, 1);
1876 litest_touch_up(dev, 0);
1877
1878 litest_assert_empty_queue(li);
1879 }
1880 END_TEST
1881
1882 START_TEST(touchpad_tap_n_drag_3fg)
1883 {
1884 /* Test: tap with 1-3 fingers (multiple times), then a 1fg move
1885 * followed by a second finger down and *both* fingers moving.
1886 * This is a special behavior catering for the use-case when a user
1887 * needs a second finger down to "hold" the drag while resetting the
1888 * first finger.
1889 * Even though it's 2fg movement, we expect it to behave like a 1fg
1890 * drag. This behavior may change in the future.
1891 */
1892 struct litest_device *dev = litest_current_device();
1893 struct libinput *li = dev->libinput;
1894 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1895 unsigned int button = 0;
1896
1897 if (litest_slot_count(dev) < 3)
1898 return LITEST_NOT_APPLICABLE;
1899
1900 litest_enable_tap(dev->libinput_device);
1901 litest_disable_hold_gestures(dev->libinput_device);
1902
1903 switch (nfingers) {
1904 case 1:
1905 button = BTN_LEFT;
1906 break;
1907 case 2:
1908 button = BTN_RIGHT;
1909 break;
1910 case 3:
1911 button = BTN_MIDDLE;
1912 break;
1913 default:
1914 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1915 }
1916
1917 litest_drain_events(li);
1918
1919 switch (nfingers) {
1920 case 3:
1921 litest_touch_down(dev, 2, 60, 30);
1922 _fallthrough_;
1923 case 2:
1924 litest_touch_down(dev, 1, 50, 30);
1925 _fallthrough_;
1926 case 1:
1927 litest_touch_down(dev, 0, 40, 30);
1928 break;
1929 }
1930 switch (nfingers) {
1931 case 3:
1932 litest_touch_up(dev, 2);
1933 _fallthrough_;
1934 case 2:
1935 litest_touch_up(dev, 1);
1936 _fallthrough_;
1937 case 1:
1938 litest_touch_up(dev, 0);
1939 break;
1940 }
1941 /* 1fg down triggers the drag */
1942 litest_touch_down(dev, 0, 30, 70);
1943 litest_timeout_tap(li);
1944 /* 2fg is allowed now without cancelling the drag */
1945 litest_touch_down(dev, 1, 80, 90);
1946 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
1947 litest_dispatch(li);
1948
1949 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
1950
1951 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1952
1953 /* Putting down a third finger should end the drag */
1954 litest_touch_down(dev, 2, 50, 50);
1955
1956 litest_dispatch(li);
1957
1958 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
1959
1960 /* Releasing the fingers should not cause any events */
1961 litest_touch_up(dev, 2);
1962 litest_touch_up(dev, 1);
1963 litest_touch_up(dev, 0);
1964
1965 litest_assert_empty_queue(li);
1966 }
1967 END_TEST
1968
1969 START_TEST(touchpad_tap_n_drag_3fg_swipe)
1970 {
1971 /* Test: tap with 1-3 fingers, then immediate 3fg swipe.
1972 * We expect this to be a tap followed by a swipe.
1973 */
1974 struct litest_device *dev = litest_current_device();
1975 struct libinput *li = dev->libinput;
1976 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
1977 unsigned int button = 0;
1978
1979 if (litest_slot_count(dev) < 3)
1980 return LITEST_NOT_APPLICABLE;
1981
1982 litest_enable_tap(dev->libinput_device);
1983 litest_disable_hold_gestures(dev->libinput_device);
1984
1985 switch (nfingers) {
1986 case 1:
1987 button = BTN_LEFT;
1988 break;
1989 case 2:
1990 button = BTN_RIGHT;
1991 break;
1992 case 3:
1993 button = BTN_MIDDLE;
1994 break;
1995 default:
1996 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
1997 }
1998
1999 litest_drain_events(li);
2000
2001 switch (nfingers) {
2002 case 3:
2003 litest_touch_down(dev, 2, 60, 30);
2004 _fallthrough_;
2005 case 2:
2006 litest_touch_down(dev, 1, 50, 30);
2007 _fallthrough_;
2008 case 1:
2009 litest_touch_down(dev, 0, 40, 30);
2010 break;
2011 }
2012 switch (nfingers) {
2013 case 3:
2014 litest_touch_up(dev, 2);
2015 _fallthrough_;
2016 case 2:
2017 litest_touch_up(dev, 1);
2018 _fallthrough_;
2019 case 1:
2020 litest_touch_up(dev, 0);
2021 break;
2022 }
2023
2024 litest_touch_down(dev, 0, 30, 50);
2025 litest_touch_down(dev, 1, 50, 50);
2026 litest_touch_down(dev, 2, 80, 50);
2027 litest_dispatch(li);
2028 litest_touch_move_three_touches(dev, 30, 50, 50, 50, 80, 50, 0, 20, 10);
2029 litest_dispatch(li);
2030
2031 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2032 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2033
2034 litest_assert_gesture_event(li, LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN, 3);
2035 litest_assert_only_typed_events(li, LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE);
2036
2037 litest_touch_up(dev, 2);
2038 litest_touch_up(dev, 1);
2039 litest_touch_up(dev, 0);
2040 litest_assert_gesture_event(li, LIBINPUT_EVENT_GESTURE_SWIPE_END, 3);
2041
2042 litest_assert_empty_queue(li);
2043 }
2044 END_TEST
2045
2046 START_TEST(touchpad_tap_n_drag_draglock_3fg_swipe)
2047 {
2048 /* Test: tap with 1-3 fingers, trigger drag-lock,
2049 * then immediate 3fg swipe.
2050 * We expect this to be a tap-and-drag followed by a swipe.
2051 */
2052 struct litest_device *dev = litest_current_device();
2053 struct libinput *li = dev->libinput;
2054 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
2055 unsigned int button = 0;
2056
2057 if (litest_slot_count(dev) < 3)
2058 return LITEST_NOT_APPLICABLE;
2059
2060 litest_enable_tap(dev->libinput_device);
2061 litest_enable_drag_lock(dev->libinput_device);
2062 litest_disable_hold_gestures(dev->libinput_device);
2063
2064 switch (nfingers) {
2065 case 1:
2066 button = BTN_LEFT;
2067 break;
2068 case 2:
2069 button = BTN_RIGHT;
2070 break;
2071 case 3:
2072 button = BTN_MIDDLE;
2073 break;
2074 default:
2075 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
2076 }
2077
2078 litest_drain_events(li);
2079
2080 switch (nfingers) {
2081 case 3:
2082 litest_touch_down(dev, 2, 60, 30);
2083 _fallthrough_;
2084 case 2:
2085 litest_touch_down(dev, 1, 50, 30);
2086 _fallthrough_;
2087 case 1:
2088 litest_touch_down(dev, 0, 40, 30);
2089 break;
2090 }
2091 switch (nfingers) {
2092 case 3:
2093 litest_touch_up(dev, 2);
2094 _fallthrough_;
2095 case 2:
2096 litest_touch_up(dev, 1);
2097 _fallthrough_;
2098 case 1:
2099 litest_touch_up(dev, 0);
2100 break;
2101 }
2102
2103 /* Drag with one finger */
2104 litest_touch_down(dev, 0, 50, 50);
2105 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
2106
2107 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2108 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
2109
2110 /* Release finger to trigger drag-lock */
2111 litest_touch_up(dev, 0);
2112
2113 litest_touch_down(dev, 0, 30, 50);
2114 litest_touch_down(dev, 1, 50, 50);
2115 litest_touch_down(dev, 2, 80, 50);
2116 litest_dispatch(li);
2117 litest_touch_move_three_touches(dev, 30, 50, 50, 50, 80, 50, 0, 20, 10);
2118 litest_dispatch(li);
2119
2120 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2121
2122 litest_assert_gesture_event(li, LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN, 3);
2123 litest_assert_only_typed_events(li, LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE);
2124
2125 litest_touch_up(dev, 2);
2126 litest_touch_up(dev, 1);
2127 litest_touch_up(dev, 0);
2128 litest_assert_gesture_event(li, LIBINPUT_EVENT_GESTURE_SWIPE_END, 3);
2129
2130 litest_assert_empty_queue(li);
2131 }
2132 END_TEST
2133
2134 START_TEST(touchpad_2fg_tap)
2135 {
2136 struct litest_device *dev = litest_current_device();
2137 struct libinput *li = dev->libinput;
2138 unsigned int button = 0;
2139 struct libinput_event *ev;
2140 struct libinput_event_pointer *ptrev;
2141 uint64_t ptime, rtime;
2142
2143 enum libinput_config_tap_button_map map =
2144 litest_test_param_get_i32(test_env->params, "map");
2145
2146 litest_enable_tap(dev->libinput_device);
2147 litest_set_tap_map(dev->libinput_device, map);
2148 litest_disable_hold_gestures(dev->libinput_device);
2149
2150 switch (map) {
2151 case LIBINPUT_CONFIG_TAP_MAP_LRM:
2152 button = BTN_RIGHT;
2153 break;
2154 case LIBINPUT_CONFIG_TAP_MAP_LMR:
2155 button = BTN_MIDDLE;
2156 break;
2157 default:
2158 litest_abort_msg("Invalid map range %d", map);
2159 }
2160
2161 litest_drain_events(dev->libinput);
2162
2163 litest_touch_down(dev, 0, 50, 50);
2164 litest_touch_down(dev, 1, 70, 70);
2165 litest_touch_up(dev, 0);
2166 litest_touch_up(dev, 1);
2167
2168 litest_timeout_tap(li);
2169
2170 ev = libinput_get_event(li);
2171 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_PRESSED);
2172 ptime = libinput_event_pointer_get_time_usec(ptrev);
2173 libinput_event_destroy(ev);
2174 ev = libinput_get_event(li);
2175 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_RELEASED);
2176 rtime = libinput_event_pointer_get_time_usec(ptrev);
2177 libinput_event_destroy(ev);
2178
2179 litest_assert_int_lt(ptime, rtime);
2180
2181 litest_assert_empty_queue(li);
2182 }
2183 END_TEST
2184
2185 START_TEST(touchpad_2fg_tap_inverted)
2186 {
2187 struct litest_device *dev = litest_current_device();
2188 struct libinput *li = dev->libinput;
2189 unsigned int button = 0;
2190 struct libinput_event *ev;
2191 struct libinput_event_pointer *ptrev;
2192 uint64_t ptime, rtime;
2193
2194 enum libinput_config_tap_button_map map =
2195 litest_test_param_get_i32(test_env->params, "map");
2196
2197 litest_enable_tap(dev->libinput_device);
2198 litest_set_tap_map(dev->libinput_device, map);
2199 litest_disable_hold_gestures(dev->libinput_device);
2200
2201 switch (map) {
2202 case LIBINPUT_CONFIG_TAP_MAP_LRM:
2203 button = BTN_RIGHT;
2204 break;
2205 case LIBINPUT_CONFIG_TAP_MAP_LMR:
2206 button = BTN_MIDDLE;
2207 break;
2208 default:
2209 litest_abort_msg("Invalid map range %d", map);
2210 }
2211
2212 litest_drain_events(dev->libinput);
2213
2214 litest_touch_down(dev, 0, 50, 50);
2215 litest_touch_down(dev, 1, 70, 70);
2216 litest_touch_up(dev, 1);
2217 litest_touch_up(dev, 0);
2218
2219 litest_timeout_tap(li);
2220
2221 ev = libinput_get_event(li);
2222 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_PRESSED);
2223 ptime = libinput_event_pointer_get_time_usec(ptrev);
2224 libinput_event_destroy(ev);
2225 ev = libinput_get_event(li);
2226 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_RELEASED);
2227 rtime = libinput_event_pointer_get_time_usec(ptrev);
2228 libinput_event_destroy(ev);
2229
2230 litest_assert_int_lt(ptime, rtime);
2231
2232 litest_assert_empty_queue(li);
2233 }
2234 END_TEST
2235
2236 START_TEST(touchpad_2fg_tap_move_on_release)
2237 {
2238 struct litest_device *dev = litest_current_device();
2239 struct libinput *li = dev->libinput;
2240
2241 litest_enable_tap(dev->libinput_device);
2242 litest_disable_hold_gestures(dev->libinput_device);
2243 litest_drain_events(dev->libinput);
2244
2245 litest_touch_down(dev, 0, 50, 50);
2246 litest_touch_down(dev, 1, 70, 70);
2247
2248 litest_push_event_frame(dev);
2249 litest_touch_move(dev, 0, 55, 55);
2250 litest_touch_up(dev, 1);
2251 litest_pop_event_frame(dev);
2252
2253 litest_touch_up(dev, 0);
2254
2255 litest_dispatch(li);
2256
2257 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2258 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2259
2260 litest_assert_empty_queue(li);
2261 }
2262 END_TEST
2263
2264 START_TEST(touchpad_2fg_tap_n_hold_first)
2265 {
2266 struct litest_device *dev = litest_current_device();
2267 struct libinput *li = dev->libinput;
2268
2269 litest_enable_tap(dev->libinput_device);
2270 litest_disable_hold_gestures(dev->libinput_device);
2271 litest_drain_events(dev->libinput);
2272
2273 litest_touch_down(dev, 0, 50, 50);
2274 litest_touch_down(dev, 1, 70, 70);
2275 litest_touch_up(dev, 1);
2276
2277 litest_dispatch(li);
2278
2279 litest_assert_empty_queue(li);
2280 litest_timeout_tap(li);
2281
2282 litest_assert_empty_queue(li);
2283 }
2284 END_TEST
2285
2286 START_TEST(touchpad_2fg_tap_n_hold_second)
2287 {
2288 struct litest_device *dev = litest_current_device();
2289 struct libinput *li = dev->libinput;
2290
2291 litest_enable_tap(dev->libinput_device);
2292 litest_disable_hold_gestures(dev->libinput_device);
2293 litest_drain_events(dev->libinput);
2294
2295 litest_touch_down(dev, 0, 50, 50);
2296 litest_touch_down(dev, 1, 70, 70);
2297 litest_touch_up(dev, 0);
2298
2299 litest_dispatch(li);
2300
2301 litest_assert_empty_queue(li);
2302 litest_timeout_tap(li);
2303
2304 litest_assert_empty_queue(li);
2305 }
2306 END_TEST
2307
2308 START_TEST(touchpad_2fg_tap_quickrelease)
2309 {
2310 struct litest_device *dev = litest_current_device();
2311 struct libinput *li = dev->libinput;
2312
2313 litest_enable_tap(dev->libinput_device);
2314 litest_disable_hold_gestures(dev->libinput_device);
2315 litest_drain_events(dev->libinput);
2316
2317 litest_touch_down(dev, 0, 50, 50);
2318 litest_touch_down(dev, 1, 70, 70);
2319 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
2320 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2321 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
2322 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2323 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
2324 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
2325 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2326
2327 litest_dispatch(li);
2328
2329 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2330 litest_timeout_tap(li);
2331 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2332
2333 litest_assert_empty_queue(li);
2334 }
2335 END_TEST
2336
2337 START_TEST(touchpad_1fg_tap_click)
2338 {
2339 struct litest_device *dev = litest_current_device();
2340 struct libinput *li = dev->libinput;
2341
2342 litest_enable_tap(dev->libinput_device);
2343 litest_disable_hold_gestures(dev->libinput_device);
2344 litest_drain_events(dev->libinput);
2345
2346 /* Finger down, finger up -> tap button press
2347 * Physical button click -> no button press/release
2348 * Tap timeout -> tap button release */
2349 litest_touch_down(dev, 0, 50, 50);
2350 litest_touch_up(dev, 0);
2351 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2352 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2353 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2354 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2355 litest_timeout_tap(li);
2356
2357 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2358 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2359
2360 litest_assert_empty_queue(li);
2361 }
2362 END_TEST
2363
2364 START_TEST(touchpad_2fg_tap_click)
2365 {
2366 struct litest_device *dev = litest_current_device();
2367 struct libinput *li = dev->libinput;
2368
2369 litest_enable_tap(dev->libinput_device);
2370 litest_disable_hold_gestures(dev->libinput_device);
2371 litest_drain_events(dev->libinput);
2372
2373 /* two fingers down, left button click, fingers up
2374 -> one left button, one right button event pair */
2375 litest_touch_down(dev, 0, 50, 50);
2376 litest_touch_down(dev, 1, 70, 50);
2377 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2378 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2379 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2380 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2381 litest_touch_up(dev, 1);
2382 litest_touch_up(dev, 0);
2383
2384 litest_dispatch(li);
2385
2386 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2387 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2388 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2389 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2390
2391 litest_assert_empty_queue(li);
2392 }
2393 END_TEST
2394
2395 START_TEST(clickpad_2fg_tap_click)
2396 {
2397 struct litest_device *dev = litest_current_device();
2398 struct libinput *li = dev->libinput;
2399
2400 litest_enable_tap(dev->libinput_device);
2401 litest_disable_hold_gestures(dev->libinput_device);
2402 litest_drain_events(dev->libinput);
2403
2404 /* two fingers down, button click, fingers up
2405 -> only one button left event pair */
2406 litest_touch_down(dev, 0, 50, 50);
2407 litest_touch_down(dev, 1, 70, 50);
2408 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2409 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2410 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2411 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2412 litest_touch_up(dev, 1);
2413 litest_touch_up(dev, 0);
2414
2415 litest_dispatch(li);
2416
2417 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2418 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2419
2420 litest_assert_empty_queue(li);
2421 }
2422 END_TEST
2423
2424 START_TEST(touchpad_2fg_tap_click_apple)
2425 {
2426 struct litest_device *dev = litest_current_device();
2427 struct libinput *li = dev->libinput;
2428
2429 litest_enable_tap(dev->libinput_device);
2430 litest_disable_hold_gestures(dev->libinput_device);
2431 litest_drain_events(dev->libinput);
2432
2433 /* two fingers down, button click, fingers up
2434 -> only one button right event pair
2435 (apple have clickfinger enabled by default) */
2436 litest_touch_down(dev, 0, 50, 50);
2437 litest_touch_down(dev, 1, 70, 50);
2438 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2439 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2440 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2441 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2442 litest_touch_up(dev, 1);
2443 litest_touch_up(dev, 0);
2444
2445 litest_dispatch(li);
2446
2447 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
2448 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
2449
2450 litest_assert_empty_queue(li);
2451 }
2452 END_TEST
2453
2454 START_TEST(touchpad_no_2fg_tap_after_move)
2455 {
2456 struct litest_device *dev = litest_current_device();
2457 struct libinput *li = dev->libinput;
2458
2459 litest_enable_tap(dev->libinput_device);
2460 litest_disable_hold_gestures(dev->libinput_device);
2461 litest_drain_events(dev->libinput);
2462
2463 /* one finger down, move past threshold,
2464 second finger down, first finger up
2465 -> no event
2466 */
2467 litest_touch_down(dev, 0, 50, 50);
2468 litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10);
2469 litest_drain_events(dev->libinput);
2470
2471 litest_touch_down(dev, 1, 70, 50);
2472 litest_touch_up(dev, 0);
2473
2474 litest_assert_empty_queue(li);
2475 }
2476 END_TEST
2477
2478 START_TEST(touchpad_no_2fg_tap_after_timeout)
2479 {
2480 struct litest_device *dev = litest_current_device();
2481 struct libinput *li = dev->libinput;
2482
2483 litest_enable_tap(dev->libinput_device);
2484 litest_disable_hold_gestures(dev->libinput_device);
2485 litest_drain_events(dev->libinput);
2486
2487 /* one finger down, wait past tap timeout,
2488 second finger down, first finger up
2489 -> no event
2490 */
2491 litest_touch_down(dev, 0, 50, 50);
2492 litest_timeout_tap(li);
2493 litest_drain_events(dev->libinput);
2494
2495 litest_touch_down(dev, 1, 70, 50);
2496 litest_touch_up(dev, 0);
2497
2498 litest_assert_empty_queue(li);
2499 }
2500 END_TEST
2501
2502 START_TEST(touchpad_no_first_fg_tap_after_move)
2503 {
2504 struct litest_device *dev = litest_current_device();
2505 struct libinput *li = dev->libinput;
2506 struct libinput_event *event;
2507
2508 litest_enable_tap(dev->libinput_device);
2509 litest_disable_hold_gestures(dev->libinput_device);
2510 litest_drain_events(dev->libinput);
2511
2512 /* one finger down, second finger down,
2513 second finger moves beyond threshold,
2514 first finger up
2515 -> no event
2516 */
2517 litest_touch_down(dev, 0, 50, 50);
2518 litest_touch_down(dev, 1, 70, 50);
2519 litest_dispatch(dev->libinput);
2520 litest_touch_move_to(dev, 1, 70, 50, 90, 90, 10);
2521 litest_dispatch(dev->libinput);
2522 litest_touch_up(dev, 0);
2523 litest_touch_up(dev, 1);
2524 litest_dispatch(dev->libinput);
2525
2526 while ((event = libinput_get_event(li))) {
2527 litest_assert_event_type_not_one_of(event,
2528 LIBINPUT_EVENT_POINTER_BUTTON);
2529 libinput_event_destroy(event);
2530 }
2531 }
2532 END_TEST
2533
2534 START_TEST(touchpad_double_tap_click)
2535 {
2536 struct litest_device *dev = litest_current_device();
2537 struct libinput *li = dev->libinput;
2538 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
2539 unsigned int button = 0;
2540
2541 if (nfingers > litest_slot_count(dev))
2542 return LITEST_NOT_APPLICABLE;
2543
2544 litest_enable_tap(dev->libinput_device);
2545 litest_disable_hold_gestures(dev->libinput_device);
2546
2547 switch (nfingers) {
2548 case 1:
2549 button = BTN_LEFT;
2550 break;
2551 case 2:
2552 button = BTN_RIGHT;
2553 break;
2554 case 3:
2555 button = BTN_MIDDLE;
2556 break;
2557 default:
2558 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
2559 }
2560
2561 litest_drain_events(dev->libinput);
2562
2563 /* finger(s) down, up, one finger down, button click, finger up
2564 -> two button event pairs */
2565 switch (nfingers) {
2566 case 3:
2567 litest_touch_down(dev, 2, 60, 30);
2568 _fallthrough_;
2569 case 2:
2570 litest_touch_down(dev, 1, 50, 30);
2571 _fallthrough_;
2572 case 1:
2573 litest_touch_down(dev, 0, 40, 30);
2574 break;
2575 }
2576 switch (nfingers) {
2577 case 3:
2578 litest_touch_up(dev, 2);
2579 _fallthrough_;
2580 case 2:
2581 litest_touch_up(dev, 1);
2582 _fallthrough_;
2583 case 1:
2584 litest_touch_up(dev, 0);
2585 break;
2586 }
2587 litest_touch_down(dev, 0, 50, 50);
2588 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2589 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2590 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2591 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2592 litest_touch_up(dev, 0);
2593
2594 litest_dispatch(li);
2595
2596 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2597 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2598 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2599 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2600
2601 litest_assert_empty_queue(li);
2602 }
2603 END_TEST
2604
2605 START_TEST(touchpad_tap_n_drag_click)
2606 {
2607 struct litest_device *dev = litest_current_device();
2608 struct libinput *li = dev->libinput;
2609
2610 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
2611 unsigned int button = 0;
2612
2613 if (nfingers > litest_slot_count(dev))
2614 return LITEST_NOT_APPLICABLE;
2615
2616 litest_enable_tap(dev->libinput_device);
2617 litest_disable_hold_gestures(dev->libinput_device);
2618
2619 switch (nfingers) {
2620 case 1:
2621 button = BTN_LEFT;
2622 break;
2623 case 2:
2624 button = BTN_RIGHT;
2625 break;
2626 case 3:
2627 button = BTN_MIDDLE;
2628 break;
2629 default:
2630 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
2631 }
2632
2633 litest_drain_events(dev->libinput);
2634
2635 /* finger(s) down, up, one finger down, move, button click, finger up
2636 -> two button event pairs, motion allowed */
2637 switch (nfingers) {
2638 case 3:
2639 litest_touch_down(dev, 2, 60, 30);
2640 _fallthrough_;
2641 case 2:
2642 litest_touch_down(dev, 1, 50, 30);
2643 _fallthrough_;
2644 case 1:
2645 litest_touch_down(dev, 0, 40, 30);
2646 break;
2647 }
2648 switch (nfingers) {
2649 case 3:
2650 litest_touch_up(dev, 2);
2651 _fallthrough_;
2652 case 2:
2653 litest_touch_up(dev, 1);
2654 _fallthrough_;
2655 case 1:
2656 litest_touch_up(dev, 0);
2657 break;
2658 }
2659 litest_touch_down(dev, 0, 50, 50);
2660 litest_touch_move_to(dev, 0, 50, 50, 80, 50, 10);
2661
2662 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2663
2664 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
2665
2666 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2667 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2668
2669 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2670 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
2671
2672 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2673 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2674 litest_touch_up(dev, 0);
2675
2676 litest_dispatch(li);
2677
2678 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
2679
2680 litest_assert_empty_queue(li);
2681 }
2682 END_TEST
2683
2684 START_TEST(touchpad_3fg_tap)
2685 {
2686 struct litest_device *dev = litest_current_device();
2687 struct libinput *li = dev->libinput;
2688 unsigned int button = 0;
2689 int i;
2690
2691 enum libinput_config_tap_button_map map =
2692 litest_test_param_get_i32(test_env->params, "map");
2693
2694 if (litest_slot_count(dev) < 3)
2695 return LITEST_NOT_APPLICABLE;
2696
2697 litest_enable_tap(dev->libinput_device);
2698 litest_set_tap_map(dev->libinput_device, map);
2699 litest_disable_hold_gestures(dev->libinput_device);
2700
2701 switch (map) {
2702 case LIBINPUT_CONFIG_TAP_MAP_LRM:
2703 button = BTN_MIDDLE;
2704 break;
2705 case LIBINPUT_CONFIG_TAP_MAP_LMR:
2706 button = BTN_RIGHT;
2707 break;
2708 default:
2709 litest_abort_msg("Invalid map range %d", map);
2710 }
2711
2712 for (i = 0; i < 3; i++) {
2713 uint64_t ptime, rtime;
2714 struct libinput_event *ev;
2715 struct libinput_event_pointer *ptrev;
2716
2717 litest_drain_events(li);
2718
2719 litest_touch_down(dev, 0, 50, 50);
2720 msleep(5);
2721 litest_touch_down(dev, 1, 70, 50);
2722 msleep(5);
2723 litest_touch_down(dev, 2, 80, 50);
2724 msleep(10);
2725
2726 litest_touch_up(dev, (i + 2) % 3);
2727 litest_touch_up(dev, (i + 1) % 3);
2728 litest_touch_up(dev, (i + 0) % 3);
2729
2730 litest_timeout_tap(li);
2731
2732 ev = libinput_get_event(li);
2733 ptrev = litest_is_button_event(ev,
2734 button,
2735 LIBINPUT_BUTTON_STATE_PRESSED);
2736 ptime = libinput_event_pointer_get_time_usec(ptrev);
2737 libinput_event_destroy(ev);
2738 ev = libinput_get_event(li);
2739 ptrev = litest_is_button_event(ev,
2740 button,
2741 LIBINPUT_BUTTON_STATE_RELEASED);
2742 rtime = libinput_event_pointer_get_time_usec(ptrev);
2743 libinput_event_destroy(ev);
2744
2745 litest_assert_int_lt(ptime, rtime);
2746 }
2747 }
2748 END_TEST
2749
2750 START_TEST(touchpad_3fg_tap_tap_again)
2751 {
2752 struct litest_device *dev = litest_current_device();
2753 struct libinput *li = dev->libinput;
2754 int i;
2755
2756 if (litest_slot_count(dev) < 3)
2757 return LITEST_NOT_APPLICABLE;
2758
2759 litest_enable_tap(dev->libinput_device);
2760 litest_disable_hold_gestures(dev->libinput_device);
2761
2762 uint64_t ptime, rtime;
2763 struct libinput_event *ev;
2764 struct libinput_event_pointer *ptrev;
2765
2766 litest_drain_events(li);
2767
2768 litest_touch_down(dev, 0, 50, 50);
2769 msleep(5);
2770 litest_touch_down(dev, 1, 70, 50);
2771 msleep(5);
2772 litest_touch_down(dev, 2, 80, 50);
2773 msleep(10);
2774 litest_touch_up(dev, 0);
2775 msleep(10);
2776 litest_touch_down(dev, 0, 80, 50);
2777 msleep(10);
2778 litest_touch_up(dev, 0);
2779 litest_touch_up(dev, 1);
2780 litest_touch_up(dev, 2);
2781
2782 litest_timeout_tap(li);
2783
2784 for (i = 0; i < 2; i++) {
2785 ev = libinput_get_event(li);
2786 ptrev = litest_is_button_event(ev,
2787 BTN_MIDDLE,
2788 LIBINPUT_BUTTON_STATE_PRESSED);
2789 ptime = libinput_event_pointer_get_time_usec(ptrev);
2790 libinput_event_destroy(ev);
2791 ev = libinput_get_event(li);
2792 ptrev = litest_is_button_event(ev,
2793 BTN_MIDDLE,
2794 LIBINPUT_BUTTON_STATE_RELEASED);
2795 rtime = libinput_event_pointer_get_time_usec(ptrev);
2796 libinput_event_destroy(ev);
2797
2798 litest_assert_int_lt(ptime, rtime);
2799 }
2800 }
2801 END_TEST
2802
2803 START_TEST(touchpad_3fg_tap_quickrelease)
2804 {
2805 struct litest_device *dev = litest_current_device();
2806 struct libinput *li = dev->libinput;
2807
2808 if (litest_slot_count(dev) < 3)
2809 return LITEST_NOT_APPLICABLE;
2810
2811 litest_enable_tap(dev->libinput_device);
2812 litest_disable_hold_gestures(dev->libinput_device);
2813 litest_drain_events(li);
2814
2815 litest_touch_down(dev, 0, 50, 50);
2816 litest_touch_down(dev, 1, 70, 50);
2817 litest_touch_down(dev, 2, 80, 50);
2818 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
2819 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2820 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
2821 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2822 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
2823 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2824 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
2825 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
2826 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2827
2828 litest_dispatch(li);
2829
2830 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
2831 litest_timeout_tap(li);
2832 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_RELEASED);
2833
2834 litest_dispatch(li);
2835 litest_assert_empty_queue(li);
2836 }
2837 END_TEST
2838
2839 START_TEST(touchpad_3fg_tap_pressure_btntool)
2840 {
2841 struct litest_device *dev = litest_current_device();
2842 struct libinput *li = dev->libinput;
2843
2844 if (litest_slot_count(dev) >= 3 ||
2845 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
2846 return LITEST_NOT_APPLICABLE;
2847
2848 /* libinput doesn't export when it uses pressure detection, so we
2849 * need to reconstruct this here. Specifically, semi-mt devices are
2850 * non-mt in libinput, so if they have ABS_PRESSURE, they'll use it.
2851 */
2852 if (!libevdev_has_event_code(dev->evdev, EV_ABS, ABS_MT_PRESSURE))
2853 return LITEST_NOT_APPLICABLE;
2854
2855 litest_enable_tap(dev->libinput_device);
2856 litest_enable_edge_scroll(dev);
2857 litest_disable_hold_gestures(dev->libinput_device);
2858 litest_drain_events(li);
2859
2860 litest_touch_down(dev, 0, 50, 50);
2861 litest_touch_down(dev, 1, 70, 50);
2862
2863 litest_timeout_tap(li);
2864 litest_drain_events(li);
2865
2866 /* drop below the pressure threshold in the same frame as starting a
2867 * third touch, see
2868 * E: 8713.954784 0001 014e 0001 # EV_KEY / BTN_TOOL_TRIPLETAP 1
2869 * in https://bugs.freedesktop.org/attachment.cgi?id=137672
2870 */
2871 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 3);
2872 litest_event(dev, EV_ABS, ABS_PRESSURE, 3);
2873 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
2874 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
2875 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2876 litest_dispatch(li);
2877
2878 litest_push_event_frame(dev);
2879 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
2880 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
2881 litest_pop_event_frame(dev);
2882
2883 litest_touch_up(dev, 0);
2884 litest_touch_up(dev, 1);
2885 litest_timeout_tap(li);
2886
2887 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
2888 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_RELEASED);
2889 }
2890 END_TEST
2891
2892 START_TEST(touchpad_3fg_tap_hover_btntool)
2893 {
2894 struct litest_device *dev = litest_current_device();
2895 struct libinput *li = dev->libinput;
2896
2897 if (litest_slot_count(dev) >= 3 ||
2898 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
2899 return LITEST_NOT_APPLICABLE;
2900
2901 /* libinput doesn't export when it uses pressure detection, so we
2902 * need to reconstruct this here. Specifically, semi-mt devices are
2903 * non-mt in libinput, so if they have ABS_PRESSURE, they'll use it.
2904 */
2905 if (libevdev_has_event_code(dev->evdev, EV_ABS, ABS_MT_PRESSURE))
2906 return LITEST_NOT_APPLICABLE;
2907
2908 if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT) &&
2909 libevdev_has_event_code(dev->evdev, EV_ABS, ABS_PRESSURE))
2910 return LITEST_NOT_APPLICABLE;
2911
2912 litest_enable_tap(dev->libinput_device);
2913 litest_enable_edge_scroll(dev);
2914 litest_disable_hold_gestures(dev->libinput_device);
2915 litest_drain_events(li);
2916
2917 litest_touch_down(dev, 0, 50, 50);
2918 litest_touch_down(dev, 1, 70, 50);
2919 litest_dispatch(li);
2920
2921 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
2922 litest_touch_move_to(dev, 1, 70, 50, 50, 70, 10);
2923 litest_drain_events(li);
2924
2925 /* drop below the pressure threshold in the same frame as starting a
2926 * third touch */
2927 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
2928 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
2929 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
2930 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2931 litest_dispatch(li);
2932
2933 litest_push_event_frame(dev);
2934 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
2935 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
2936 litest_pop_event_frame(dev);
2937 litest_assert_empty_queue(li);
2938
2939 litest_touch_up(dev, 0);
2940 litest_touch_up(dev, 1);
2941 }
2942 END_TEST
2943
2944 START_TEST(touchpad_3fg_tap_btntool)
2945 {
2946 struct litest_device *dev = litest_current_device();
2947 struct libinput *li = dev->libinput;
2948 unsigned int button = 0;
2949
2950 enum libinput_config_tap_button_map map =
2951 litest_test_param_get_i32(test_env->params, "map");
2952
2953 if (litest_slot_count(dev) >= 3 ||
2954 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
2955 return LITEST_NOT_APPLICABLE;
2956
2957 litest_enable_tap(dev->libinput_device);
2958 litest_set_tap_map(dev->libinput_device, map);
2959 litest_disable_hold_gestures(dev->libinput_device);
2960
2961 switch (map) {
2962 case LIBINPUT_CONFIG_TAP_MAP_LRM:
2963 button = BTN_MIDDLE;
2964 break;
2965 case LIBINPUT_CONFIG_TAP_MAP_LMR:
2966 button = BTN_RIGHT;
2967 break;
2968 default:
2969 litest_abort_msg("Invalid map range %d", map);
2970 }
2971
2972 litest_drain_events(li);
2973
2974 litest_touch_down(dev, 0, 50, 50);
2975 litest_touch_down(dev, 1, 70, 50);
2976 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
2977 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
2978 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2979 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
2980 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
2981 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2982 litest_touch_up(dev, 1);
2983 litest_touch_up(dev, 0);
2984
2985 litest_dispatch(li);
2986
2987 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
2988 litest_timeout_tap(li);
2989 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
2990
2991 litest_assert_empty_queue(li);
2992 }
2993 END_TEST
2994
2995 START_TEST(touchpad_3fg_tap_btntool_inverted)
2996 {
2997 struct litest_device *dev = litest_current_device();
2998 struct libinput *li = dev->libinput;
2999 unsigned int button = 0;
3000
3001 enum libinput_config_tap_button_map map =
3002 litest_test_param_get_i32(test_env->params, "map");
3003
3004 if (litest_slot_count(dev) > 3 ||
3005 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
3006 return LITEST_NOT_APPLICABLE;
3007
3008 litest_enable_tap(dev->libinput_device);
3009 litest_set_tap_map(dev->libinput_device, map);
3010 litest_disable_hold_gestures(dev->libinput_device);
3011
3012 switch (map) {
3013 case LIBINPUT_CONFIG_TAP_MAP_LRM:
3014 button = BTN_MIDDLE;
3015 break;
3016 case LIBINPUT_CONFIG_TAP_MAP_LMR:
3017 button = BTN_RIGHT;
3018 break;
3019 default:
3020 litest_abort_msg("invalid map range %d", map);
3021 }
3022
3023 litest_drain_events(li);
3024
3025 litest_touch_down(dev, 0, 50, 50);
3026 litest_touch_down(dev, 1, 70, 50);
3027 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
3028 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
3029 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3030 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
3031 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
3032 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3033 litest_touch_up(dev, 0);
3034 litest_touch_up(dev, 1);
3035
3036 litest_dispatch(li);
3037
3038 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3039 litest_timeout_tap(li);
3040 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3041
3042 litest_assert_empty_queue(li);
3043 }
3044 END_TEST
3045
3046 START_TEST(touchpad_3fg_tap_btntool_pointerjump)
3047 {
3048 struct litest_device *dev = litest_current_device();
3049 struct libinput *li = dev->libinput;
3050 unsigned int button = 0;
3051
3052 enum libinput_config_tap_button_map map =
3053 litest_test_param_get_i32(test_env->params, "map");
3054
3055 if (litest_slot_count(dev) > 3 ||
3056 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
3057 return LITEST_NOT_APPLICABLE;
3058
3059 litest_enable_tap(dev->libinput_device);
3060 litest_set_tap_map(dev->libinput_device, map);
3061 litest_disable_hold_gestures(dev->libinput_device);
3062
3063 switch (map) {
3064 case LIBINPUT_CONFIG_TAP_MAP_LRM:
3065 button = BTN_MIDDLE;
3066 break;
3067 case LIBINPUT_CONFIG_TAP_MAP_LMR:
3068 button = BTN_RIGHT;
3069 break;
3070 default:
3071 litest_abort_msg("Invalid map range %d", map);
3072 }
3073
3074 litest_drain_events(li);
3075
3076 litest_touch_down(dev, 0, 50, 50);
3077 litest_touch_down(dev, 1, 70, 50);
3078 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
3079 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
3080 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3081 /* Pointer jump should be ignored */
3082 litest_touch_move_to(dev, 0, 50, 50, 20, 20, 0);
3083 litest_dispatch(li);
3084 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
3085 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
3086 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3087 litest_touch_up(dev, 1);
3088 litest_touch_up(dev, 0);
3089
3090 litest_dispatch(li);
3091
3092 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3093 litest_timeout_tap(li);
3094 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3095
3096 litest_assert_empty_queue(li);
3097 }
3098 END_TEST
3099
3100 START_TEST(touchpad_3fg_tap_slot_release_btntool)
3101 {
3102 struct litest_device *dev = litest_current_device();
3103 struct libinput *li = dev->libinput;
3104
3105 /* Synaptics touchpads sometimes end one touch point after
3106 * setting BTN_TOOL_TRIPLETAP.
3107 * https://gitlab.freedesktop.org/libinput/libinput/issues/99
3108 */
3109 litest_drain_events(li);
3110 litest_enable_tap(dev->libinput_device);
3111 litest_disable_hold_gestures(dev->libinput_device);
3112
3113 /* touch 1 down */
3114 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3115 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 1);
3116 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2200);
3117 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3200);
3118 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
3119 litest_event(dev, EV_ABS, ABS_X, 2200);
3120 litest_event(dev, EV_ABS, ABS_Y, 3200);
3121 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
3122 litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
3123 litest_event(dev, EV_KEY, BTN_TOUCH, 1);
3124 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3125 litest_dispatch(li);
3126 msleep(2);
3127
3128 /* touch 2 and TRIPLETAP down */
3129 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3130 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 1);
3131 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
3132 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
3133 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 73);
3134 litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
3135 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
3136 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3137 litest_dispatch(li);
3138 msleep(2);
3139
3140 /* touch 2 up, coordinate jump + ends slot 1, TRIPLETAP stays */
3141 litest_disable_log_handler(li);
3142 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3143 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
3144 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
3145 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
3146 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3147 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3148 litest_event(dev, EV_ABS, ABS_X, 2500);
3149 litest_event(dev, EV_ABS, ABS_Y, 3800);
3150 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
3151 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3152 litest_dispatch(li);
3153 msleep(2);
3154
3155 /* slot 2 reactivated
3156 */
3157 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3158 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
3159 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
3160 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
3161 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3162 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 3);
3163 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 3500);
3164 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3500);
3165 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 73);
3166 litest_event(dev, EV_ABS, ABS_X, 2200);
3167 litest_event(dev, EV_ABS, ABS_Y, 3200);
3168 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
3169 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3170 litest_dispatch(li);
3171 litest_restore_log_handler(li);
3172
3173 /* now end all three */
3174 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3175 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3176 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3177 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3178 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
3179 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
3180 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3181 litest_timeout_tap(li);
3182
3183 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
3184 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_RELEASED);
3185
3186 litest_assert_empty_queue(li);
3187 }
3188 END_TEST
3189
3190 START_TEST(touchpad_3fg_tap_after_scroll)
3191 {
3192 struct litest_device *dev = litest_current_device();
3193 struct libinput *li = dev->libinput;
3194
3195 if (litest_slot_count(dev) <= 3)
3196 return LITEST_NOT_APPLICABLE;
3197
3198 litest_enable_2fg_scroll(dev);
3199 litest_enable_tap(dev->libinput_device);
3200 litest_disable_hold_gestures(dev->libinput_device);
3201
3202 litest_touch_down(dev, 0, 40, 20);
3203 litest_touch_down(dev, 1, 50, 20);
3204 litest_drain_events(li);
3205
3206 /* 2fg scroll */
3207 litest_touch_move_two_touches(dev, 40, 20, 50, 20, 0, 20, 10);
3208 litest_drain_events(li);
3209
3210 litest_timeout_tap(li);
3211
3212 /* third finger tap without the other two fingers moving */
3213 litest_touch_down(dev, 2, 60, 40);
3214 litest_dispatch(li);
3215 litest_touch_up(dev, 2);
3216 litest_dispatch(li);
3217
3218 litest_timeout_tap(li);
3219
3220 litest_assert_empty_queue(li);
3221 }
3222 END_TEST
3223
3224 START_TEST(touchpad_4fg_tap)
3225 {
3226 struct litest_device *dev = litest_current_device();
3227 struct libinput *li = dev->libinput;
3228 int i;
3229
3230 if (litest_slot_count(dev) <= 4)
3231 return LITEST_NOT_APPLICABLE;
3232
3233 litest_enable_tap(dev->libinput_device);
3234 litest_disable_hold_gestures(dev->libinput_device);
3235
3236 for (i = 0; i < 4; i++) {
3237 litest_drain_events(li);
3238
3239 litest_touch_down(dev, 0, 50, 50);
3240 litest_touch_down(dev, 1, 70, 50);
3241 litest_touch_down(dev, 2, 80, 50);
3242 litest_touch_down(dev, 3, 90, 50);
3243
3244 litest_touch_up(dev, (i + 3) % 4);
3245 litest_touch_up(dev, (i + 2) % 4);
3246 litest_touch_up(dev, (i + 1) % 4);
3247 litest_touch_up(dev, (i + 0) % 4);
3248
3249 litest_dispatch(li);
3250 litest_assert_empty_queue(li);
3251 litest_timeout_tap(li);
3252 litest_assert_empty_queue(li);
3253 }
3254 }
3255 END_TEST
3256
3257 START_TEST(touchpad_4fg_tap_quickrelease)
3258 {
3259 struct litest_device *dev = litest_current_device();
3260 struct libinput *li = dev->libinput;
3261
3262 if (litest_slot_count(dev) <= 4)
3263 return LITEST_NOT_APPLICABLE;
3264
3265 litest_enable_tap(dev->libinput_device);
3266 litest_disable_hold_gestures(dev->libinput_device);
3267 litest_drain_events(li);
3268
3269 litest_touch_down(dev, 0, 50, 50);
3270 litest_touch_down(dev, 1, 70, 50);
3271 litest_touch_down(dev, 2, 80, 50);
3272 litest_touch_down(dev, 3, 90, 50);
3273
3274 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3275 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3276 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3277 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3278 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
3279 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3280 litest_event(dev, EV_ABS, ABS_MT_SLOT, 3);
3281 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3282 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0);
3283 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
3284 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3285
3286 litest_dispatch(li);
3287 litest_assert_empty_queue(li);
3288 litest_timeout_tap(li);
3289 litest_assert_empty_queue(li);
3290 }
3291 END_TEST
3292
3293 START_TEST(touchpad_move_after_touch)
3294 {
3295 struct litest_device *dev = litest_current_device();
3296 struct libinput *li = dev->libinput;
3297 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
3298
3299 if (nfingers > litest_slot_count(dev))
3300 return LITEST_NOT_APPLICABLE;
3301
3302 litest_enable_tap(dev->libinput_device);
3303 litest_disable_hold_gestures(dev->libinput_device);
3304 litest_drain_events(li);
3305
3306 /* respective number of fingers down */
3307 switch (nfingers) {
3308 case 5:
3309 litest_touch_down(dev, 4, 80, 30);
3310 _fallthrough_;
3311 case 4:
3312 litest_touch_down(dev, 3, 70, 30);
3313 _fallthrough_;
3314 case 3:
3315 litest_touch_down(dev, 2, 60, 30);
3316 _fallthrough_;
3317 case 2:
3318 litest_touch_down(dev, 1, 50, 30);
3319 _fallthrough_;
3320 case 1:
3321 litest_touch_down(dev, 0, 40, 30);
3322 break;
3323 default:
3324 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
3325 }
3326
3327 /* move finger 1 */
3328 litest_dispatch(li);
3329 litest_touch_move_to(dev, 0, 40, 30, 70, 60, 10);
3330 litest_dispatch(li);
3331
3332 /* lift finger 1, put it back */
3333 litest_touch_up(dev, 0);
3334 litest_dispatch(li);
3335 litest_touch_down(dev, 0, 40, 30);
3336 litest_dispatch(li);
3337
3338 /* lift fingers up */
3339 switch (nfingers) {
3340 case 5:
3341 litest_touch_up(dev, 4);
3342 _fallthrough_;
3343 case 4:
3344 litest_touch_up(dev, 3);
3345 _fallthrough_;
3346 case 3:
3347 litest_touch_up(dev, 2);
3348 _fallthrough_;
3349 case 2:
3350 litest_touch_up(dev, 1);
3351 _fallthrough_;
3352 case 1:
3353 litest_touch_up(dev, 0);
3354 break;
3355 }
3356 litest_timeout_tap(li);
3357
3358 litest_assert_no_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
3359 }
3360 END_TEST
3361
3362 START_TEST(touchpad_5fg_tap)
3363 {
3364 struct litest_device *dev = litest_current_device();
3365 struct libinput *li = dev->libinput;
3366 int i;
3367
3368 if (litest_slot_count(dev) < 5)
3369 return LITEST_NOT_APPLICABLE;
3370
3371 litest_enable_tap(dev->libinput_device);
3372 litest_disable_hold_gestures(dev->libinput_device);
3373
3374 for (i = 0; i < 5; i++) {
3375 litest_drain_events(li);
3376
3377 litest_touch_down(dev, 0, 20, 50);
3378 litest_touch_down(dev, 1, 30, 50);
3379 litest_touch_down(dev, 2, 40, 50);
3380 litest_touch_down(dev, 3, 50, 50);
3381 litest_touch_down(dev, 4, 60, 50);
3382
3383 litest_touch_up(dev, (i + 4) % 5);
3384 litest_touch_up(dev, (i + 3) % 5);
3385 litest_touch_up(dev, (i + 2) % 5);
3386 litest_touch_up(dev, (i + 1) % 5);
3387 litest_touch_up(dev, (i + 0) % 5);
3388
3389 litest_dispatch(li);
3390 litest_assert_empty_queue(li);
3391 litest_timeout_tap(li);
3392 litest_assert_empty_queue(li);
3393 }
3394 }
3395 END_TEST
3396
3397 START_TEST(touchpad_5fg_tap_quickrelease)
3398 {
3399 struct litest_device *dev = litest_current_device();
3400 struct libinput *li = dev->libinput;
3401
3402 if (litest_slot_count(dev) < 5)
3403 return LITEST_NOT_APPLICABLE;
3404
3405 litest_enable_tap(dev->libinput_device);
3406 litest_disable_hold_gestures(dev->libinput_device);
3407 litest_drain_events(li);
3408
3409 litest_touch_down(dev, 0, 20, 50);
3410 litest_touch_down(dev, 1, 30, 50);
3411 litest_touch_down(dev, 2, 40, 50);
3412 litest_touch_down(dev, 3, 70, 50);
3413 litest_touch_down(dev, 4, 90, 50);
3414
3415 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
3416 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3417 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
3418 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3419 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
3420 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3421 litest_event(dev, EV_ABS, ABS_MT_SLOT, 3);
3422 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3423 litest_event(dev, EV_ABS, ABS_MT_SLOT, 4);
3424 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
3425 litest_event(dev, EV_KEY, BTN_TOOL_QUINTTAP, 0);
3426 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
3427 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3428
3429 litest_dispatch(li);
3430 litest_assert_empty_queue(li);
3431 litest_timeout_tap(li);
3432 litest_assert_empty_queue(li);
3433 }
3434 END_TEST
3435
3436 START_TEST(clickpad_1fg_tap_click)
3437 {
3438 struct litest_device *dev = litest_current_device();
3439 struct libinput *li = dev->libinput;
3440
3441 litest_enable_tap(dev->libinput_device);
3442 litest_disable_hold_gestures(dev->libinput_device);
3443 litest_drain_events(dev->libinput);
3444
3445 /* finger down, button click, finger up
3446 -> only one button left event pair */
3447 litest_touch_down(dev, 0, 50, 50);
3448 litest_event(dev, EV_KEY, BTN_LEFT, 1);
3449 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3450 litest_event(dev, EV_KEY, BTN_LEFT, 0);
3451 litest_event(dev, EV_SYN, SYN_REPORT, 0);
3452 litest_touch_up(dev, 0);
3453 litest_timeout_tap(li);
3454
3455 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
3456 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
3457
3458 litest_assert_empty_queue(li);
3459 }
3460 END_TEST
3461
3462 START_TEST(touchpad_tap_is_available)
3463 {
3464 struct litest_device *dev = litest_current_device();
3465
3466 litest_assert_int_ge(
3467 libinput_device_config_tap_get_finger_count(dev->libinput_device),
3468 1);
3469 }
3470 END_TEST
3471
3472 START_TEST(touchpad_tap_is_not_available)
3473 {
3474 struct litest_device *dev = litest_current_device();
3475
3476 litest_assert_int_eq(
3477 libinput_device_config_tap_get_finger_count(dev->libinput_device),
3478 0);
3479 litest_assert_enum_eq(
3480 libinput_device_config_tap_get_enabled(dev->libinput_device),
3481 LIBINPUT_CONFIG_TAP_DISABLED);
3482 litest_assert_enum_eq(
3483 libinput_device_config_tap_set_enabled(dev->libinput_device,
3484 LIBINPUT_CONFIG_TAP_ENABLED),
3485 LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3486 litest_assert_enum_eq(
3487 libinput_device_config_tap_set_enabled(dev->libinput_device,
3488 LIBINPUT_CONFIG_TAP_DISABLED),
3489 LIBINPUT_CONFIG_STATUS_SUCCESS);
3490 }
3491 END_TEST
3492
3493 START_TEST(touchpad_tap_default_disabled)
3494 {
3495 struct litest_device *dev = litest_current_device();
3496
3497 /* this test is only run on specific devices */
3498
3499 litest_assert_enum_eq(
3500 libinput_device_config_tap_get_enabled(dev->libinput_device),
3501 LIBINPUT_CONFIG_TAP_DISABLED);
3502 litest_assert_enum_eq(
3503 libinput_device_config_tap_get_default_enabled(dev->libinput_device),
3504 LIBINPUT_CONFIG_TAP_DISABLED);
3505 }
3506 END_TEST
3507
3508 START_TEST(touchpad_tap_default_enabled)
3509 {
3510 struct litest_device *dev = litest_current_device();
3511
3512 /* this test is only run on specific devices */
3513
3514 litest_assert_enum_eq(
3515 libinput_device_config_tap_get_enabled(dev->libinput_device),
3516 LIBINPUT_CONFIG_TAP_ENABLED);
3517 litest_assert_enum_eq(
3518 libinput_device_config_tap_get_default_enabled(dev->libinput_device),
3519 LIBINPUT_CONFIG_TAP_ENABLED);
3520 }
3521 END_TEST
3522
3523 START_TEST(touchpad_tap_invalid)
3524 {
3525 struct litest_device *dev = litest_current_device();
3526
3527 litest_assert_enum_eq(
3528 libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
3529 LIBINPUT_CONFIG_STATUS_INVALID);
3530 litest_assert_enum_eq(
3531 libinput_device_config_tap_set_enabled(dev->libinput_device, -1),
3532 LIBINPUT_CONFIG_STATUS_INVALID);
3533 }
3534 END_TEST
3535
3536 START_TEST(touchpad_tap_default_map)
3537 {
3538 struct litest_device *dev = litest_current_device();
3539 enum libinput_config_tap_button_map map;
3540
3541 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
3542 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3543
3544 map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
3545 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3546 }
3547 END_TEST
3548
3549 START_TEST(touchpad_tap_map_unsupported)
3550 {
3551 struct litest_device *dev = litest_current_device();
3552 enum libinput_config_tap_button_map map;
3553 enum libinput_config_status status;
3554
3555 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
3556 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3557 map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
3558 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3559
3560 status = libinput_device_config_tap_set_button_map(dev->libinput_device,
3561 LIBINPUT_CONFIG_TAP_MAP_LMR);
3562 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3563 status = libinput_device_config_tap_set_button_map(dev->libinput_device,
3564 LIBINPUT_CONFIG_TAP_MAP_LRM);
3565 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3566 }
3567 END_TEST
3568
3569 START_TEST(touchpad_tap_set_map)
3570 {
3571 struct litest_device *dev = litest_current_device();
3572 struct libinput_device *device = dev->libinput_device;
3573 enum libinput_config_tap_button_map map;
3574 enum libinput_config_status status;
3575
3576 map = LIBINPUT_CONFIG_TAP_MAP_LRM;
3577 status = libinput_device_config_tap_set_button_map(device, map);
3578 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
3579 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
3580 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3581
3582 map = LIBINPUT_CONFIG_TAP_MAP_LMR;
3583 status = libinput_device_config_tap_set_button_map(device, map);
3584 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
3585 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
3586 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
3587
3588 map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
3589 status = libinput_device_config_tap_set_button_map(device, map);
3590 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
3591
3592 map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
3593 status = libinput_device_config_tap_set_button_map(device, map);
3594 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
3595 }
3596 END_TEST
3597
3598 START_TEST(touchpad_tap_set_map_no_tapping)
3599 {
3600 struct litest_device *dev = litest_current_device();
3601 struct libinput_device *device = dev->libinput_device;
3602 enum libinput_config_tap_button_map map;
3603 enum libinput_config_status status;
3604
3605 map = LIBINPUT_CONFIG_TAP_MAP_LRM;
3606 status = libinput_device_config_tap_set_button_map(device, map);
3607 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3608
3609 map = LIBINPUT_CONFIG_TAP_MAP_LMR;
3610 status = libinput_device_config_tap_set_button_map(device, map);
3611 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3612
3613 map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
3614 status = libinput_device_config_tap_set_button_map(device, map);
3615 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
3616
3617 map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
3618 status = libinput_device_config_tap_set_button_map(device, map);
3619 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
3620 }
3621 END_TEST
3622
3623 START_TEST(touchpad_tap_get_map_no_tapping)
3624 {
3625 struct litest_device *dev = litest_current_device();
3626 struct libinput_device *device = dev->libinput_device;
3627 enum libinput_config_tap_button_map map;
3628
3629 map = libinput_device_config_tap_get_button_map(device);
3630 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3631
3632 map = libinput_device_config_tap_get_default_button_map(device);
3633 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
3634 }
3635 END_TEST
3636
3637 START_TEST(touchpad_tap_map_delayed)
3638 {
3639 struct litest_device *dev = litest_current_device();
3640 struct libinput *li = dev->libinput;
3641 enum libinput_config_tap_button_map map;
3642
3643 litest_enable_tap(dev->libinput_device);
3644 litest_set_tap_map(dev->libinput_device, LIBINPUT_CONFIG_TAP_MAP_LRM);
3645 litest_disable_hold_gestures(dev->libinput_device);
3646 litest_drain_events(dev->libinput);
3647
3648 litest_touch_down(dev, 0, 50, 50);
3649 litest_touch_down(dev, 1, 70, 70);
3650 litest_dispatch(li);
3651
3652 litest_set_tap_map(dev->libinput_device, LIBINPUT_CONFIG_TAP_MAP_LMR);
3653 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
3654 litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
3655
3656 litest_touch_up(dev, 0);
3657 litest_touch_up(dev, 1);
3658
3659 litest_dispatch(li);
3660
3661 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
3662 litest_timeout_tap(li);
3663 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
3664
3665 litest_assert_empty_queue(li);
3666 }
3667 END_TEST
3668
3669 START_TEST(touchpad_drag_default_disabled)
3670 {
3671 struct litest_device *dev = litest_current_device();
3672
3673 /* this test is only run on specific devices */
3674
3675 litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(
3676 dev->libinput_device),
3677 LIBINPUT_CONFIG_DRAG_DISABLED);
3678 litest_assert_enum_eq(
3679 libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
3680 LIBINPUT_CONFIG_DRAG_DISABLED);
3681 }
3682 END_TEST
3683
3684 START_TEST(touchpad_drag_default_enabled)
3685 {
3686 struct litest_device *dev = litest_current_device();
3687
3688 /* this test is only run on specific devices */
3689
3690 litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(
3691 dev->libinput_device),
3692 LIBINPUT_CONFIG_DRAG_ENABLED);
3693 litest_assert_enum_eq(
3694 libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
3695 LIBINPUT_CONFIG_DRAG_ENABLED);
3696 }
3697 END_TEST
3698
3699 START_TEST(touchpad_drag_config_invalid)
3700 {
3701 struct litest_device *dev = litest_current_device();
3702
3703 litest_assert_enum_eq(
3704 libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
3705 LIBINPUT_CONFIG_STATUS_INVALID);
3706 litest_assert_enum_eq(
3707 libinput_device_config_tap_set_drag_enabled(dev->libinput_device, -1),
3708 LIBINPUT_CONFIG_STATUS_INVALID);
3709 }
3710 END_TEST
3711
3712 START_TEST(touchpad_drag_config_unsupported)
3713 {
3714 struct litest_device *dev = litest_current_device();
3715 enum libinput_config_status status;
3716
3717 litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(
3718 dev->libinput_device),
3719 LIBINPUT_CONFIG_DRAG_DISABLED);
3720 litest_assert_enum_eq(
3721 libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
3722 LIBINPUT_CONFIG_DRAG_DISABLED);
3723 status = libinput_device_config_tap_set_drag_enabled(
3724 dev->libinput_device,
3725 LIBINPUT_CONFIG_DRAG_ENABLED);
3726 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
3727 status = libinput_device_config_tap_set_drag_enabled(
3728 dev->libinput_device,
3729 LIBINPUT_CONFIG_DRAG_DISABLED);
3730 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
3731 }
3732 END_TEST
3733
3734 START_TEST(touchpad_drag_config_enabledisable)
3735 {
3736 struct litest_device *dev = litest_current_device();
3737 enum libinput_config_drag_state state;
3738
3739 litest_disable_hold_gestures(dev->libinput_device);
3740
3741 litest_enable_tap(dev->libinput_device);
3742
3743 litest_disable_tap_drag(dev->libinput_device);
3744 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
3745 litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
3746
3747 litest_enable_tap_drag(dev->libinput_device);
3748 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
3749 litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
3750
3751 /* same thing with tapping disabled */
3752 litest_enable_tap(dev->libinput_device);
3753
3754 litest_disable_tap_drag(dev->libinput_device);
3755 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
3756 litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
3757
3758 litest_enable_tap_drag(dev->libinput_device);
3759 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
3760 litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
3761 }
3762 END_TEST
3763
3764 START_TEST(touchpad_drag_disabled)
3765 {
3766 struct litest_device *dev = litest_current_device();
3767 struct libinput *li = dev->libinput;
3768 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
3769 unsigned int button = 0;
3770
3771 if (nfingers > litest_slot_count(dev))
3772 return LITEST_NOT_APPLICABLE;
3773
3774 litest_enable_tap(dev->libinput_device);
3775 litest_disable_tap_drag(dev->libinput_device);
3776 litest_disable_hold_gestures(dev->libinput_device);
3777
3778 switch (nfingers) {
3779 case 1:
3780 button = BTN_LEFT;
3781 break;
3782 case 2:
3783 button = BTN_RIGHT;
3784 break;
3785 case 3:
3786 button = BTN_MIDDLE;
3787 break;
3788 default:
3789 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
3790 }
3791
3792 litest_drain_events(li);
3793
3794 switch (nfingers) {
3795 case 3:
3796 litest_touch_down(dev, 2, 60, 30);
3797 _fallthrough_;
3798 case 2:
3799 litest_touch_down(dev, 1, 50, 30);
3800 _fallthrough_;
3801 case 1:
3802 litest_touch_down(dev, 0, 40, 30);
3803 break;
3804 }
3805 /* lift fingers up */
3806 switch (nfingers) {
3807 case 3:
3808 litest_touch_up(dev, 2);
3809 _fallthrough_;
3810 case 2:
3811 litest_touch_up(dev, 1);
3812 _fallthrough_;
3813 case 1:
3814 litest_touch_up(dev, 0);
3815 break;
3816 }
3817
3818 litest_dispatch(li);
3819 litest_touch_down(dev, 0, 50, 50);
3820 litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10);
3821 litest_touch_up(dev, 0);
3822 litest_dispatch(li);
3823
3824 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
3825 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
3826 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
3827 }
3828 END_TEST
3829
3830 START_TEST(touchpad_drag_disabled_immediate)
3831 {
3832 struct litest_device *dev = litest_current_device();
3833 struct libinput *li = dev->libinput;
3834 struct libinput_event *ev;
3835 struct libinput_event_pointer *ptrev;
3836 uint64_t press_time, release_time;
3837 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
3838 unsigned int button = 0;
3839
3840 if (nfingers > litest_slot_count(dev))
3841 return LITEST_NOT_APPLICABLE;
3842
3843 litest_enable_tap(dev->libinput_device);
3844 litest_disable_tap_drag(dev->libinput_device);
3845 litest_disable_hold_gestures(dev->libinput_device);
3846
3847 switch (nfingers) {
3848 case 1:
3849 button = BTN_LEFT;
3850 break;
3851 case 2:
3852 button = BTN_RIGHT;
3853 break;
3854 case 3:
3855 button = BTN_MIDDLE;
3856 break;
3857 default:
3858 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
3859 }
3860
3861 litest_drain_events(li);
3862
3863 switch (nfingers) {
3864 case 3:
3865 litest_touch_down(dev, 2, 60, 30);
3866 _fallthrough_;
3867 case 2:
3868 litest_touch_down(dev, 1, 50, 30);
3869 _fallthrough_;
3870 case 1:
3871 litest_touch_down(dev, 0, 40, 30);
3872 break;
3873 }
3874 msleep(10); /* to force a time difference */
3875 litest_dispatch(li);
3876 switch (nfingers) {
3877 case 3:
3878 litest_touch_up(dev, 2);
3879 _fallthrough_;
3880 case 2:
3881 litest_touch_up(dev, 1);
3882 _fallthrough_;
3883 case 1:
3884 litest_touch_up(dev, 0);
3885 break;
3886 }
3887 litest_dispatch(li);
3888
3889 ev = libinput_get_event(li);
3890 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_PRESSED);
3891 press_time = libinput_event_pointer_get_time(ptrev);
3892 libinput_event_destroy(ev);
3893
3894 ev = libinput_get_event(li);
3895 ptrev = litest_is_button_event(ev, button, LIBINPUT_BUTTON_STATE_RELEASED);
3896 release_time = libinput_event_pointer_get_time(ptrev);
3897 libinput_event_destroy(ev);
3898
3899 litest_assert_int_gt(release_time, press_time);
3900 }
3901 END_TEST
3902
3903 START_TEST(touchpad_drag_disabled_multitap_no_drag)
3904 {
3905 struct litest_device *dev = litest_current_device();
3906 struct libinput *li = dev->libinput;
3907 struct libinput_event *event;
3908 struct libinput_event_pointer *ptrev;
3909 uint32_t oldtime = 0, curtime;
3910 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
3911 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
3912 unsigned int button = 0;
3913
3914 if (nfingers > litest_slot_count(dev))
3915 return LITEST_NOT_APPLICABLE;
3916
3917 litest_enable_tap(dev->libinput_device);
3918 litest_disable_tap_drag(dev->libinput_device);
3919 litest_disable_hold_gestures(dev->libinput_device);
3920
3921 switch (nfingers) {
3922 case 1:
3923 button = BTN_LEFT;
3924 break;
3925 case 2:
3926 button = BTN_RIGHT;
3927 break;
3928 case 3:
3929 button = BTN_MIDDLE;
3930 break;
3931 default:
3932 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
3933 }
3934
3935 litest_drain_events(li);
3936
3937 for (ntaps = 0; ntaps <= range; ntaps++) {
3938 switch (nfingers) {
3939 case 3:
3940 litest_touch_down(dev, 2, 60, 30);
3941 _fallthrough_;
3942 case 2:
3943 litest_touch_down(dev, 1, 50, 30);
3944 _fallthrough_;
3945 case 1:
3946 litest_touch_down(dev, 0, 40, 30);
3947 break;
3948 }
3949 switch (nfingers) {
3950 case 3:
3951 litest_touch_up(dev, 2);
3952 _fallthrough_;
3953 case 2:
3954 litest_touch_up(dev, 1);
3955 _fallthrough_;
3956 case 1:
3957 litest_touch_up(dev, 0);
3958 break;
3959 }
3960
3961 litest_dispatch(li);
3962 msleep(10);
3963 }
3964
3965 litest_dispatch(li);
3966 litest_touch_down(dev, 0, 50, 50);
3967 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
3968 litest_dispatch(li);
3969
3970 for (ntaps = 0; ntaps <= range; ntaps++) {
3971 event = libinput_get_event(li);
3972 ptrev = litest_is_button_event(event,
3973 button,
3974 LIBINPUT_BUTTON_STATE_PRESSED);
3975 curtime = libinput_event_pointer_get_time(ptrev);
3976 libinput_event_destroy(event);
3977 litest_assert_int_gt(curtime, oldtime);
3978
3979 event = libinput_get_event(li);
3980 ptrev = litest_is_button_event(event,
3981 button,
3982 LIBINPUT_BUTTON_STATE_RELEASED);
3983 curtime = libinput_event_pointer_get_time(ptrev);
3984 libinput_event_destroy(event);
3985 litest_assert_int_ge(curtime, oldtime);
3986 oldtime = curtime;
3987 }
3988
3989 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
3990 litest_assert_empty_queue(li);
3991 }
3992 END_TEST
3993
3994 START_TEST(touchpad_drag_lock_default_disabled)
3995 {
3996 struct litest_device *dev = litest_current_device();
3997 struct libinput_device *device = dev->libinput_device;
3998 enum libinput_config_status status;
3999
4000 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4001 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4002 litest_assert_enum_eq(
4003 libinput_device_config_tap_get_default_drag_lock_enabled(device),
4004 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4005
4006 status = libinput_device_config_tap_set_drag_lock_enabled(
4007 device,
4008 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
4009 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
4010 /* ENABLED is a legacy spelling for ENABLED_TIMEOUT */
4011 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4012 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
4013
4014 status = libinput_device_config_tap_set_drag_lock_enabled(
4015 device,
4016 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4017 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
4018 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4019 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4020
4021 status = libinput_device_config_tap_set_drag_lock_enabled(
4022 device,
4023 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
4024 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
4025 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4026 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
4027
4028 status = libinput_device_config_tap_set_drag_lock_enabled(
4029 device,
4030 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
4031 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
4032 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4033 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
4034
4035 status = libinput_device_config_tap_set_drag_lock_enabled(device, 3);
4036 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
4037 }
4038 END_TEST
4039
4040 START_TEST(touchpad_drag_lock_default_unavailable)
4041 {
4042 struct litest_device *dev = litest_current_device();
4043 struct libinput_device *device = dev->libinput_device;
4044 enum libinput_config_status status;
4045
4046 litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
4047 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4048 litest_assert_enum_eq(
4049 libinput_device_config_tap_get_default_drag_lock_enabled(device),
4050 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4051
4052 status = libinput_device_config_tap_set_drag_lock_enabled(
4053 device,
4054 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
4055 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
4056
4057 status = libinput_device_config_tap_set_drag_lock_enabled(
4058 device,
4059 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
4060 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
4061
4062 status = libinput_device_config_tap_set_drag_lock_enabled(
4063 device,
4064 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
4065 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
4066
4067 status = libinput_device_config_tap_set_drag_lock_enabled(
4068 device,
4069 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
4070 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
4071
4072 status = libinput_device_config_tap_set_drag_lock_enabled(device, 3);
4073 litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
4074 }
4075 END_TEST
4076
4077 static inline bool
4078 touchpad_has_palm_pressure(struct litest_device *dev)
4079 {
4080 struct libevdev *evdev = dev->evdev;
4081
4082 if (dev->which == LITEST_SYNAPTICS_PRESSUREPAD)
4083 return false;
4084
4085 if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_PRESSURE))
4086 return libevdev_get_abs_resolution(evdev, ABS_MT_PRESSURE) == 0;
4087
4088 return false;
4089 }
4090
4091 START_TEST(touchpad_tap_palm_on_idle)
4092 {
4093 struct litest_device *dev = litest_current_device();
4094 struct libinput *li = dev->libinput;
4095 struct axis_replacement axes[] = {
4096 { ABS_MT_PRESSURE, 75 },
4097 { -1, 0 },
4098 };
4099
4100 if (!touchpad_has_palm_pressure(dev))
4101 return LITEST_NOT_APPLICABLE;
4102
4103 litest_enable_tap(dev->libinput_device);
4104 litest_disable_hold_gestures(dev->libinput_device);
4105 litest_drain_events(li);
4106
4107 /* Finger down is immediately palm */
4108
4109 litest_touch_down_extended(dev, 0, 50, 50, axes);
4110 litest_touch_up(dev, 0);
4111
4112 litest_dispatch(li);
4113
4114 litest_assert_empty_queue(li);
4115 }
4116 END_TEST
4117
4118 START_TEST(touchpad_tap_palm_on_touch)
4119 {
4120 struct litest_device *dev = litest_current_device();
4121 struct libinput *li = dev->libinput;
4122 struct axis_replacement axes[] = {
4123 { ABS_MT_PRESSURE, 75 },
4124 { -1, 0 },
4125 };
4126
4127 if (!touchpad_has_palm_pressure(dev))
4128 return LITEST_NOT_APPLICABLE;
4129
4130 litest_enable_tap(dev->libinput_device);
4131 litest_disable_hold_gestures(dev->libinput_device);
4132 litest_drain_events(li);
4133
4134 /* Finger down is palm after touch begin */
4135
4136 litest_touch_down(dev, 0, 50, 50);
4137 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4138 litest_touch_up(dev, 0);
4139
4140 litest_dispatch(li);
4141
4142 litest_assert_empty_queue(li);
4143 }
4144 END_TEST
4145
4146 START_TEST(touchpad_tap_palm_on_touch_hold_timeout)
4147 {
4148 struct litest_device *dev = litest_current_device();
4149 struct libinput *li = dev->libinput;
4150 struct axis_replacement axes[] = {
4151 { ABS_MT_PRESSURE, 75 },
4152 { -1, 0 },
4153 };
4154
4155 if (!touchpad_has_palm_pressure(dev))
4156 return LITEST_NOT_APPLICABLE;
4157
4158 litest_enable_tap(dev->libinput_device);
4159 litest_disable_hold_gestures(dev->libinput_device);
4160 litest_drain_events(li);
4161
4162 /* Finger down is palm after tap timeout */
4163
4164 litest_touch_down(dev, 0, 50, 50);
4165 litest_timeout_tap(li);
4166 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4167 litest_touch_up(dev, 0);
4168
4169 litest_dispatch(li);
4170
4171 litest_assert_empty_queue(li);
4172 }
4173 END_TEST
4174
4175 START_TEST(touchpad_tap_palm_on_touch_hold_move)
4176 {
4177 struct litest_device *dev = litest_current_device();
4178 struct libinput *li = dev->libinput;
4179 struct axis_replacement axes[] = {
4180 { ABS_MT_PRESSURE, 75 },
4181 { -1, 0 },
4182 };
4183
4184 if (!touchpad_has_palm_pressure(dev))
4185 return LITEST_NOT_APPLICABLE;
4186
4187 litest_enable_tap(dev->libinput_device);
4188 litest_disable_hold_gestures(dev->libinput_device);
4189 litest_drain_events(li);
4190
4191 /* Finger down is palm after tap move threshold */
4192
4193 litest_touch_down(dev, 0, 50, 50);
4194 litest_touch_move_to(dev, 0, 50, 50, 60, 60, 10);
4195 litest_drain_events(li);
4196
4197 litest_touch_move_to_extended(dev, 0, 60, 60, 60, 60, axes, 1);
4198 litest_touch_up(dev, 0);
4199
4200 litest_dispatch(li);
4201
4202 litest_assert_empty_queue(li);
4203 }
4204 END_TEST
4205
4206 START_TEST(touchpad_tap_palm_on_tapped)
4207 {
4208 struct litest_device *dev = litest_current_device();
4209 struct libinput *li = dev->libinput;
4210 struct axis_replacement axes[] = {
4211 { ABS_MT_PRESSURE, 75 },
4212 { -1, 0 },
4213 };
4214 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
4215 unsigned int button = 0;
4216
4217 if (!touchpad_has_palm_pressure(dev))
4218 return LITEST_NOT_APPLICABLE;
4219
4220 if (nfingers > litest_slot_count(dev))
4221 return LITEST_NOT_APPLICABLE;
4222
4223 litest_enable_tap(dev->libinput_device);
4224 litest_disable_hold_gestures(dev->libinput_device);
4225
4226 switch (nfingers) {
4227 case 1:
4228 button = BTN_LEFT;
4229 break;
4230 case 2:
4231 button = BTN_RIGHT;
4232 break;
4233 case 3:
4234 button = BTN_MIDDLE;
4235 break;
4236 default:
4237 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4238 }
4239
4240 litest_drain_events(li);
4241
4242 /* tap + palm down */
4243
4244 switch (nfingers) {
4245 case 3:
4246 litest_touch_down(dev, 2, 60, 30);
4247 _fallthrough_;
4248 case 2:
4249 litest_touch_down(dev, 1, 50, 30);
4250 _fallthrough_;
4251 case 1:
4252 litest_touch_down(dev, 0, 40, 30);
4253 break;
4254 }
4255 switch (nfingers) {
4256 case 3:
4257 litest_touch_up(dev, 2);
4258 _fallthrough_;
4259 case 2:
4260 litest_touch_up(dev, 1);
4261 _fallthrough_;
4262 case 1:
4263 litest_touch_up(dev, 0);
4264 break;
4265 }
4266 litest_dispatch(li);
4267
4268 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4269
4270 litest_touch_down(dev, 0, 50, 50);
4271 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4272 litest_touch_up(dev, 0);
4273
4274 litest_timeout_tap(li);
4275
4276 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4277
4278 litest_assert_empty_queue(li);
4279 }
4280 END_TEST
4281
4282 START_TEST(touchpad_tap_palm_on_tapped_palm_down)
4283 {
4284 struct litest_device *dev = litest_current_device();
4285 struct libinput *li = dev->libinput;
4286 struct axis_replacement axes[] = {
4287 { ABS_MT_PRESSURE, 75 },
4288 { -1, 0 },
4289 };
4290 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
4291 unsigned int button = 0;
4292
4293 if (!touchpad_has_palm_pressure(dev))
4294 return LITEST_NOT_APPLICABLE;
4295
4296 if (nfingers > litest_slot_count(dev))
4297 return LITEST_NOT_APPLICABLE;
4298
4299 litest_enable_tap(dev->libinput_device);
4300 litest_disable_hold_gestures(dev->libinput_device);
4301
4302 switch (nfingers) {
4303 case 1:
4304 button = BTN_LEFT;
4305 break;
4306 case 2:
4307 button = BTN_RIGHT;
4308 break;
4309 case 3:
4310 button = BTN_MIDDLE;
4311 break;
4312 default:
4313 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4314 }
4315
4316 litest_drain_events(li);
4317
4318 /* tap + palm down */
4319
4320 switch (nfingers) {
4321 case 3:
4322 litest_touch_down(dev, 2, 60, 30);
4323 _fallthrough_;
4324 case 2:
4325 litest_touch_down(dev, 1, 50, 30);
4326 _fallthrough_;
4327 case 1:
4328 litest_touch_down(dev, 0, 40, 30);
4329 break;
4330 }
4331 switch (nfingers) {
4332 case 3:
4333 litest_touch_up(dev, 2);
4334 _fallthrough_;
4335 case 2:
4336 litest_touch_up(dev, 1);
4337 _fallthrough_;
4338 case 1:
4339 litest_touch_up(dev, 0);
4340 break;
4341 }
4342 litest_dispatch(li);
4343
4344 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4345
4346 litest_touch_down_extended(dev, 0, 50, 50, axes);
4347 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4348 litest_touch_up(dev, 0);
4349
4350 litest_timeout_tap(li);
4351
4352 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4353
4354 litest_assert_empty_queue(li);
4355 }
4356 END_TEST
4357
4358 START_TEST(touchpad_tap_palm_on_tapped_doubletap)
4359 {
4360 struct litest_device *dev = litest_current_device();
4361 struct libinput *li = dev->libinput;
4362 struct axis_replacement axes[] = {
4363 { ABS_MT_PRESSURE, 75 },
4364 { -1, 0 },
4365 };
4366 int nfingers = litest_test_param_get_i32(test_env->params, "fingers_1st"),
4367 nfingers2 = litest_test_param_get_i32(test_env->params, "fingers_2nd");
4368 unsigned int button = 0, button2 = 0;
4369
4370 if (!touchpad_has_palm_pressure(dev))
4371 return LITEST_NOT_APPLICABLE;
4372
4373 if (nfingers > litest_slot_count(dev))
4374 return LITEST_NOT_APPLICABLE;
4375
4376 if (nfingers2 + 1 > litest_slot_count(dev))
4377 return LITEST_NOT_APPLICABLE;
4378
4379 litest_enable_tap(dev->libinput_device);
4380 litest_disable_hold_gestures(dev->libinput_device);
4381
4382 switch (nfingers) {
4383 case 1:
4384 button = BTN_LEFT;
4385 break;
4386 case 2:
4387 button = BTN_RIGHT;
4388 break;
4389 case 3:
4390 button = BTN_MIDDLE;
4391 break;
4392 default:
4393 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4394 }
4395 switch (nfingers2) {
4396 case 1:
4397 button2 = BTN_LEFT;
4398 break;
4399 case 2:
4400 button2 = BTN_RIGHT;
4401 break;
4402 case 3:
4403 button2 = BTN_MIDDLE;
4404 break;
4405 default:
4406 litest_abort_msg("Unexpected number of fingers (%d)", nfingers2);
4407 }
4408
4409 litest_drain_events(li);
4410
4411 /* tap + palm down + tap with additional finger(s) */
4412
4413 switch (nfingers) {
4414 case 3:
4415 litest_touch_down(dev, 2, 60, 30);
4416 _fallthrough_;
4417 case 2:
4418 litest_touch_down(dev, 1, 50, 30);
4419 _fallthrough_;
4420 case 1:
4421 litest_touch_down(dev, 0, 40, 30);
4422 break;
4423 }
4424 switch (nfingers) {
4425 case 3:
4426 litest_touch_up(dev, 2);
4427 _fallthrough_;
4428 case 2:
4429 litest_touch_up(dev, 1);
4430 _fallthrough_;
4431 case 1:
4432 litest_touch_up(dev, 0);
4433 break;
4434 }
4435 litest_dispatch(li);
4436
4437 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4438
4439 litest_touch_down(dev, 0, 50, 50);
4440 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4441
4442 litest_dispatch(li);
4443
4444 switch (nfingers2) {
4445 case 3:
4446 litest_touch_down(dev, 3, 60, 30);
4447 _fallthrough_;
4448 case 2:
4449 litest_touch_down(dev, 2, 50, 30);
4450 _fallthrough_;
4451 case 1:
4452 litest_touch_down(dev, 1, 40, 30);
4453 break;
4454 }
4455 switch (nfingers2) {
4456 case 3:
4457 litest_touch_up(dev, 3);
4458 _fallthrough_;
4459 case 2:
4460 litest_touch_up(dev, 2);
4461 _fallthrough_;
4462 case 1:
4463 litest_touch_up(dev, 1);
4464 break;
4465 }
4466
4467 litest_timeout_tap(li);
4468
4469 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4470 litest_assert_button_event(li, button2, LIBINPUT_BUTTON_STATE_PRESSED);
4471 litest_assert_button_event(li, button2, LIBINPUT_BUTTON_STATE_RELEASED);
4472
4473 litest_touch_up(dev, 0);
4474 litest_assert_empty_queue(li);
4475 }
4476 END_TEST
4477
4478 START_TEST(touchpad_tap_palm_on_drag)
4479 {
4480 struct litest_device *dev = litest_current_device();
4481 struct libinput *li = dev->libinput;
4482 struct axis_replacement axes[] = {
4483 { ABS_MT_PRESSURE, 75 },
4484 { -1, 0 },
4485 };
4486 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
4487 unsigned int button = 0;
4488
4489 if (!touchpad_has_palm_pressure(dev))
4490 return LITEST_NOT_APPLICABLE;
4491
4492 if (nfingers > litest_slot_count(dev))
4493 return LITEST_NOT_APPLICABLE;
4494
4495 litest_enable_tap(dev->libinput_device);
4496 litest_disable_hold_gestures(dev->libinput_device);
4497
4498 switch (nfingers) {
4499 case 1:
4500 button = BTN_LEFT;
4501 break;
4502 case 2:
4503 button = BTN_RIGHT;
4504 break;
4505 case 3:
4506 button = BTN_MIDDLE;
4507 break;
4508 default:
4509 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4510 }
4511
4512 litest_drain_events(li);
4513
4514 /* tap + finger down (->drag), finger turns into palm */
4515
4516 switch (nfingers) {
4517 case 3:
4518 litest_touch_down(dev, 2, 60, 30);
4519 _fallthrough_;
4520 case 2:
4521 litest_touch_down(dev, 1, 50, 30);
4522 _fallthrough_;
4523 case 1:
4524 litest_touch_down(dev, 0, 40, 30);
4525 break;
4526 }
4527 switch (nfingers) {
4528 case 3:
4529 litest_touch_up(dev, 2);
4530 _fallthrough_;
4531 case 2:
4532 litest_touch_up(dev, 1);
4533 _fallthrough_;
4534 case 1:
4535 litest_touch_up(dev, 0);
4536 break;
4537 }
4538 litest_dispatch(li);
4539
4540 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4541
4542 litest_touch_down(dev, 0, 50, 50);
4543 litest_timeout_tap(li);
4544
4545 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4546 litest_dispatch(li);
4547
4548 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4549
4550 litest_touch_up(dev, 0);
4551 litest_assert_empty_queue(li);
4552 }
4553 END_TEST
4554
4555 START_TEST(touchpad_tap_palm_on_drag_2fg)
4556 {
4557 struct litest_device *dev = litest_current_device();
4558 struct libinput *li = dev->libinput;
4559 struct axis_replacement axes[] = {
4560 { ABS_MT_PRESSURE, 75 },
4561 { -1, 0 },
4562 };
4563 int which = litest_test_param_get_i32(test_env->params, "which"),
4564 this = which % 2, other = (which + 1) % 2,
4565 nfingers = litest_test_param_get_i32(test_env->params, "fingers");
4566 unsigned int button = 0;
4567
4568 if (!touchpad_has_palm_pressure(dev))
4569 return LITEST_NOT_APPLICABLE;
4570
4571 if (nfingers > litest_slot_count(dev))
4572 return LITEST_NOT_APPLICABLE;
4573
4574 litest_enable_tap(dev->libinput_device);
4575 litest_disable_hold_gestures(dev->libinput_device);
4576
4577 switch (nfingers) {
4578 case 1:
4579 button = BTN_LEFT;
4580 break;
4581 case 2:
4582 button = BTN_RIGHT;
4583 break;
4584 case 3:
4585 button = BTN_MIDDLE;
4586 break;
4587 default:
4588 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4589 }
4590
4591 litest_drain_events(li);
4592
4593 /* tap + finger down, 2nd finger down, finger turns to palm */
4594
4595 switch (nfingers) {
4596 case 3:
4597 litest_touch_down(dev, 2, 60, 30);
4598 _fallthrough_;
4599 case 2:
4600 litest_touch_down(dev, 1, 50, 30);
4601 _fallthrough_;
4602 case 1:
4603 litest_touch_down(dev, 0, 40, 30);
4604 break;
4605 }
4606 switch (nfingers) {
4607 case 3:
4608 litest_touch_up(dev, 2);
4609 _fallthrough_;
4610 case 2:
4611 litest_touch_up(dev, 1);
4612 _fallthrough_;
4613 case 1:
4614 litest_touch_up(dev, 0);
4615 break;
4616 }
4617 litest_dispatch(li);
4618
4619 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4620
4621 litest_touch_down(dev, this, 50, 50);
4622 litest_timeout_tap(li);
4623 litest_touch_down(dev, other, 60, 50);
4624 litest_dispatch(li);
4625
4626 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4627 litest_dispatch(li);
4628
4629 litest_touch_move_to(dev, other, 60, 50, 65, 50, 10);
4630 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
4631 litest_touch_up(dev, other);
4632
4633 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4634
4635 litest_touch_up(dev, this);
4636 litest_assert_empty_queue(li);
4637 }
4638 END_TEST
4639
4640 START_TEST(touchpad_tap_palm_on_touch_2)
4641 {
4642 struct litest_device *dev = litest_current_device();
4643 struct libinput *li = dev->libinput;
4644 struct axis_replacement axes[] = {
4645 { ABS_MT_PRESSURE, 75 },
4646 { -1, 0 },
4647 };
4648 int which = litest_test_param_get_i32(test_env->params, "which"),
4649 this = which % 2, other = (which + 1) % 2;
4650
4651 if (!touchpad_has_palm_pressure(dev))
4652 return LITEST_NOT_APPLICABLE;
4653
4654 litest_enable_tap(dev->libinput_device);
4655 litest_disable_hold_gestures(dev->libinput_device);
4656 litest_drain_events(li);
4657
4658 /* 2fg tap with one finger detected as palm */
4659 litest_touch_down(dev, 0, 50, 50);
4660 litest_touch_down(dev, 1, 60, 60);
4661 litest_drain_events(li);
4662 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4663
4664 litest_touch_up(dev, this);
4665 litest_touch_up(dev, other);
4666
4667 litest_dispatch(li);
4668 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
4669 litest_timeout_tap(li);
4670 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
4671
4672 litest_assert_empty_queue(li);
4673 }
4674 END_TEST
4675
4676 START_TEST(touchpad_tap_palm_on_touch_2_retouch)
4677 {
4678 struct litest_device *dev = litest_current_device();
4679 struct libinput *li = dev->libinput;
4680 struct axis_replacement axes[] = {
4681 { ABS_MT_PRESSURE, 75 },
4682 { -1, 0 },
4683 };
4684 int which = litest_test_param_get_i32(test_env->params, "which"),
4685 this = which % 2, other = (which + 1) % 2;
4686
4687 if (!touchpad_has_palm_pressure(dev))
4688 return LITEST_NOT_APPLICABLE;
4689
4690 litest_enable_tap(dev->libinput_device);
4691 litest_disable_hold_gestures(dev->libinput_device);
4692 litest_drain_events(li);
4693
4694 /* 2fg tap with one finger detected as palm, that finger is lifted
4695 * and taps again as not-palm */
4696 litest_touch_down(dev, this, 50, 50);
4697 litest_touch_down(dev, other, 60, 60);
4698 litest_drain_events(li);
4699 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4700 litest_touch_up(dev, this);
4701 litest_dispatch(li);
4702
4703 litest_touch_down(dev, this, 70, 70);
4704 litest_touch_up(dev, this);
4705 litest_touch_up(dev, other);
4706
4707 litest_dispatch(li);
4708 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
4709 litest_timeout_tap(li);
4710 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
4711
4712 litest_assert_empty_queue(li);
4713 }
4714 END_TEST
4715
4716 START_TEST(touchpad_tap_palm_on_touch_3)
4717 {
4718 struct litest_device *dev = litest_current_device();
4719 struct libinput *li = dev->libinput;
4720 struct axis_replacement axes[] = {
4721 { ABS_MT_PRESSURE, 75 },
4722 { -1, 0 },
4723 };
4724 int which = litest_test_param_get_i32(test_env->params, "which"),
4725 this = which % 3;
4726
4727 if (litest_slot_count(dev) < 3)
4728 return LITEST_NOT_APPLICABLE;
4729
4730 if (!touchpad_has_palm_pressure(dev))
4731 return LITEST_NOT_APPLICABLE;
4732
4733 litest_enable_tap(dev->libinput_device);
4734 litest_disable_hold_gestures(dev->libinput_device);
4735 litest_drain_events(li);
4736
4737 /* 3fg tap with one finger detected as palm, that finger is lifted,
4738 other two fingers lifted cause 2fg tap */
4739 litest_touch_down(dev, this, 50, 50);
4740 litest_touch_down(dev, (this + 1) % 3, 60, 50);
4741 litest_touch_down(dev, (this + 2) % 3, 70, 50);
4742 litest_drain_events(li);
4743 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4744 litest_touch_up(dev, this);
4745 litest_dispatch(li);
4746
4747 litest_touch_up(dev, (this + 1) % 3);
4748 litest_touch_up(dev, (this + 2) % 3);
4749
4750 litest_dispatch(li);
4751 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
4752 litest_timeout_tap(li);
4753 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
4754
4755 litest_assert_empty_queue(li);
4756 }
4757 END_TEST
4758
4759 START_TEST(touchpad_tap_palm_on_touch_3_retouch)
4760 {
4761 struct litest_device *dev = litest_current_device();
4762 struct libinput *li = dev->libinput;
4763 struct axis_replacement axes[] = {
4764 { ABS_MT_PRESSURE, 75 },
4765 { -1, 0 },
4766 };
4767 int which = litest_test_param_get_i32(test_env->params, "which"),
4768 this = which % 3;
4769
4770 if (litest_slot_count(dev) < 3)
4771 return LITEST_NOT_APPLICABLE;
4772
4773 if (!touchpad_has_palm_pressure(dev))
4774 return LITEST_NOT_APPLICABLE;
4775
4776 litest_enable_tap(dev->libinput_device);
4777 litest_disable_hold_gestures(dev->libinput_device);
4778 litest_drain_events(li);
4779
4780 /* 3fg tap with one finger detected as palm, that finger is lifted,
4781 then put down again as normal finger -> 3fg tap */
4782 litest_touch_down(dev, this, 50, 50);
4783 litest_touch_down(dev, (this + 1) % 3, 60, 50);
4784 litest_touch_down(dev, (this + 2) % 3, 70, 50);
4785 litest_drain_events(li);
4786 litest_timeout_tap(li);
4787
4788 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4789 litest_touch_up(dev, this);
4790 litest_dispatch(li);
4791
4792 litest_touch_down(dev, this, 50, 50);
4793 litest_touch_up(dev, this);
4794 litest_touch_up(dev, (this + 1) % 3);
4795 litest_touch_up(dev, (this + 2) % 3);
4796
4797 litest_dispatch(li);
4798 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_PRESSED);
4799 litest_timeout_tap(li);
4800 litest_assert_button_event(li, BTN_MIDDLE, LIBINPUT_BUTTON_STATE_RELEASED);
4801
4802 litest_assert_empty_queue(li);
4803 }
4804 END_TEST
4805
4806 START_TEST(touchpad_tap_palm_on_touch_4)
4807 {
4808 struct litest_device *dev = litest_current_device();
4809 struct libinput *li = dev->libinput;
4810 struct axis_replacement axes[] = {
4811 { ABS_MT_PRESSURE, 75 },
4812 { -1, 0 },
4813 };
4814 int which = litest_test_param_get_i32(test_env->params, "which"),
4815 this = which % 4;
4816
4817 if (litest_slot_count(dev) < 4)
4818 return LITEST_NOT_APPLICABLE;
4819
4820 if (!touchpad_has_palm_pressure(dev))
4821 return LITEST_NOT_APPLICABLE;
4822
4823 litest_enable_tap(dev->libinput_device);
4824 litest_disable_hold_gestures(dev->libinput_device);
4825 litest_drain_events(li);
4826
4827 /* 4fg tap with one finger detected as palm, that finger is lifted,
4828 other two fingers lifted cause nothing because we terminate
4829 tapping as soon as 4 fingers are down */
4830 litest_touch_down(dev, this, 50, 50);
4831 litest_touch_down(dev, (this + 1) % 4, 60, 50);
4832 litest_touch_down(dev, (this + 2) % 4, 70, 50);
4833 litest_touch_down(dev, (this + 3) % 4, 80, 50);
4834 litest_drain_events(li);
4835 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
4836 litest_touch_up(dev, this);
4837 litest_dispatch(li);
4838
4839 litest_touch_up(dev, (this + 1) % 4);
4840 litest_touch_up(dev, (this + 2) % 4);
4841 litest_touch_up(dev, (this + 3) % 4);
4842
4843 litest_assert_empty_queue(li);
4844 }
4845 END_TEST
4846
4847 START_TEST(touchpad_tap_palm_after_tap)
4848 {
4849 struct litest_device *dev = litest_current_device();
4850 struct libinput *li = dev->libinput;
4851 struct axis_replacement axes[] = {
4852 { ABS_MT_PRESSURE, 75 },
4853 { -1, 0 },
4854 };
4855 int nfingers = litest_test_param_get_i32(test_env->params, "fingers");
4856 unsigned int button = 0;
4857
4858 if (!touchpad_has_palm_pressure(dev))
4859 return LITEST_NOT_APPLICABLE;
4860
4861 if (nfingers > litest_slot_count(dev))
4862 return LITEST_NOT_APPLICABLE;
4863
4864 litest_enable_tap(dev->libinput_device);
4865 litest_disable_hold_gestures(dev->libinput_device);
4866
4867 switch (nfingers) {
4868 case 1:
4869 button = BTN_LEFT;
4870 break;
4871 case 2:
4872 button = BTN_RIGHT;
4873 break;
4874 case 3:
4875 button = BTN_MIDDLE;
4876 break;
4877 default:
4878 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4879 }
4880
4881 litest_drain_events(li);
4882
4883 switch (nfingers) {
4884 case 3:
4885 litest_touch_down(dev, 2, 60, 30);
4886 _fallthrough_;
4887 case 2:
4888 litest_touch_down(dev, 1, 50, 30);
4889 _fallthrough_;
4890 case 1:
4891 litest_touch_down(dev, 0, 40, 30);
4892 break;
4893 }
4894 switch (nfingers) {
4895 case 3:
4896 litest_touch_up(dev, 2);
4897 _fallthrough_;
4898 case 2:
4899 litest_touch_up(dev, 1);
4900 _fallthrough_;
4901 case 1:
4902 litest_touch_up(dev, 0);
4903 break;
4904 }
4905 litest_dispatch(li);
4906
4907 litest_dispatch(li);
4908 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4909
4910 litest_touch_down(dev, 0, 50, 50);
4911 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4912 litest_touch_up(dev, 0);
4913
4914 litest_timeout_tap(li);
4915 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4916
4917 litest_assert_empty_queue(li);
4918 }
4919 END_TEST
4920
4921 START_TEST(touchpad_tap_palm_multitap)
4922 {
4923 struct litest_device *dev = litest_current_device();
4924 struct libinput *li = dev->libinput;
4925 struct axis_replacement axes[] = {
4926 { ABS_MT_PRESSURE, 75 },
4927 { -1, 0 },
4928 };
4929 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
4930 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
4931 unsigned int button = 0;
4932
4933 if (!touchpad_has_palm_pressure(dev))
4934 return LITEST_NOT_APPLICABLE;
4935
4936 if (nfingers > litest_slot_count(dev))
4937 return LITEST_NOT_APPLICABLE;
4938
4939 litest_enable_tap(dev->libinput_device);
4940 litest_disable_hold_gestures(dev->libinput_device);
4941
4942 switch (nfingers) {
4943 case 1:
4944 button = BTN_LEFT;
4945 break;
4946 case 2:
4947 button = BTN_RIGHT;
4948 break;
4949 case 3:
4950 button = BTN_MIDDLE;
4951 break;
4952 default:
4953 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
4954 }
4955
4956 litest_drain_events(li);
4957
4958 for (ntaps = 0; ntaps <= range; ntaps++) {
4959 switch (nfingers) {
4960 case 3:
4961 litest_touch_down(dev, 2, 60, 30);
4962 _fallthrough_;
4963 case 2:
4964 litest_touch_down(dev, 1, 50, 30);
4965 _fallthrough_;
4966 case 1:
4967 litest_touch_down(dev, 0, 40, 30);
4968 break;
4969 }
4970 switch (nfingers) {
4971 case 3:
4972 litest_touch_up(dev, 2);
4973 _fallthrough_;
4974 case 2:
4975 litest_touch_up(dev, 1);
4976 _fallthrough_;
4977 case 1:
4978 litest_touch_up(dev, 0);
4979 break;
4980 }
4981
4982 litest_dispatch(li);
4983 msleep(10);
4984 }
4985
4986 litest_touch_down(dev, 0, 50, 50);
4987 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
4988 litest_touch_up(dev, 0);
4989 litest_timeout_tap(li);
4990
4991 for (ntaps = 0; ntaps <= range; ntaps++) {
4992 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
4993 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
4994 }
4995
4996 litest_assert_empty_queue(li);
4997 }
4998 END_TEST
4999
5000 START_TEST(touchpad_tap_palm_multitap_timeout)
5001 {
5002 struct litest_device *dev = litest_current_device();
5003 struct libinput *li = dev->libinput;
5004 struct axis_replacement axes[] = {
5005 { ABS_MT_PRESSURE, 75 },
5006 { -1, 0 },
5007 };
5008 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
5009 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
5010 unsigned int button = 0;
5011
5012 if (!touchpad_has_palm_pressure(dev))
5013 return LITEST_NOT_APPLICABLE;
5014
5015 if (nfingers > litest_slot_count(dev))
5016 return LITEST_NOT_APPLICABLE;
5017
5018 litest_enable_tap(dev->libinput_device);
5019 litest_disable_hold_gestures(dev->libinput_device);
5020
5021 switch (nfingers) {
5022 case 1:
5023 button = BTN_LEFT;
5024 break;
5025 case 2:
5026 button = BTN_RIGHT;
5027 break;
5028 case 3:
5029 button = BTN_MIDDLE;
5030 break;
5031 default:
5032 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
5033 }
5034
5035 litest_drain_events(li);
5036
5037 for (ntaps = 0; ntaps <= range; ntaps++) {
5038 switch (nfingers) {
5039 case 3:
5040 litest_touch_down(dev, 2, 60, 30);
5041 _fallthrough_;
5042 case 2:
5043 litest_touch_down(dev, 1, 50, 30);
5044 _fallthrough_;
5045 case 1:
5046 litest_touch_down(dev, 0, 40, 30);
5047 break;
5048 }
5049 switch (nfingers) {
5050 case 3:
5051 litest_touch_up(dev, 2);
5052 _fallthrough_;
5053 case 2:
5054 litest_touch_up(dev, 1);
5055 _fallthrough_;
5056 case 1:
5057 litest_touch_up(dev, 0);
5058 break;
5059 }
5060
5061 litest_dispatch(li);
5062 msleep(10);
5063 }
5064
5065 litest_touch_down(dev, 0, 50, 50);
5066 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
5067 litest_timeout_tap(li);
5068
5069 for (ntaps = 0; ntaps <= range; ntaps++) {
5070 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
5071 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
5072 }
5073
5074 litest_assert_empty_queue(li);
5075 }
5076 END_TEST
5077
5078 START_TEST(touchpad_tap_palm_multitap_down_again)
5079 {
5080 struct litest_device *dev = litest_current_device();
5081 struct libinput *li = dev->libinput;
5082 struct axis_replacement axes[] = {
5083 { ABS_MT_PRESSURE, 75 },
5084 { -1, 0 },
5085 };
5086 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
5087 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
5088 unsigned int button = 0;
5089
5090 if (!touchpad_has_palm_pressure(dev))
5091 return LITEST_NOT_APPLICABLE;
5092
5093 if (nfingers + 1 > litest_slot_count(dev))
5094 return LITEST_NOT_APPLICABLE;
5095
5096 litest_enable_tap(dev->libinput_device);
5097 litest_disable_hold_gestures(dev->libinput_device);
5098
5099 switch (nfingers) {
5100 case 1:
5101 button = BTN_LEFT;
5102 break;
5103 case 2:
5104 button = BTN_RIGHT;
5105 break;
5106 case 3:
5107 button = BTN_MIDDLE;
5108 break;
5109 default:
5110 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
5111 }
5112
5113 litest_drain_events(li);
5114
5115 for (ntaps = 0; ntaps <= range; ntaps++) {
5116 switch (nfingers) {
5117 case 3:
5118 litest_touch_down(dev, 2, 60, 30);
5119 _fallthrough_;
5120 case 2:
5121 litest_touch_down(dev, 1, 50, 30);
5122 _fallthrough_;
5123 case 1:
5124 litest_touch_down(dev, 0, 40, 30);
5125 break;
5126 }
5127 switch (nfingers) {
5128 case 3:
5129 litest_touch_up(dev, 2);
5130 _fallthrough_;
5131 case 2:
5132 litest_touch_up(dev, 1);
5133 _fallthrough_;
5134 case 1:
5135 litest_touch_up(dev, 0);
5136 break;
5137 }
5138
5139 litest_dispatch(li);
5140 msleep(10);
5141 }
5142
5143 litest_touch_down(dev, 0, 50, 50);
5144 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
5145 litest_dispatch(li);
5146
5147 /* keep palm finger down */
5148 for (ntaps = 0; ntaps <= range; ntaps++) {
5149 switch (nfingers) {
5150 case 3:
5151 litest_touch_down(dev, 3, 60, 30);
5152 _fallthrough_;
5153 case 2:
5154 litest_touch_down(dev, 2, 50, 30);
5155 _fallthrough_;
5156 case 1:
5157 litest_touch_down(dev, 1, 40, 30);
5158 break;
5159 }
5160 switch (nfingers) {
5161 case 3:
5162 litest_touch_up(dev, 3);
5163 _fallthrough_;
5164 case 2:
5165 litest_touch_up(dev, 2);
5166 _fallthrough_;
5167 case 1:
5168 litest_touch_up(dev, 1);
5169 break;
5170 }
5171
5172 litest_dispatch(li);
5173 msleep(10);
5174 }
5175
5176 litest_timeout_tap(li);
5177
5178 for (ntaps = 0; ntaps <= 2 * range + 1; ntaps++) {
5179 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
5180 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
5181 }
5182
5183 litest_touch_up(dev, 0);
5184 litest_assert_empty_queue(li);
5185 }
5186 END_TEST
5187
5188 START_TEST(touchpad_tap_palm_multitap_click)
5189 {
5190 struct litest_device *dev = litest_current_device();
5191 struct libinput *li = dev->libinput;
5192 struct axis_replacement axes[] = {
5193 { ABS_MT_PRESSURE, 75 },
5194 { -1, 0 },
5195 };
5196 int nfingers = litest_test_param_get_i32(test_env->params, "fingers"),
5197 range = litest_test_param_get_i32(test_env->params, "taps"), ntaps;
5198 unsigned int button = 0;
5199
5200 if (!touchpad_has_palm_pressure(dev))
5201 return LITEST_NOT_APPLICABLE;
5202
5203 if (nfingers > litest_slot_count(dev))
5204 return LITEST_NOT_APPLICABLE;
5205
5206 litest_enable_tap(dev->libinput_device);
5207 litest_disable_hold_gestures(dev->libinput_device);
5208
5209 switch (nfingers) {
5210 case 1:
5211 button = BTN_LEFT;
5212 break;
5213 case 2:
5214 button = BTN_RIGHT;
5215 break;
5216 case 3:
5217 button = BTN_MIDDLE;
5218 break;
5219 default:
5220 litest_abort_msg("Unexpected number of fingers (%d)", nfingers);
5221 }
5222
5223 litest_drain_events(li);
5224
5225 for (ntaps = 0; ntaps <= range; ntaps++) {
5226 switch (nfingers) {
5227 case 3:
5228 litest_touch_down(dev, 2, 60, 30);
5229 _fallthrough_;
5230 case 2:
5231 litest_touch_down(dev, 1, 50, 30);
5232 _fallthrough_;
5233 case 1:
5234 litest_touch_down(dev, 0, 40, 30);
5235 break;
5236 }
5237 switch (nfingers) {
5238 case 3:
5239 litest_touch_up(dev, 2);
5240 _fallthrough_;
5241 case 2:
5242 litest_touch_up(dev, 1);
5243 _fallthrough_;
5244 case 1:
5245 litest_touch_up(dev, 0);
5246 break;
5247 }
5248
5249 litest_dispatch(li);
5250 msleep(10);
5251 }
5252
5253 litest_touch_down(dev, 0, 50, 50);
5254 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
5255 litest_dispatch(li);
5256 /* keep palm finger down */
5257
5258 litest_button_click(dev, BTN_LEFT, true);
5259 litest_button_click(dev, BTN_LEFT, false);
5260 litest_dispatch(li);
5261
5262 for (ntaps = 0; ntaps <= range; ntaps++) {
5263 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_PRESSED);
5264 litest_assert_button_event(li, button, LIBINPUT_BUTTON_STATE_RELEASED);
5265 }
5266
5267 /* the click */
5268 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
5269 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
5270 litest_touch_up(dev, 0);
5271 litest_assert_empty_queue(li);
5272 }
5273 END_TEST
5274
5275 START_TEST(touchpad_tap_palm_click_then_tap)
5276 {
5277 struct litest_device *dev = litest_current_device();
5278 struct libinput *li = dev->libinput;
5279 struct axis_replacement axes[] = {
5280 { ABS_MT_PRESSURE, 75 },
5281 { -1, 0 },
5282 };
5283
5284 if (!touchpad_has_palm_pressure(dev))
5285 return LITEST_NOT_APPLICABLE;
5286
5287 litest_enable_tap(dev->libinput_device);
5288 litest_disable_hold_gestures(dev->libinput_device);
5289 litest_drain_events(li);
5290
5291 litest_touch_down_extended(dev, 0, 50, 50, axes);
5292 litest_dispatch(li);
5293
5294 litest_button_click(dev, BTN_LEFT, true);
5295 litest_button_click(dev, BTN_LEFT, false);
5296 litest_dispatch(li);
5297
5298 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
5299 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
5300
5301 litest_touch_up(dev, 0);
5302 litest_assert_empty_queue(li);
5303
5304 litest_touch_down(dev, 0, 50, 50);
5305 litest_touch_up(dev, 0);
5306 litest_timeout_tap(li);
5307
5308 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
5309 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
5310
5311 litest_assert_empty_queue(li);
5312 }
5313 END_TEST
5314
5315 START_TEST(touchpad_tap_palm_dwt_tap)
5316 {
5317 struct litest_device *dev = litest_current_device();
5318 struct litest_device *keyboard;
5319 struct libinput *li = dev->libinput;
5320 struct axis_replacement axes[] = {
5321 { ABS_MT_PRESSURE, 75 },
5322 { -1, 0 },
5323 };
5324
5325 if (!touchpad_has_palm_pressure(dev))
5326 return LITEST_NOT_APPLICABLE;
5327
5328 keyboard = litest_add_device(li, LITEST_KEYBOARD);
5329
5330 litest_enable_tap(dev->libinput_device);
5331 litest_disable_hold_gestures(dev->libinput_device);
5332 litest_drain_events(li);
5333
5334 litest_keyboard_key(keyboard, KEY_A, true);
5335 litest_keyboard_key(keyboard, KEY_B, true);
5336 litest_keyboard_key(keyboard, KEY_A, false);
5337 litest_drain_events(li);
5338
5339 litest_touch_down(dev, 0, 50, 50);
5340 litest_dispatch(li);
5341
5342 litest_keyboard_key(keyboard, KEY_B, false);
5343 litest_drain_events(li);
5344 litest_timeout_dwt_long(li);
5345
5346 /* Changes to palm after dwt timeout */
5347 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
5348 litest_dispatch(li);
5349
5350 litest_touch_up(dev, 0);
5351 litest_dispatch(li);
5352
5353 litest_assert_empty_queue(li);
5354
5355 litest_device_destroy(keyboard);
5356 }
5357 END_TEST
5358
5359 START_TEST(touchpad_tap_palm_3fg_start)
5360 {
5361 struct litest_device *dev = litest_current_device();
5362 struct libinput *li = dev->libinput;
5363
5364 if (litest_slot_count(dev) < 3 || !litest_has_palm_detect_size(dev))
5365 return LITEST_NOT_APPLICABLE;
5366
5367 litest_enable_tap(dev->libinput_device);
5368 litest_disable_hold_gestures(dev->libinput_device);
5369 litest_drain_events(li);
5370
5371 litest_push_event_frame(dev);
5372 litest_touch_down(dev, 0, 50, 50);
5373 litest_touch_down(dev, 1, 55, 55);
5374 litest_touch_down(dev, 2, 99, 55); /* edge palm */
5375 litest_pop_event_frame(dev);
5376 litest_dispatch(li);
5377
5378 litest_touch_up(dev, 2); /* release the palm */
5379 litest_assert_empty_queue(li);
5380
5381 litest_touch_up(dev, 0);
5382 litest_touch_up(dev, 1);
5383
5384 litest_dispatch(li);
5385 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
5386 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
5387 litest_assert_empty_queue(li);
5388 }
5389 END_TEST
5390
5391 TEST_COLLECTION(touchpad_tap)
5392 {
5393 /* clang-format off */
5394 litest_add(touchpad_1fg_tap, LITEST_TOUCHPAD, LITEST_ANY);
5395 litest_with_parameters(params, "fingers_1st", 'i', 3, 1, 2, 3,
5396 "fingers_2nd", 'i', 3, 1, 2, 3) {
5397 litest_add_parametrized(touchpad_doubletap, LITEST_TOUCHPAD, LITEST_ANY, params);
5398 }
5399 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3,
5400 "taps", 'i', 3, 3, 4, 5) {
5401 litest_add_parametrized(touchpad_multitap, LITEST_TOUCHPAD, LITEST_ANY, params);
5402 litest_add_parametrized(touchpad_multitap_timeout, LITEST_TOUCHPAD, LITEST_ANY, params);
5403 }
5404
5405 litest_add(touchpad_2fg_tap_move_on_release, LITEST_TOUCHPAD|LITEST_SEMI_MT, LITEST_SINGLE_TOUCH);
5406 litest_add(touchpad_2fg_tap_n_hold_first, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5407 litest_add(touchpad_2fg_tap_n_hold_second, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5408 litest_add(touchpad_2fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5409 litest_add(touchpad_1fg_tap_click, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_CLICKPAD);
5410 litest_add(touchpad_2fg_tap_click, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_SINGLE_TOUCH|LITEST_CLICKPAD);
5411
5412 litest_add(touchpad_2fg_tap_click_apple, LITEST_APPLE_CLICKPAD, LITEST_ANY);
5413 litest_add(touchpad_no_2fg_tap_after_move, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5414 litest_add(touchpad_no_2fg_tap_after_timeout, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5415 litest_add(touchpad_no_first_fg_tap_after_move, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5416 litest_add(touchpad_3fg_tap_tap_again, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5417 litest_add(touchpad_3fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5418 litest_add(touchpad_3fg_tap_hover_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5419 litest_add(touchpad_3fg_tap_pressure_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5420 litest_add_for_device(touchpad_3fg_tap_slot_release_btntool, LITEST_SYNAPTICS_TOPBUTTONPAD);
5421 litest_add(touchpad_3fg_tap_after_scroll, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
5422
5423 litest_add(touchpad_4fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5424 litest_add(touchpad_4fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5425 litest_add(touchpad_5fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5426 litest_add(touchpad_5fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5427
5428 litest_with_parameters(params, "map", 'I', 2, litest_named_i32(LIBINPUT_CONFIG_TAP_MAP_LRM, "LRM"),
5429 litest_named_i32(LIBINPUT_CONFIG_TAP_MAP_LMR, "LMR")) {
5430 litest_add_parametrized(touchpad_2fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT, params);
5431 litest_add_parametrized(touchpad_2fg_tap_inverted, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5432 litest_add_parametrized(touchpad_3fg_tap_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5433 litest_add_parametrized(touchpad_3fg_tap_btntool_inverted, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5434 litest_add_parametrized_for_device(touchpad_3fg_tap_btntool_pointerjump, LITEST_SYNAPTICS_TOPBUTTONPAD, params);
5435 litest_add_parametrized(touchpad_3fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5436 }
5437
5438 litest_with_parameters(params, "fingers", 'i', 4, 2, 3, 4, 5) {
5439 litest_add_parametrized(touchpad_move_after_touch, LITEST_TOUCHPAD, LITEST_ANY, params);
5440 }
5441
5442 /* Real buttons don't interfere with tapping, so don't run those for
5443 pads with buttons */
5444 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3) {
5445 litest_add_parametrized(touchpad_double_tap_click, LITEST_CLICKPAD, LITEST_ANY, params);
5446 }
5447
5448 litest_add(touchpad_tap_default_disabled, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_ANY);
5449 litest_add(touchpad_tap_default_enabled, LITEST_TOUCHPAD, LITEST_BUTTON);
5450 litest_add(touchpad_tap_invalid, LITEST_TOUCHPAD, LITEST_ANY);
5451 litest_add(touchpad_tap_is_available, LITEST_TOUCHPAD, LITEST_ANY);
5452 litest_add(touchpad_tap_is_not_available, LITEST_ANY, LITEST_TOUCHPAD);
5453
5454 litest_add(touchpad_tap_default_map, LITEST_TOUCHPAD, LITEST_ANY);
5455 litest_add(touchpad_tap_map_unsupported, LITEST_ANY, LITEST_TOUCHPAD);
5456 litest_add(touchpad_tap_set_map, LITEST_TOUCHPAD, LITEST_ANY);
5457 litest_add(touchpad_tap_set_map_no_tapping, LITEST_ANY, LITEST_TOUCHPAD);
5458 litest_add(touchpad_tap_get_map_no_tapping, LITEST_ANY, LITEST_TOUCHPAD);
5459 litest_add(touchpad_tap_map_delayed, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
5460
5461 litest_add(clickpad_1fg_tap_click, LITEST_CLICKPAD, LITEST_ANY);
5462 litest_add(clickpad_2fg_tap_click, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH|LITEST_APPLE_CLICKPAD);
5463 /* clang-format on */
5464 }
5465
5466 TEST_COLLECTION(touchpad_tap_drag)
5467 {
5468 /* clang-format off */
5469 litest_add(touchpad_drag_lock_default_disabled, LITEST_TOUCHPAD, LITEST_ANY);
5470 litest_add(touchpad_drag_lock_default_unavailable, LITEST_ANY, LITEST_TOUCHPAD);
5471
5472 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3,
5473 "taps", 'i', 3, 3, 4, 5) {
5474 litest_add_parametrized(touchpad_multitap_n_drag_tap_click, LITEST_CLICKPAD, LITEST_ANY, params);
5475
5476 litest_add_parametrized(touchpad_multitap_n_drag_timeout, LITEST_TOUCHPAD, LITEST_ANY, params);
5477 litest_add_parametrized(touchpad_multitap_n_drag_tap, LITEST_TOUCHPAD, LITEST_ANY, params);
5478 litest_add_parametrized(touchpad_multitap_n_drag_move, LITEST_TOUCHPAD, LITEST_ANY, params);
5479 litest_add_parametrized(touchpad_multitap_n_drag_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5480 litest_add_parametrized(touchpad_multitap_n_drag_click, LITEST_CLICKPAD, LITEST_ANY, params);
5481
5482 litest_add_parametrized(touchpad_drag_disabled_multitap_no_drag, LITEST_TOUCHPAD, LITEST_ANY, params);
5483 }
5484
5485 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3,
5486 "taps", 'i', 3, 1, 2, 3) {
5487 litest_add_parametrized(touchpad_multitap_n_drag_high_delay, LITEST_TOUCHPAD, LITEST_ANY, params);
5488 }
5489
5490 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3) {
5491 litest_add_parametrized(touchpad_tap_n_drag_click, LITEST_CLICKPAD, LITEST_ANY, params);
5492 litest_add_parametrized(touchpad_tap_n_drag_draglock_tap_click, LITEST_CLICKPAD, LITEST_ANY, params);
5493
5494 litest_add_parametrized(touchpad_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY, params);
5495 litest_add_parametrized(touchpad_tap_n_drag_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5496 litest_add_parametrized(touchpad_tap_n_drag_2fg_scroll, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5497 litest_add_parametrized(touchpad_tap_n_drag_draglock_2fg_scroll, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5498 litest_add_parametrized(touchpad_tap_n_drag_3fg_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_APPLE_CLICKPAD, params);
5499 litest_add_parametrized(touchpad_tap_n_drag_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5500 litest_add_parametrized(touchpad_tap_n_drag_3fg_swipe, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5501 litest_add_parametrized(touchpad_tap_n_drag_draglock_3fg_swipe, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5502 litest_add_parametrized(touchpad_tap_n_drag_draglock, LITEST_TOUCHPAD, LITEST_ANY, params);
5503 litest_add_parametrized(touchpad_tap_n_drag_draglock_timeout, LITEST_TOUCHPAD, LITEST_ANY, params);
5504 litest_add_parametrized(touchpad_tap_n_drag_draglock_sticky, LITEST_TOUCHPAD, LITEST_ANY, params);
5505
5506 litest_add_parametrized(touchpad_drag_disabled, LITEST_TOUCHPAD, LITEST_ANY, params);
5507 litest_add_parametrized(touchpad_drag_disabled_immediate, LITEST_TOUCHPAD, LITEST_ANY, params);
5508 }
5509
5510 litest_with_parameters(params, "fingers_1st", 'i', 3, 1, 2, 3,
5511 "fingers_2nd", 'i', 3, 1, 2, 3) {
5512 litest_add_parametrized(touchpad_tap_n_drag_draglock_tap, LITEST_TOUCHPAD, LITEST_ANY, params);
5513 }
5514
5515 litest_add(touchpad_drag_default_disabled, LITEST_ANY, LITEST_TOUCHPAD);
5516 litest_add(touchpad_drag_default_enabled, LITEST_TOUCHPAD, LITEST_BUTTON);
5517 litest_add(touchpad_drag_config_invalid, LITEST_TOUCHPAD, LITEST_ANY);
5518 litest_add(touchpad_drag_config_unsupported, LITEST_ANY, LITEST_TOUCHPAD);
5519 litest_add(touchpad_drag_config_enabledisable, LITEST_TOUCHPAD, LITEST_ANY);
5520 /* clang-format on */
5521 }
5522
5523 TEST_COLLECTION(touchpad_tap_palm)
5524 {
5525 /* clang-format off */
5526 litest_add(touchpad_tap_palm_on_idle, LITEST_TOUCHPAD, LITEST_ANY);
5527 litest_add(touchpad_tap_palm_on_touch, LITEST_TOUCHPAD, LITEST_ANY);
5528 litest_add(touchpad_tap_palm_on_touch_hold_timeout, LITEST_TOUCHPAD, LITEST_ANY);
5529 litest_add(touchpad_tap_palm_on_touch_hold_move, LITEST_TOUCHPAD, LITEST_ANY);
5530
5531 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3) {
5532 litest_add_parametrized(touchpad_tap_palm_on_tapped, LITEST_TOUCHPAD, LITEST_ANY, params);
5533 litest_add_parametrized(touchpad_tap_palm_on_tapped_palm_down, LITEST_TOUCHPAD, LITEST_ANY, params);
5534 litest_add_parametrized(touchpad_tap_palm_on_drag, LITEST_TOUCHPAD, LITEST_ANY, params);
5535 litest_add_parametrized(touchpad_tap_palm_after_tap, LITEST_TOUCHPAD, LITEST_ANY, params);
5536 }
5537
5538 litest_with_parameters(params, "fingers_1st", 'i', 3, 1, 2, 3,
5539 "fingers_2nd", 'i', 3, 1, 2, 3) {
5540 litest_add_parametrized(touchpad_tap_palm_on_tapped_doubletap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5541 }
5542
5543 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3,
5544 "which", 'I', 2, litest_named_i32(0, "first"), litest_named_i32(1, "second")) {
5545 litest_add_parametrized(touchpad_tap_palm_on_drag_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5546 }
5547
5548 litest_with_parameters(params, "which", 'I', 2, litest_named_i32(0, "first"), litest_named_i32(1, "second")) {
5549 litest_add_parametrized(touchpad_tap_palm_on_touch_2, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5550 litest_add_parametrized(touchpad_tap_palm_on_touch_2_retouch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5551 }
5552
5553 litest_with_parameters(params, "which", 'I', 3, litest_named_i32(0, "first"), litest_named_i32(1, "second"),
5554 litest_named_i32(2, "third")) {
5555 litest_add_parametrized(touchpad_tap_palm_on_touch_3, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5556 litest_add_parametrized(touchpad_tap_palm_on_touch_3_retouch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5557 }
5558
5559 litest_with_parameters(params, "which", 'I', 4, litest_named_i32(0, "first"), litest_named_i32(1, "second"),
5560 litest_named_i32(2, "third"), litest_named_i32(3, "fourth")) {
5561 litest_add_parametrized(touchpad_tap_palm_on_touch_4, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5562 }
5563
5564 litest_with_parameters(params, "fingers", 'i', 3, 1, 2, 3,
5565 "taps", 'i', 3, 3, 4, 5) {
5566 litest_add_parametrized(touchpad_tap_palm_multitap, LITEST_TOUCHPAD, LITEST_ANY, params);
5567 litest_add_parametrized(touchpad_tap_palm_multitap_timeout, LITEST_TOUCHPAD, LITEST_ANY, params);
5568 litest_add_parametrized(touchpad_tap_palm_multitap_down_again, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, params);
5569 litest_add_parametrized(touchpad_tap_palm_multitap_click, LITEST_CLICKPAD, LITEST_ANY, params);
5570 }
5571
5572 litest_add(touchpad_tap_palm_click_then_tap, LITEST_CLICKPAD, LITEST_ANY);
5573 litest_add(touchpad_tap_palm_dwt_tap, LITEST_TOUCHPAD, LITEST_ANY);
5574 litest_add(touchpad_tap_palm_3fg_start, LITEST_TOUCHPAD, LITEST_ANY);
5575 /* clang-format on */
5576 }