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