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
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_1fg_doubletap)59 START_TEST(touchpad_1fg_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
67 litest_enable_tap(dev->libinput_device);
68
69 litest_drain_events(li);
70
71 litest_touch_down(dev, 0, 50, 50);
72 msleep(10);
73 litest_touch_up(dev, 0);
74 msleep(10);
75 litest_touch_down(dev, 0, 50, 50);
76 msleep(10);
77 litest_touch_up(dev, 0);
78 libinput_dispatch(li);
79
80 litest_timeout_tap();
81
82 libinput_dispatch(li);
83 event = libinput_get_event(li);
84 ptrev = litest_is_button_event(event,
85 BTN_LEFT,
86 LIBINPUT_BUTTON_STATE_PRESSED);
87 oldtime = libinput_event_pointer_get_time(ptrev);
88 libinput_event_destroy(event);
89
90 event = libinput_get_event(li);
91 ptrev = litest_is_button_event(event,
92 BTN_LEFT,
93 LIBINPUT_BUTTON_STATE_RELEASED);
94 curtime = libinput_event_pointer_get_time(ptrev);
95 libinput_event_destroy(event);
96 ck_assert_int_lt(oldtime, curtime);
97
98 event = libinput_get_event(li);
99 ptrev = litest_is_button_event(event,
100 BTN_LEFT,
101 LIBINPUT_BUTTON_STATE_PRESSED);
102 curtime = libinput_event_pointer_get_time(ptrev);
103 libinput_event_destroy(event);
104 ck_assert_int_lt(oldtime, curtime);
105 oldtime = curtime;
106
107 event = libinput_get_event(li);
108 ptrev = litest_is_button_event(event,
109 BTN_LEFT,
110 LIBINPUT_BUTTON_STATE_RELEASED);
111 curtime = libinput_event_pointer_get_time(ptrev);
112 libinput_event_destroy(event);
113 ck_assert_int_lt(oldtime, curtime);
114
115 litest_assert_empty_queue(li);
116 }
117 END_TEST
118
START_TEST(touchpad_1fg_multitap)119 START_TEST(touchpad_1fg_multitap)
120 {
121 struct litest_device *dev = litest_current_device();
122 struct libinput *li = dev->libinput;
123 struct libinput_event *event;
124 struct libinput_event_pointer *ptrev;
125 uint32_t oldtime = 0,
126 curtime;
127 int range = _i, /* looped test */
128 ntaps;
129
130 litest_enable_tap(dev->libinput_device);
131 litest_enable_drag_lock(dev->libinput_device);
132
133 litest_drain_events(li);
134
135 for (ntaps = 0; ntaps <= range; ntaps++) {
136 litest_touch_down(dev, 0, 50, 50);
137 litest_touch_up(dev, 0);
138 libinput_dispatch(li);
139 msleep(10);
140 }
141
142 litest_timeout_tap();
143 libinput_dispatch(li);
144
145 for (ntaps = 0; ntaps <= range; ntaps++) {
146 event = libinput_get_event(li);
147 ptrev = litest_is_button_event(event,
148 BTN_LEFT,
149 LIBINPUT_BUTTON_STATE_PRESSED);
150 curtime = libinput_event_pointer_get_time(ptrev);
151 libinput_event_destroy(event);
152 ck_assert_int_gt(curtime, oldtime);
153
154 event = libinput_get_event(li);
155 ptrev = litest_is_button_event(event,
156 BTN_LEFT,
157 LIBINPUT_BUTTON_STATE_RELEASED);
158 curtime = libinput_event_pointer_get_time(ptrev);
159 libinput_event_destroy(event);
160 ck_assert_int_ge(curtime, oldtime);
161 oldtime = curtime;
162 }
163 litest_timeout_tap();
164 litest_assert_empty_queue(li);
165 }
166 END_TEST
167
START_TEST(touchpad_1fg_multitap_n_drag_move)168 START_TEST(touchpad_1fg_multitap_n_drag_move)
169 {
170 struct litest_device *dev = litest_current_device();
171 struct libinput *li = dev->libinput;
172 struct libinput_event *event;
173 struct libinput_event_pointer *ptrev;
174 uint32_t oldtime = 0,
175 curtime;
176 int range = _i, /* looped test */
177 ntaps;
178
179 litest_enable_tap(dev->libinput_device);
180 litest_enable_drag_lock(dev->libinput_device);
181
182 litest_drain_events(li);
183
184 for (ntaps = 0; ntaps <= range; ntaps++) {
185 litest_touch_down(dev, 0, 50, 50);
186 litest_touch_up(dev, 0);
187 libinput_dispatch(li);
188 msleep(10);
189 }
190
191 libinput_dispatch(li);
192 litest_touch_down(dev, 0, 50, 50);
193 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
194 libinput_dispatch(li);
195
196 for (ntaps = 0; ntaps < range; ntaps++) {
197 event = libinput_get_event(li);
198 ptrev = litest_is_button_event(event,
199 BTN_LEFT,
200 LIBINPUT_BUTTON_STATE_PRESSED);
201 curtime = libinput_event_pointer_get_time(ptrev);
202 libinput_event_destroy(event);
203 ck_assert_int_gt(curtime, oldtime);
204
205 event = libinput_get_event(li);
206 ptrev = litest_is_button_event(event,
207 BTN_LEFT,
208 LIBINPUT_BUTTON_STATE_RELEASED);
209 curtime = libinput_event_pointer_get_time(ptrev);
210 libinput_event_destroy(event);
211 ck_assert_int_ge(curtime, oldtime);
212 oldtime = curtime;
213 }
214
215 event = libinput_get_event(li);
216 ptrev = litest_is_button_event(event,
217 BTN_LEFT,
218 LIBINPUT_BUTTON_STATE_PRESSED);
219 curtime = libinput_event_pointer_get_time(ptrev);
220 libinput_event_destroy(event);
221 ck_assert_int_gt(curtime, oldtime);
222
223 litest_assert_only_typed_events(li,
224 LIBINPUT_EVENT_POINTER_MOTION);
225
226 litest_touch_up(dev, 0);
227 litest_assert_button_event(li,
228 BTN_LEFT,
229 LIBINPUT_BUTTON_STATE_RELEASED);
230
231 litest_assert_empty_queue(li);
232 }
233 END_TEST
234
START_TEST(touchpad_1fg_multitap_n_drag_2fg)235 START_TEST(touchpad_1fg_multitap_n_drag_2fg)
236 {
237 struct litest_device *dev = litest_current_device();
238 struct libinput *li = dev->libinput;
239 struct libinput_event *event;
240 struct libinput_event_pointer *ptrev;
241 uint32_t oldtime = 0,
242 curtime;
243 int range = _i,
244 ntaps;
245
246 if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT))
247 return;
248
249 litest_enable_tap(dev->libinput_device);
250 litest_enable_drag_lock(dev->libinput_device);
251
252 litest_drain_events(li);
253
254 for (ntaps = 0; ntaps <= range; ntaps++) {
255 litest_touch_down(dev, 0, 50, 50);
256 litest_touch_up(dev, 0);
257 libinput_dispatch(li);
258 msleep(10);
259 }
260
261 libinput_dispatch(li);
262 litest_touch_down(dev, 0, 50, 50);
263 msleep(10);
264 litest_touch_down(dev, 1, 70, 50);
265 libinput_dispatch(li);
266
267 for (ntaps = 0; ntaps < range; ntaps++) {
268 event = libinput_get_event(li);
269 ptrev = litest_is_button_event(event,
270 BTN_LEFT,
271 LIBINPUT_BUTTON_STATE_PRESSED);
272 curtime = libinput_event_pointer_get_time(ptrev);
273 libinput_event_destroy(event);
274 ck_assert_int_gt(curtime, oldtime);
275
276 event = libinput_get_event(li);
277 ptrev = litest_is_button_event(event,
278 BTN_LEFT,
279 LIBINPUT_BUTTON_STATE_RELEASED);
280 curtime = libinput_event_pointer_get_time(ptrev);
281 libinput_event_destroy(event);
282 ck_assert_int_ge(curtime, oldtime);
283 oldtime = curtime;
284 }
285
286 event = libinput_get_event(li);
287 ptrev = litest_is_button_event(event,
288 BTN_LEFT,
289 LIBINPUT_BUTTON_STATE_PRESSED);
290 curtime = libinput_event_pointer_get_time(ptrev);
291 libinput_event_destroy(event);
292 ck_assert_int_gt(curtime, oldtime);
293
294 litest_touch_move_to(dev, 1, 70, 50, 90, 50, 10);
295
296 litest_assert_only_typed_events(li,
297 LIBINPUT_EVENT_POINTER_MOTION);
298
299 litest_touch_up(dev, 1);
300 litest_touch_up(dev, 0);
301 litest_timeout_tap();
302 litest_assert_button_event(li,
303 BTN_LEFT,
304 LIBINPUT_BUTTON_STATE_RELEASED);
305
306 litest_assert_empty_queue(li);
307 }
308 END_TEST
309
START_TEST(touchpad_1fg_multitap_n_drag_click)310 START_TEST(touchpad_1fg_multitap_n_drag_click)
311 {
312 struct litest_device *dev = litest_current_device();
313 struct libinput *li = dev->libinput;
314 struct libinput_event *event;
315 struct libinput_event_pointer *ptrev;
316 uint32_t oldtime = 0,
317 curtime;
318 int range = _i, /* looped test */
319 ntaps;
320
321 litest_enable_tap(dev->libinput_device);
322 litest_enable_drag_lock(dev->libinput_device);
323
324 litest_drain_events(li);
325
326 for (ntaps = 0; ntaps <= range; ntaps++) {
327 litest_touch_down(dev, 0, 50, 50);
328 litest_touch_up(dev, 0);
329 libinput_dispatch(li);
330 msleep(10);
331 }
332
333 litest_touch_down(dev, 0, 50, 50);
334 libinput_dispatch(li);
335 litest_button_click(dev, BTN_LEFT, true);
336 litest_button_click(dev, BTN_LEFT, false);
337 libinput_dispatch(li);
338
339 for (ntaps = 0; ntaps <= range; ntaps++) {
340 event = libinput_get_event(li);
341 ptrev = litest_is_button_event(event,
342 BTN_LEFT,
343 LIBINPUT_BUTTON_STATE_PRESSED);
344 curtime = libinput_event_pointer_get_time(ptrev);
345 libinput_event_destroy(event);
346 ck_assert_int_gt(curtime, oldtime);
347
348 event = libinput_get_event(li);
349 ptrev = litest_is_button_event(event,
350 BTN_LEFT,
351 LIBINPUT_BUTTON_STATE_RELEASED);
352 curtime = libinput_event_pointer_get_time(ptrev);
353 libinput_event_destroy(event);
354 ck_assert_int_ge(curtime, oldtime);
355 oldtime = curtime;
356 }
357
358 litest_assert_button_event(li,
359 BTN_LEFT,
360 LIBINPUT_BUTTON_STATE_PRESSED);
361 litest_assert_button_event(li,
362 BTN_LEFT,
363 LIBINPUT_BUTTON_STATE_RELEASED);
364 litest_touch_up(dev, 0);
365 litest_timeout_tap();
366
367 litest_assert_empty_queue(li);
368 }
369 END_TEST
370
START_TEST(touchpad_1fg_multitap_timeout)371 START_TEST(touchpad_1fg_multitap_timeout)
372 {
373 struct litest_device *dev = litest_current_device();
374 struct libinput *li = dev->libinput;
375 struct libinput_event *event;
376 struct libinput_event_pointer *ptrev;
377 uint32_t ptime, rtime;
378 int range = _i, /* looped test */
379 ntaps;
380
381 litest_enable_tap(dev->libinput_device);
382 litest_enable_drag_lock(dev->libinput_device);
383
384 litest_drain_events(li);
385
386 for (ntaps = 0; ntaps <= range; ntaps++) {
387 litest_touch_down(dev, 0, 50, 50);
388 msleep(10);
389 litest_touch_up(dev, 0);
390 libinput_dispatch(li);
391 msleep(10);
392 }
393
394 libinput_dispatch(li);
395 litest_timeout_tap();
396 libinput_dispatch(li);
397
398 for (ntaps = 0; ntaps <= range; ntaps++) {
399 event = libinput_get_event(li);
400 ptrev = litest_is_button_event(event,
401 BTN_LEFT,
402 LIBINPUT_BUTTON_STATE_PRESSED);
403 ptime = libinput_event_pointer_get_time(ptrev);
404 libinput_event_destroy(event);
405
406 event = libinput_get_event(li);
407 ptrev = litest_is_button_event(event,
408 BTN_LEFT,
409 LIBINPUT_BUTTON_STATE_RELEASED);
410 rtime = libinput_event_pointer_get_time(ptrev);
411 libinput_event_destroy(event);
412 ck_assert_int_lt(ptime, rtime);
413 }
414
415 litest_assert_empty_queue(li);
416 }
417 END_TEST
418
START_TEST(touchpad_1fg_multitap_n_drag_timeout)419 START_TEST(touchpad_1fg_multitap_n_drag_timeout)
420 {
421 struct litest_device *dev = litest_current_device();
422 struct libinput *li = dev->libinput;
423 struct libinput_event *event;
424 struct libinput_event_pointer *ptrev;
425 uint32_t oldtime = 0,
426 curtime;
427 int range = _i, /* looped test */
428 ntaps;
429
430 litest_enable_tap(dev->libinput_device);
431 litest_enable_drag_lock(dev->libinput_device);
432
433 litest_drain_events(li);
434
435 for (ntaps = 0; ntaps <= range; ntaps++) {
436 litest_touch_down(dev, 0, 50, 50);
437 msleep(10);
438 litest_touch_up(dev, 0);
439 libinput_dispatch(li);
440 msleep(10);
441 }
442
443 libinput_dispatch(li);
444 litest_touch_down(dev, 0, 50, 50);
445 libinput_dispatch(li);
446
447 litest_timeout_tap();
448 libinput_dispatch(li);
449
450 for (ntaps = 0; ntaps < range; ntaps++) {
451 event = libinput_get_event(li);
452 ptrev = litest_is_button_event(event,
453 BTN_LEFT,
454 LIBINPUT_BUTTON_STATE_PRESSED);
455 curtime = libinput_event_pointer_get_time(ptrev);
456 libinput_event_destroy(event);
457 ck_assert_int_gt(curtime, oldtime);
458
459 event = libinput_get_event(li);
460 ptrev = litest_is_button_event(event,
461 BTN_LEFT,
462 LIBINPUT_BUTTON_STATE_RELEASED);
463 curtime = libinput_event_pointer_get_time(ptrev);
464 libinput_event_destroy(event);
465 ck_assert_int_gt(curtime, oldtime);
466 oldtime = curtime;
467 }
468
469 event = libinput_get_event(li);
470 ptrev = litest_is_button_event(event,
471 BTN_LEFT,
472 LIBINPUT_BUTTON_STATE_PRESSED);
473 curtime = libinput_event_pointer_get_time(ptrev);
474 libinput_event_destroy(event);
475 ck_assert_int_gt(curtime, oldtime);
476
477 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
478
479 litest_assert_only_typed_events(li,
480 LIBINPUT_EVENT_POINTER_MOTION);
481
482 litest_touch_up(dev, 0);
483 litest_assert_button_event(li,
484 BTN_LEFT,
485 LIBINPUT_BUTTON_STATE_RELEASED);
486
487 litest_assert_empty_queue(li);
488 }
489 END_TEST
490
START_TEST(touchpad_1fg_multitap_n_drag_tap)491 START_TEST(touchpad_1fg_multitap_n_drag_tap)
492 {
493 struct litest_device *dev = litest_current_device();
494 struct libinput *li = dev->libinput;
495 struct libinput_event *event;
496 struct libinput_event_pointer *ptrev;
497 uint32_t oldtime = 0,
498 curtime;
499 int range = _i, /* looped test */
500 ntaps;
501
502 litest_enable_tap(dev->libinput_device);
503 litest_enable_drag_lock(dev->libinput_device);
504
505 litest_drain_events(li);
506
507 for (ntaps = 0; ntaps <= range; ntaps++) {
508 litest_touch_down(dev, 0, 50, 50);
509 msleep(10);
510 litest_touch_up(dev, 0);
511 libinput_dispatch(li);
512 msleep(10);
513 }
514
515 libinput_dispatch(li);
516 litest_touch_down(dev, 0, 50, 50);
517 libinput_dispatch(li);
518
519 litest_timeout_tap();
520 libinput_dispatch(li);
521
522 for (ntaps = 0; ntaps < range; ntaps++) {
523 event = libinput_get_event(li);
524 ptrev = litest_is_button_event(event,
525 BTN_LEFT,
526 LIBINPUT_BUTTON_STATE_PRESSED);
527 curtime = libinput_event_pointer_get_time(ptrev);
528 libinput_event_destroy(event);
529 ck_assert_int_gt(curtime, oldtime);
530
531 event = libinput_get_event(li);
532 ptrev = litest_is_button_event(event,
533 BTN_LEFT,
534 LIBINPUT_BUTTON_STATE_RELEASED);
535 curtime = libinput_event_pointer_get_time(ptrev);
536 libinput_event_destroy(event);
537 ck_assert_int_ge(curtime, oldtime);
538 oldtime = curtime;
539 }
540
541 event = libinput_get_event(li);
542 ptrev = litest_is_button_event(event,
543 BTN_LEFT,
544 LIBINPUT_BUTTON_STATE_PRESSED);
545 curtime = libinput_event_pointer_get_time(ptrev);
546 libinput_event_destroy(event);
547 ck_assert_int_gt(curtime, oldtime);
548
549 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
550
551 litest_assert_only_typed_events(li,
552 LIBINPUT_EVENT_POINTER_MOTION);
553
554 litest_touch_up(dev, 0);
555 litest_touch_down(dev, 0, 70, 50);
556 litest_touch_up(dev, 0);
557 litest_assert_button_event(li,
558 BTN_LEFT,
559 LIBINPUT_BUTTON_STATE_RELEASED);
560
561 litest_assert_empty_queue(li);
562 }
563 END_TEST
564
START_TEST(touchpad_1fg_multitap_n_drag_tap_click)565 START_TEST(touchpad_1fg_multitap_n_drag_tap_click)
566 {
567 struct litest_device *dev = litest_current_device();
568 struct libinput *li = dev->libinput;
569 struct libinput_event *event;
570 struct libinput_event_pointer *ptrev;
571 uint32_t oldtime = 0,
572 curtime;
573 int range = _i, /* looped test */
574 ntaps;
575
576 litest_enable_tap(dev->libinput_device);
577 litest_enable_drag_lock(dev->libinput_device);
578
579 litest_drain_events(li);
580
581 for (ntaps = 0; ntaps <= range; ntaps++) {
582 litest_touch_down(dev, 0, 50, 50);
583 msleep(10);
584 litest_touch_up(dev, 0);
585 libinput_dispatch(li);
586 msleep(10);
587 }
588
589 libinput_dispatch(li);
590 litest_touch_down(dev, 0, 50, 50);
591 libinput_dispatch(li);
592
593 litest_timeout_tap();
594 libinput_dispatch(li);
595
596 for (ntaps = 0; ntaps < range; ntaps++) {
597 event = libinput_get_event(li);
598 ptrev = litest_is_button_event(event,
599 BTN_LEFT,
600 LIBINPUT_BUTTON_STATE_PRESSED);
601 curtime = libinput_event_pointer_get_time(ptrev);
602 libinput_event_destroy(event);
603 ck_assert_int_gt(curtime, oldtime);
604
605 event = libinput_get_event(li);
606 ptrev = litest_is_button_event(event,
607 BTN_LEFT,
608 LIBINPUT_BUTTON_STATE_RELEASED);
609 curtime = libinput_event_pointer_get_time(ptrev);
610 libinput_event_destroy(event);
611 ck_assert_int_ge(curtime, oldtime);
612 oldtime = curtime;
613 }
614
615 event = libinput_get_event(li);
616 ptrev = litest_is_button_event(event,
617 BTN_LEFT,
618 LIBINPUT_BUTTON_STATE_PRESSED);
619 curtime = libinput_event_pointer_get_time(ptrev);
620 libinput_event_destroy(event);
621 ck_assert_int_gt(curtime, oldtime);
622
623 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
624
625 litest_assert_only_typed_events(li,
626 LIBINPUT_EVENT_POINTER_MOTION);
627
628 litest_touch_up(dev, 0);
629 litest_touch_down(dev, 0, 70, 50);
630 litest_button_click(dev, BTN_LEFT, true);
631 litest_button_click(dev, BTN_LEFT, false);
632 libinput_dispatch(li);
633
634 litest_assert_button_event(li,
635 BTN_LEFT,
636 LIBINPUT_BUTTON_STATE_RELEASED);
637
638 /* the physical click */
639 litest_assert_button_event(li,
640 BTN_LEFT,
641 LIBINPUT_BUTTON_STATE_PRESSED);
642 litest_assert_button_event(li,
643 BTN_LEFT,
644 LIBINPUT_BUTTON_STATE_RELEASED);
645 litest_touch_up(dev, 0);
646
647 litest_assert_empty_queue(li);
648 }
649 END_TEST
650
START_TEST(touchpad_1fg_tap_n_drag)651 START_TEST(touchpad_1fg_tap_n_drag)
652 {
653 struct litest_device *dev = litest_current_device();
654 struct libinput *li = dev->libinput;
655 struct libinput_event *event;
656
657 litest_enable_tap(dev->libinput_device);
658 litest_disable_drag_lock(dev->libinput_device);
659
660 litest_drain_events(li);
661
662 litest_touch_down(dev, 0, 50, 50);
663 litest_touch_up(dev, 0);
664 litest_touch_down(dev, 0, 50, 50);
665 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
666
667 libinput_dispatch(li);
668
669 litest_assert_button_event(li, BTN_LEFT,
670 LIBINPUT_BUTTON_STATE_PRESSED);
671
672 libinput_dispatch(li);
673
674 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
675
676 litest_touch_up(dev, 0);
677
678 /* don't use helper functions here, we expect the event be available
679 * immediately, not after a timeout that the helper functions may
680 * trigger.
681 */
682 libinput_dispatch(li);
683 event = libinput_get_event(li);
684 ck_assert_notnull(event);
685 litest_is_button_event(event,
686 BTN_LEFT,
687 LIBINPUT_BUTTON_STATE_RELEASED);
688 libinput_event_destroy(event);
689
690 litest_assert_empty_queue(li);
691 }
692 END_TEST
693
START_TEST(touchpad_1fg_tap_n_drag_draglock)694 START_TEST(touchpad_1fg_tap_n_drag_draglock)
695 {
696 struct litest_device *dev = litest_current_device();
697 struct libinput *li = dev->libinput;
698
699 litest_enable_tap(dev->libinput_device);
700 litest_enable_drag_lock(dev->libinput_device);
701
702 litest_drain_events(li);
703
704 litest_touch_down(dev, 0, 50, 50);
705 litest_touch_up(dev, 0);
706 litest_touch_down(dev, 0, 50, 50);
707 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
708 litest_touch_up(dev, 0);
709
710 libinput_dispatch(li);
711
712 litest_assert_button_event(li, BTN_LEFT,
713 LIBINPUT_BUTTON_STATE_PRESSED);
714
715 libinput_dispatch(li);
716
717 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
718
719 /* lift finger, set down again, should continue dragging */
720 litest_touch_down(dev, 0, 50, 50);
721 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
722 litest_touch_up(dev, 0);
723
724 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
725
726 litest_timeout_tap();
727
728 litest_assert_button_event(li, BTN_LEFT,
729 LIBINPUT_BUTTON_STATE_RELEASED);
730
731 litest_assert_empty_queue(li);
732 }
733 END_TEST
734
START_TEST(touchpad_1fg_tap_n_drag_draglock_tap)735 START_TEST(touchpad_1fg_tap_n_drag_draglock_tap)
736 {
737 struct litest_device *dev = litest_current_device();
738 struct libinput *li = dev->libinput;
739
740 litest_enable_tap(dev->libinput_device);
741 litest_enable_drag_lock(dev->libinput_device);
742
743 litest_drain_events(li);
744
745 litest_touch_down(dev, 0, 50, 50);
746 litest_touch_up(dev, 0);
747 litest_touch_down(dev, 0, 50, 50);
748 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
749 litest_touch_up(dev, 0);
750
751 libinput_dispatch(li);
752
753 litest_assert_button_event(li, BTN_LEFT,
754 LIBINPUT_BUTTON_STATE_PRESSED);
755
756 libinput_dispatch(li);
757
758 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
759
760 /* lift finger, set down again, should continue dragging */
761 litest_touch_down(dev, 0, 50, 50);
762 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
763
764 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
765
766 litest_touch_up(dev, 0);
767 litest_touch_down(dev, 0, 50, 50);
768 litest_touch_up(dev, 0);
769
770 litest_assert_button_event(li, BTN_LEFT,
771 LIBINPUT_BUTTON_STATE_RELEASED);
772
773 litest_assert_empty_queue(li);
774 }
775 END_TEST
776
START_TEST(touchpad_1fg_tap_n_drag_draglock_tap_click)777 START_TEST(touchpad_1fg_tap_n_drag_draglock_tap_click)
778 {
779 struct litest_device *dev = litest_current_device();
780 struct libinput *li = dev->libinput;
781
782 litest_enable_tap(dev->libinput_device);
783 litest_enable_drag_lock(dev->libinput_device);
784
785 litest_drain_events(li);
786
787 litest_touch_down(dev, 0, 50, 50);
788 litest_touch_up(dev, 0);
789 litest_touch_down(dev, 0, 50, 50);
790 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
791 libinput_dispatch(li);
792
793 litest_assert_button_event(li, BTN_LEFT,
794 LIBINPUT_BUTTON_STATE_PRESSED);
795
796 libinput_dispatch(li);
797
798 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
799
800 litest_touch_up(dev, 0);
801 litest_touch_down(dev, 0, 50, 50);
802 litest_button_click(dev, BTN_LEFT, true);
803 litest_button_click(dev, BTN_LEFT, false);
804 libinput_dispatch(li);
805
806 litest_assert_button_event(li, BTN_LEFT,
807 LIBINPUT_BUTTON_STATE_RELEASED);
808
809 /* the physical click */
810 litest_assert_button_event(li,
811 BTN_LEFT,
812 LIBINPUT_BUTTON_STATE_PRESSED);
813 litest_assert_button_event(li,
814 BTN_LEFT,
815 LIBINPUT_BUTTON_STATE_RELEASED);
816 litest_touch_up(dev, 0);
817
818 litest_assert_empty_queue(li);
819 }
820 END_TEST
821
START_TEST(touchpad_1fg_tap_n_drag_draglock_timeout)822 START_TEST(touchpad_1fg_tap_n_drag_draglock_timeout)
823 {
824 struct litest_device *dev = litest_current_device();
825 struct libinput *li = dev->libinput;
826
827 litest_enable_tap(dev->libinput_device);
828 litest_enable_drag_lock(dev->libinput_device);
829
830 litest_drain_events(li);
831
832 litest_touch_down(dev, 0, 50, 50);
833 litest_touch_up(dev, 0);
834 litest_touch_down(dev, 0, 50, 50);
835 libinput_dispatch(li);
836 litest_timeout_tap();
837
838 litest_assert_button_event(li, BTN_LEFT,
839 LIBINPUT_BUTTON_STATE_PRESSED);
840
841 litest_assert_empty_queue(li);
842 litest_touch_up(dev, 0);
843 libinput_dispatch(li);
844
845 litest_timeout_tapndrag();
846 litest_assert_button_event(li, BTN_LEFT,
847 LIBINPUT_BUTTON_STATE_RELEASED);
848
849 litest_assert_empty_queue(li);
850 }
851 END_TEST
852
START_TEST(touchpad_2fg_tap_n_drag)853 START_TEST(touchpad_2fg_tap_n_drag)
854 {
855 struct litest_device *dev = litest_current_device();
856 struct libinput *li = dev->libinput;
857
858 litest_enable_tap(dev->libinput_device);
859 litest_disable_drag_lock(dev->libinput_device);
860
861 litest_drain_events(li);
862
863 litest_touch_down(dev, 0, 30, 70);
864 litest_touch_up(dev, 0);
865 litest_touch_down(dev, 0, 30, 70);
866 litest_touch_down(dev, 1, 80, 70);
867 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
868 libinput_dispatch(li);
869
870 litest_assert_button_event(li, BTN_LEFT,
871 LIBINPUT_BUTTON_STATE_PRESSED);
872
873 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
874
875 litest_touch_up(dev, 0);
876 litest_touch_up(dev, 1);
877
878 litest_assert_button_event(li, BTN_LEFT,
879 LIBINPUT_BUTTON_STATE_RELEASED);
880
881 litest_assert_empty_queue(li);
882 }
883 END_TEST
884
START_TEST(touchpad_2fg_tap_n_drag_3fg_btntool)885 START_TEST(touchpad_2fg_tap_n_drag_3fg_btntool)
886 {
887 struct litest_device *dev = litest_current_device();
888 struct libinput *li = dev->libinput;
889
890 if (libevdev_get_abs_maximum(dev->evdev,
891 ABS_MT_SLOT) > 2)
892 return;
893
894 litest_enable_tap(dev->libinput_device);
895
896 litest_drain_events(li);
897
898 litest_touch_down(dev, 0, 30, 70);
899 litest_touch_up(dev, 0);
900 litest_touch_down(dev, 0, 30, 70);
901 litest_touch_down(dev, 1, 80, 90);
902 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 5);
903 libinput_dispatch(li);
904
905 litest_assert_button_event(li, BTN_LEFT,
906 LIBINPUT_BUTTON_STATE_PRESSED);
907
908 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
909
910 /* Putting down a third finger should end the drag */
911 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
912 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
913 litest_event(dev, EV_SYN, SYN_REPORT, 0);
914 libinput_dispatch(li);
915
916 litest_assert_button_event(li, BTN_LEFT,
917 LIBINPUT_BUTTON_STATE_RELEASED);
918
919 /* Releasing the fingers should not cause any events */
920 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
921 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
922 litest_event(dev, EV_SYN, SYN_REPORT, 0);
923 litest_touch_up(dev, 1);
924 litest_touch_up(dev, 0);
925
926 litest_assert_empty_queue(li);
927 }
928 END_TEST
929
START_TEST(touchpad_2fg_tap_n_drag_3fg)930 START_TEST(touchpad_2fg_tap_n_drag_3fg)
931 {
932 struct litest_device *dev = litest_current_device();
933 struct libinput *li = dev->libinput;
934
935 if (libevdev_get_abs_maximum(dev->evdev,
936 ABS_MT_SLOT) <= 2)
937 return;
938
939 litest_enable_tap(dev->libinput_device);
940
941 litest_drain_events(li);
942
943 litest_touch_down(dev, 0, 30, 70);
944 litest_touch_up(dev, 0);
945 litest_touch_down(dev, 0, 30, 70);
946 litest_touch_down(dev, 1, 80, 90);
947 litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
948 libinput_dispatch(li);
949
950 litest_assert_button_event(li, BTN_LEFT,
951 LIBINPUT_BUTTON_STATE_PRESSED);
952
953 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
954
955 /* Putting down a third finger should end the drag */
956 litest_touch_down(dev, 2, 50, 50);
957
958 libinput_dispatch(li);
959
960 litest_assert_button_event(li, BTN_LEFT,
961 LIBINPUT_BUTTON_STATE_RELEASED);
962
963 /* Releasing the fingers should not cause any events */
964 litest_touch_up(dev, 2);
965 litest_touch_up(dev, 1);
966 litest_touch_up(dev, 0);
967
968 litest_assert_empty_queue(li);
969 }
970 END_TEST
971
START_TEST(touchpad_2fg_tap)972 START_TEST(touchpad_2fg_tap)
973 {
974 struct litest_device *dev = litest_current_device();
975 struct libinput *li = dev->libinput;
976 enum libinput_config_tap_button_map map = _i; /* ranged test */
977 unsigned int button = 0;
978 struct libinput_event *ev;
979 struct libinput_event_pointer *ptrev;
980 uint64_t ptime, rtime;
981
982 litest_enable_tap(dev->libinput_device);
983 litest_set_tap_map(dev->libinput_device, map);
984
985 switch (map) {
986 case LIBINPUT_CONFIG_TAP_MAP_LRM:
987 button = BTN_RIGHT;
988 break;
989 case LIBINPUT_CONFIG_TAP_MAP_LMR:
990 button = BTN_MIDDLE;
991 break;
992 default:
993 litest_abort_msg("Invalid map range %d", map);
994 }
995
996 litest_drain_events(dev->libinput);
997
998 litest_touch_down(dev, 0, 50, 50);
999 litest_touch_down(dev, 1, 70, 70);
1000 litest_touch_up(dev, 0);
1001 litest_touch_up(dev, 1);
1002
1003 libinput_dispatch(li);
1004
1005 ev = libinput_get_event(li);
1006 ptrev = litest_is_button_event(ev,
1007 button,
1008 LIBINPUT_BUTTON_STATE_PRESSED);
1009 ptime = libinput_event_pointer_get_time_usec(ptrev);
1010 libinput_event_destroy(ev);
1011 ev = libinput_get_event(li);
1012 ptrev = litest_is_button_event(ev,
1013 button,
1014 LIBINPUT_BUTTON_STATE_RELEASED);
1015 rtime = libinput_event_pointer_get_time_usec(ptrev);
1016 libinput_event_destroy(ev);
1017
1018 ck_assert_int_lt(ptime, rtime);
1019
1020 litest_assert_empty_queue(li);
1021 }
1022 END_TEST
1023
START_TEST(touchpad_2fg_tap_inverted)1024 START_TEST(touchpad_2fg_tap_inverted)
1025 {
1026 struct litest_device *dev = litest_current_device();
1027 struct libinput *li = dev->libinput;
1028 enum libinput_config_tap_button_map map = _i; /* ranged test */
1029 unsigned int button = 0;
1030 struct libinput_event *ev;
1031 struct libinput_event_pointer *ptrev;
1032 uint64_t ptime, rtime;
1033
1034 litest_enable_tap(dev->libinput_device);
1035 litest_set_tap_map(dev->libinput_device, map);
1036
1037 switch (map) {
1038 case LIBINPUT_CONFIG_TAP_MAP_LRM:
1039 button = BTN_RIGHT;
1040 break;
1041 case LIBINPUT_CONFIG_TAP_MAP_LMR:
1042 button = BTN_MIDDLE;
1043 break;
1044 default:
1045 litest_abort_msg("Invalid map range %d", map);
1046 }
1047
1048 litest_drain_events(dev->libinput);
1049
1050 litest_touch_down(dev, 0, 50, 50);
1051 litest_touch_down(dev, 1, 70, 70);
1052 litest_touch_up(dev, 1);
1053 litest_touch_up(dev, 0);
1054
1055 libinput_dispatch(li);
1056
1057 ev = libinput_get_event(li);
1058 ptrev = litest_is_button_event(ev,
1059 button,
1060 LIBINPUT_BUTTON_STATE_PRESSED);
1061 ptime = libinput_event_pointer_get_time_usec(ptrev);
1062 libinput_event_destroy(ev);
1063 ev = libinput_get_event(li);
1064 ptrev = litest_is_button_event(ev,
1065 button,
1066 LIBINPUT_BUTTON_STATE_RELEASED);
1067 rtime = libinput_event_pointer_get_time_usec(ptrev);
1068 libinput_event_destroy(ev);
1069
1070 ck_assert_int_lt(ptime, rtime);
1071
1072 litest_assert_empty_queue(li);
1073 }
1074 END_TEST
1075
START_TEST(touchpad_2fg_tap_move_on_release)1076 START_TEST(touchpad_2fg_tap_move_on_release)
1077 {
1078 struct litest_device *dev = litest_current_device();
1079 struct libinput *li = dev->libinput;
1080
1081 litest_enable_tap(dev->libinput_device);
1082 litest_drain_events(dev->libinput);
1083
1084 litest_touch_down(dev, 0, 50, 50);
1085 litest_touch_down(dev, 1, 70, 70);
1086
1087 litest_push_event_frame(dev);
1088 litest_touch_move(dev, 0, 55, 55);
1089 litest_touch_up(dev, 1);
1090 litest_pop_event_frame(dev);
1091
1092 litest_touch_up(dev, 0);
1093
1094 libinput_dispatch(li);
1095
1096 litest_assert_button_event(li,
1097 BTN_RIGHT,
1098 LIBINPUT_BUTTON_STATE_PRESSED);
1099 litest_assert_button_event(li,
1100 BTN_RIGHT,
1101 LIBINPUT_BUTTON_STATE_RELEASED);
1102
1103 litest_assert_empty_queue(li);
1104 }
1105 END_TEST
1106
START_TEST(touchpad_2fg_tap_n_hold_first)1107 START_TEST(touchpad_2fg_tap_n_hold_first)
1108 {
1109 struct litest_device *dev = litest_current_device();
1110 struct libinput *li = dev->libinput;
1111
1112 litest_enable_tap(dev->libinput_device);
1113
1114 litest_drain_events(dev->libinput);
1115
1116 litest_touch_down(dev, 0, 50, 50);
1117 litest_touch_down(dev, 1, 70, 70);
1118 litest_touch_up(dev, 1);
1119
1120 libinput_dispatch(li);
1121
1122 litest_assert_empty_queue(li);
1123 litest_timeout_tap();
1124
1125 litest_assert_empty_queue(li);
1126 }
1127 END_TEST
1128
START_TEST(touchpad_2fg_tap_n_hold_second)1129 START_TEST(touchpad_2fg_tap_n_hold_second)
1130 {
1131 struct litest_device *dev = litest_current_device();
1132 struct libinput *li = dev->libinput;
1133
1134 litest_enable_tap(dev->libinput_device);
1135
1136 litest_drain_events(dev->libinput);
1137
1138 litest_touch_down(dev, 0, 50, 50);
1139 litest_touch_down(dev, 1, 70, 70);
1140 litest_touch_up(dev, 0);
1141
1142 libinput_dispatch(li);
1143
1144 litest_assert_empty_queue(li);
1145 litest_timeout_tap();
1146
1147 litest_assert_empty_queue(li);
1148 }
1149 END_TEST
1150
START_TEST(touchpad_2fg_tap_quickrelease)1151 START_TEST(touchpad_2fg_tap_quickrelease)
1152 {
1153 struct litest_device *dev = litest_current_device();
1154 struct libinput *li = dev->libinput;
1155
1156 litest_enable_tap(dev->libinput_device);
1157
1158 litest_drain_events(dev->libinput);
1159
1160 litest_touch_down(dev, 0, 50, 50);
1161 litest_touch_down(dev, 1, 70, 70);
1162 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1163 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1164 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1165 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1166 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1167 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
1168 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1169
1170 libinput_dispatch(li);
1171
1172 litest_assert_button_event(li, BTN_RIGHT,
1173 LIBINPUT_BUTTON_STATE_PRESSED);
1174 litest_timeout_tap();
1175 litest_assert_button_event(li, BTN_RIGHT,
1176 LIBINPUT_BUTTON_STATE_RELEASED);
1177
1178 litest_assert_empty_queue(li);
1179 }
1180 END_TEST
1181
START_TEST(touchpad_1fg_tap_click)1182 START_TEST(touchpad_1fg_tap_click)
1183 {
1184 struct litest_device *dev = litest_current_device();
1185 struct libinput *li = dev->libinput;
1186
1187 litest_enable_tap(dev->libinput_device);
1188
1189 litest_drain_events(dev->libinput);
1190
1191 /* Finger down, finger up -> tap button press
1192 * Physical button click -> no button press/release
1193 * Tap timeout -> tap button release */
1194 litest_touch_down(dev, 0, 50, 50);
1195 litest_touch_up(dev, 0);
1196 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1197 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1198 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1199 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1200 libinput_dispatch(li);
1201 litest_timeout_tap();
1202
1203 libinput_dispatch(li);
1204
1205 litest_assert_button_event(li, BTN_LEFT,
1206 LIBINPUT_BUTTON_STATE_PRESSED);
1207 litest_assert_button_event(li, BTN_LEFT,
1208 LIBINPUT_BUTTON_STATE_RELEASED);
1209
1210 litest_assert_empty_queue(li);
1211 }
1212 END_TEST
1213
START_TEST(touchpad_2fg_tap_click)1214 START_TEST(touchpad_2fg_tap_click)
1215 {
1216 struct litest_device *dev = litest_current_device();
1217 struct libinput *li = dev->libinput;
1218
1219 litest_enable_tap(dev->libinput_device);
1220
1221 litest_drain_events(dev->libinput);
1222
1223 /* two fingers down, left button click, fingers up
1224 -> one left button, one right button event pair */
1225 litest_touch_down(dev, 0, 50, 50);
1226 litest_touch_down(dev, 1, 70, 50);
1227 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1228 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1229 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1230 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1231 litest_touch_up(dev, 1);
1232 litest_touch_up(dev, 0);
1233
1234 libinput_dispatch(li);
1235
1236 litest_assert_button_event(li, BTN_LEFT,
1237 LIBINPUT_BUTTON_STATE_PRESSED);
1238 litest_assert_button_event(li, BTN_LEFT,
1239 LIBINPUT_BUTTON_STATE_RELEASED);
1240 litest_assert_button_event(li, BTN_RIGHT,
1241 LIBINPUT_BUTTON_STATE_PRESSED);
1242 litest_assert_button_event(li, BTN_RIGHT,
1243 LIBINPUT_BUTTON_STATE_RELEASED);
1244
1245 litest_assert_empty_queue(li);
1246 }
1247 END_TEST
1248
START_TEST(clickpad_2fg_tap_click)1249 START_TEST(clickpad_2fg_tap_click)
1250 {
1251 struct litest_device *dev = litest_current_device();
1252 struct libinput *li = dev->libinput;
1253
1254 litest_enable_tap(dev->libinput_device);
1255
1256 litest_drain_events(dev->libinput);
1257
1258 /* two fingers down, button click, fingers up
1259 -> only one button left event pair */
1260 litest_touch_down(dev, 0, 50, 50);
1261 litest_touch_down(dev, 1, 70, 50);
1262 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1263 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1264 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1265 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1266 litest_touch_up(dev, 1);
1267 litest_touch_up(dev, 0);
1268
1269 libinput_dispatch(li);
1270
1271 litest_assert_button_event(li, BTN_LEFT,
1272 LIBINPUT_BUTTON_STATE_PRESSED);
1273 litest_assert_button_event(li, BTN_LEFT,
1274 LIBINPUT_BUTTON_STATE_RELEASED);
1275
1276 litest_assert_empty_queue(li);
1277 }
1278 END_TEST
1279
START_TEST(touchpad_2fg_tap_click_apple)1280 START_TEST(touchpad_2fg_tap_click_apple)
1281 {
1282 struct litest_device *dev = litest_current_device();
1283 struct libinput *li = dev->libinput;
1284
1285 litest_enable_tap(dev->libinput_device);
1286
1287 litest_drain_events(dev->libinput);
1288
1289 /* two fingers down, button click, fingers up
1290 -> only one button right event pair
1291 (apple have clickfinger enabled by default) */
1292 litest_touch_down(dev, 0, 50, 50);
1293 litest_touch_down(dev, 1, 70, 50);
1294 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1295 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1296 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1297 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1298 litest_touch_up(dev, 1);
1299 litest_touch_up(dev, 0);
1300
1301 libinput_dispatch(li);
1302
1303 litest_assert_button_event(li, BTN_RIGHT,
1304 LIBINPUT_BUTTON_STATE_PRESSED);
1305 litest_assert_button_event(li, BTN_RIGHT,
1306 LIBINPUT_BUTTON_STATE_RELEASED);
1307
1308 litest_assert_empty_queue(li);
1309 }
1310 END_TEST
1311
START_TEST(touchpad_no_2fg_tap_after_move)1312 START_TEST(touchpad_no_2fg_tap_after_move)
1313 {
1314 struct litest_device *dev = litest_current_device();
1315 struct libinput *li = dev->libinput;
1316
1317 litest_enable_tap(dev->libinput_device);
1318 litest_drain_events(dev->libinput);
1319
1320 /* one finger down, move past threshold,
1321 second finger down, first finger up
1322 -> no event
1323 */
1324 litest_touch_down(dev, 0, 50, 50);
1325 litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10);
1326 litest_drain_events(dev->libinput);
1327
1328 litest_touch_down(dev, 1, 70, 50);
1329 litest_touch_up(dev, 0);
1330
1331 litest_assert_empty_queue(li);
1332 }
1333 END_TEST
1334
START_TEST(touchpad_no_2fg_tap_after_timeout)1335 START_TEST(touchpad_no_2fg_tap_after_timeout)
1336 {
1337 struct litest_device *dev = litest_current_device();
1338 struct libinput *li = dev->libinput;
1339
1340 litest_enable_tap(dev->libinput_device);
1341 litest_drain_events(dev->libinput);
1342
1343 /* one finger down, wait past tap timeout,
1344 second finger down, first finger up
1345 -> no event
1346 */
1347 litest_touch_down(dev, 0, 50, 50);
1348 libinput_dispatch(dev->libinput);
1349 litest_timeout_tap();
1350 libinput_dispatch(dev->libinput);
1351 litest_drain_events(dev->libinput);
1352
1353 litest_touch_down(dev, 1, 70, 50);
1354 litest_touch_up(dev, 0);
1355
1356 litest_assert_empty_queue(li);
1357 }
1358 END_TEST
1359
START_TEST(touchpad_no_first_fg_tap_after_move)1360 START_TEST(touchpad_no_first_fg_tap_after_move)
1361 {
1362 struct litest_device *dev = litest_current_device();
1363 struct libinput *li = dev->libinput;
1364 struct libinput_event *event;
1365
1366 litest_enable_tap(dev->libinput_device);
1367
1368 litest_drain_events(dev->libinput);
1369
1370 /* one finger down, second finger down,
1371 second finger moves beyond threshold,
1372 first finger up
1373 -> no event
1374 */
1375 litest_touch_down(dev, 0, 50, 50);
1376 litest_touch_down(dev, 1, 70, 50);
1377 libinput_dispatch(dev->libinput);
1378 litest_touch_move_to(dev, 1, 70, 50, 90, 90, 10);
1379 libinput_dispatch(dev->libinput);
1380 litest_touch_up(dev, 0);
1381 litest_touch_up(dev, 1);
1382 libinput_dispatch(dev->libinput);
1383
1384 while ((event = libinput_get_event(li))) {
1385 ck_assert_int_ne(libinput_event_get_type(event),
1386 LIBINPUT_EVENT_POINTER_BUTTON);
1387 libinput_event_destroy(event);
1388 }
1389 }
1390 END_TEST
1391
START_TEST(touchpad_1fg_double_tap_click)1392 START_TEST(touchpad_1fg_double_tap_click)
1393 {
1394 struct litest_device *dev = litest_current_device();
1395 struct libinput *li = dev->libinput;
1396
1397 litest_enable_tap(dev->libinput_device);
1398
1399 litest_drain_events(dev->libinput);
1400
1401 /* one finger down, up, down, button click, finger up
1402 -> two button left event pairs */
1403 litest_touch_down(dev, 0, 50, 50);
1404 litest_touch_up(dev, 0);
1405 litest_touch_down(dev, 0, 50, 50);
1406 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1407 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1408 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1409 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1410 litest_touch_up(dev, 0);
1411
1412 libinput_dispatch(li);
1413
1414 litest_assert_button_event(li, BTN_LEFT,
1415 LIBINPUT_BUTTON_STATE_PRESSED);
1416 litest_assert_button_event(li, BTN_LEFT,
1417 LIBINPUT_BUTTON_STATE_RELEASED);
1418 litest_assert_button_event(li, BTN_LEFT,
1419 LIBINPUT_BUTTON_STATE_PRESSED);
1420 litest_assert_button_event(li, BTN_LEFT,
1421 LIBINPUT_BUTTON_STATE_RELEASED);
1422
1423 litest_assert_empty_queue(li);
1424 }
1425 END_TEST
1426
START_TEST(touchpad_1fg_tap_n_drag_click)1427 START_TEST(touchpad_1fg_tap_n_drag_click)
1428 {
1429 struct litest_device *dev = litest_current_device();
1430 struct libinput *li = dev->libinput;
1431
1432 litest_enable_tap(dev->libinput_device);
1433
1434 litest_drain_events(dev->libinput);
1435
1436 /* one finger down, up, down, move, button click, finger up
1437 -> two button left event pairs, motion allowed */
1438 litest_touch_down(dev, 0, 50, 50);
1439 litest_touch_up(dev, 0);
1440 litest_touch_down(dev, 0, 50, 50);
1441 litest_touch_move_to(dev, 0, 50, 50, 80, 50, 10);
1442
1443 litest_assert_button_event(li, BTN_LEFT,
1444 LIBINPUT_BUTTON_STATE_PRESSED);
1445
1446 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1447
1448 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1449 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1450
1451 litest_assert_button_event(li, BTN_LEFT,
1452 LIBINPUT_BUTTON_STATE_RELEASED);
1453 litest_assert_button_event(li, BTN_LEFT,
1454 LIBINPUT_BUTTON_STATE_PRESSED);
1455
1456 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1457 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1458 litest_touch_up(dev, 0);
1459
1460 libinput_dispatch(li);
1461
1462 litest_assert_button_event(li, BTN_LEFT,
1463 LIBINPUT_BUTTON_STATE_RELEASED);
1464
1465 litest_assert_empty_queue(li);
1466 }
1467 END_TEST
1468
START_TEST(touchpad_3fg_tap)1469 START_TEST(touchpad_3fg_tap)
1470 {
1471 struct litest_device *dev = litest_current_device();
1472 struct libinput *li = dev->libinput;
1473 enum libinput_config_tap_button_map map = _i; /* ranged test */
1474 unsigned int button = 0;
1475 int i;
1476
1477 if (libevdev_get_abs_maximum(dev->evdev,
1478 ABS_MT_SLOT) <= 2)
1479 return;
1480
1481 litest_enable_tap(dev->libinput_device);
1482 litest_set_tap_map(dev->libinput_device, map);
1483
1484 switch (map) {
1485 case LIBINPUT_CONFIG_TAP_MAP_LRM:
1486 button = BTN_MIDDLE;
1487 break;
1488 case LIBINPUT_CONFIG_TAP_MAP_LMR:
1489 button = BTN_RIGHT;
1490 break;
1491 default:
1492 litest_abort_msg("Invalid map range %d", map);
1493 }
1494
1495 for (i = 0; i < 3; i++) {
1496 uint64_t ptime, rtime;
1497 struct libinput_event *ev;
1498 struct libinput_event_pointer *ptrev;
1499
1500 litest_drain_events(li);
1501
1502 litest_touch_down(dev, 0, 50, 50);
1503 msleep(5);
1504 litest_touch_down(dev, 1, 70, 50);
1505 msleep(5);
1506 litest_touch_down(dev, 2, 80, 50);
1507 msleep(10);
1508
1509 litest_touch_up(dev, (i + 2) % 3);
1510 litest_touch_up(dev, (i + 1) % 3);
1511 litest_touch_up(dev, (i + 0) % 3);
1512
1513 libinput_dispatch(li);
1514
1515 ev = libinput_get_event(li);
1516 ptrev = litest_is_button_event(ev,
1517 button,
1518 LIBINPUT_BUTTON_STATE_PRESSED);
1519 ptime = libinput_event_pointer_get_time_usec(ptrev);
1520 libinput_event_destroy(ev);
1521 ev = libinput_get_event(li);
1522 ptrev = litest_is_button_event(ev,
1523 button,
1524 LIBINPUT_BUTTON_STATE_RELEASED);
1525 rtime = libinput_event_pointer_get_time_usec(ptrev);
1526 libinput_event_destroy(ev);
1527
1528 ck_assert_int_lt(ptime, rtime);
1529
1530 }
1531 }
1532 END_TEST
1533
START_TEST(touchpad_3fg_tap_tap_again)1534 START_TEST(touchpad_3fg_tap_tap_again)
1535 {
1536 struct litest_device *dev = litest_current_device();
1537 struct libinput *li = dev->libinput;
1538 int i;
1539
1540 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) <= 2)
1541 return;
1542
1543 litest_enable_tap(dev->libinput_device);
1544
1545 uint64_t ptime, rtime;
1546 struct libinput_event *ev;
1547 struct libinput_event_pointer *ptrev;
1548
1549 litest_drain_events(li);
1550
1551 litest_touch_down(dev, 0, 50, 50);
1552 msleep(5);
1553 litest_touch_down(dev, 1, 70, 50);
1554 msleep(5);
1555 litest_touch_down(dev, 2, 80, 50);
1556 msleep(10);
1557 litest_touch_up(dev, 0);
1558 msleep(10);
1559 litest_touch_down(dev, 0, 80, 50);
1560 msleep(10);
1561 litest_touch_up(dev, 0);
1562 litest_touch_up(dev, 1);
1563 litest_touch_up(dev, 2);
1564
1565 libinput_dispatch(li);
1566
1567 for (i = 0; i < 2; i++) {
1568 ev = libinput_get_event(li);
1569 ptrev = litest_is_button_event(ev,
1570 BTN_MIDDLE,
1571 LIBINPUT_BUTTON_STATE_PRESSED);
1572 ptime = libinput_event_pointer_get_time_usec(ptrev);
1573 libinput_event_destroy(ev);
1574 ev = libinput_get_event(li);
1575 ptrev = litest_is_button_event(ev,
1576 BTN_MIDDLE,
1577 LIBINPUT_BUTTON_STATE_RELEASED);
1578 rtime = libinput_event_pointer_get_time_usec(ptrev);
1579 libinput_event_destroy(ev);
1580
1581 ck_assert_int_lt(ptime, rtime);
1582 }
1583 }
1584 END_TEST
1585
START_TEST(touchpad_3fg_tap_quickrelease)1586 START_TEST(touchpad_3fg_tap_quickrelease)
1587 {
1588 struct litest_device *dev = litest_current_device();
1589 struct libinput *li = dev->libinput;
1590
1591 if (libevdev_get_abs_maximum(dev->evdev,
1592 ABS_MT_SLOT) <= 2)
1593 return;
1594
1595 litest_enable_tap(dev->libinput_device);
1596
1597 litest_drain_events(li);
1598
1599 litest_touch_down(dev, 0, 50, 50);
1600 litest_touch_down(dev, 1, 70, 50);
1601 litest_touch_down(dev, 2, 80, 50);
1602 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1603 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1604 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1605 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1606 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
1607 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1608 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1609 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
1610 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1611
1612 libinput_dispatch(li);
1613
1614 litest_assert_button_event(li, BTN_MIDDLE,
1615 LIBINPUT_BUTTON_STATE_PRESSED);
1616 litest_timeout_tap();
1617 litest_assert_button_event(li, BTN_MIDDLE,
1618 LIBINPUT_BUTTON_STATE_RELEASED);
1619
1620 libinput_dispatch(li);
1621 litest_assert_empty_queue(li);
1622 }
1623 END_TEST
1624
START_TEST(touchpad_3fg_tap_pressure_btntool)1625 START_TEST(touchpad_3fg_tap_pressure_btntool)
1626 {
1627 struct litest_device *dev = litest_current_device();
1628 struct libinput *li = dev->libinput;
1629
1630 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) >= 2)
1631 return;
1632
1633 /* libinput doesn't export when it uses pressure detection, so we
1634 * need to reconstruct this here. Specifically, semi-mt devices are
1635 * non-mt in libinput, so if they have ABS_PRESSURE, they'll use it.
1636 */
1637 if (!libevdev_has_event_code(dev->evdev, EV_ABS, ABS_MT_PRESSURE))
1638 return;
1639
1640 litest_enable_tap(dev->libinput_device);
1641 litest_enable_edge_scroll(dev);
1642
1643 litest_drain_events(li);
1644
1645 litest_touch_down(dev, 0, 50, 50);
1646 litest_touch_down(dev, 1, 70, 50);
1647 libinput_dispatch(li);
1648
1649 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
1650 litest_touch_move_to(dev, 1, 70, 50, 50, 70, 10);
1651 litest_drain_events(li);
1652
1653 /* drop below the pressure threshold in the same frame as starting a
1654 * third touch, see
1655 * E: 8713.954784 0001 014e 0001 # EV_KEY / BTN_TOOL_TRIPLETAP 1
1656 * in https://bugs.freedesktop.org/attachment.cgi?id=137672
1657 */
1658 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 3);
1659 litest_event(dev, EV_ABS, ABS_PRESSURE, 3);
1660 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1661 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1662 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1663 libinput_dispatch(li);
1664
1665 litest_push_event_frame(dev);
1666 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1667 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1668 litest_pop_event_frame(dev);
1669
1670 litest_touch_up(dev, 0);
1671 litest_touch_up(dev, 1);
1672 libinput_dispatch(li);
1673 litest_timeout_tap();
1674 libinput_dispatch(li);
1675
1676 litest_assert_button_event(li,
1677 BTN_MIDDLE,
1678 LIBINPUT_BUTTON_STATE_PRESSED);
1679 litest_assert_button_event(li,
1680 BTN_MIDDLE,
1681 LIBINPUT_BUTTON_STATE_RELEASED);
1682 }
1683 END_TEST
1684
START_TEST(touchpad_3fg_tap_hover_btntool)1685 START_TEST(touchpad_3fg_tap_hover_btntool)
1686 {
1687 struct litest_device *dev = litest_current_device();
1688 struct libinput *li = dev->libinput;
1689
1690 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) >= 2)
1691 return;
1692
1693 /* libinput doesn't export when it uses pressure detection, so we
1694 * need to reconstruct this here. Specifically, semi-mt devices are
1695 * non-mt in libinput, so if they have ABS_PRESSURE, they'll use it.
1696 */
1697 if (libevdev_has_event_code(dev->evdev, EV_ABS, ABS_MT_PRESSURE))
1698 return;
1699
1700 if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT) &&
1701 libevdev_has_event_code(dev->evdev, EV_ABS, ABS_PRESSURE))
1702 return;
1703
1704 litest_enable_tap(dev->libinput_device);
1705 litest_enable_edge_scroll(dev);
1706
1707 litest_drain_events(li);
1708
1709 litest_touch_down(dev, 0, 50, 50);
1710 litest_touch_down(dev, 1, 70, 50);
1711 libinput_dispatch(li);
1712
1713 litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
1714 litest_touch_move_to(dev, 1, 70, 50, 50, 70, 10);
1715 litest_drain_events(li);
1716
1717 /* drop below the pressure threshold in the same frame as starting a
1718 * third touch */
1719 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
1720 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1721 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1722 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1723 libinput_dispatch(li);
1724
1725 litest_push_event_frame(dev);
1726 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1727 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1728 litest_pop_event_frame(dev);
1729 litest_assert_empty_queue(li);
1730
1731 litest_touch_up(dev, 0);
1732 litest_touch_up(dev, 1);
1733 }
1734 END_TEST
1735
START_TEST(touchpad_3fg_tap_btntool)1736 START_TEST(touchpad_3fg_tap_btntool)
1737 {
1738 struct litest_device *dev = litest_current_device();
1739 struct libinput *li = dev->libinput;
1740 enum libinput_config_tap_button_map map = _i; /* ranged test */
1741 unsigned int button = 0;
1742
1743 if (libevdev_get_abs_maximum(dev->evdev,
1744 ABS_MT_SLOT) > 2)
1745 return;
1746
1747 litest_enable_tap(dev->libinput_device);
1748 litest_set_tap_map(dev->libinput_device, map);
1749
1750 switch (map) {
1751 case LIBINPUT_CONFIG_TAP_MAP_LRM:
1752 button = BTN_MIDDLE;
1753 break;
1754 case LIBINPUT_CONFIG_TAP_MAP_LMR:
1755 button = BTN_RIGHT;
1756 break;
1757 default:
1758 litest_abort_msg("Invalid map range %d", map);
1759 }
1760
1761 litest_drain_events(li);
1762
1763 litest_touch_down(dev, 0, 50, 50);
1764 litest_touch_down(dev, 1, 70, 50);
1765 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1766 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1767 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1768 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1769 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1770 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1771 litest_touch_up(dev, 1);
1772 litest_touch_up(dev, 0);
1773
1774 libinput_dispatch(li);
1775
1776 litest_assert_button_event(li, button,
1777 LIBINPUT_BUTTON_STATE_PRESSED);
1778 litest_timeout_tap();
1779 litest_assert_button_event(li, button,
1780 LIBINPUT_BUTTON_STATE_RELEASED);
1781
1782 litest_assert_empty_queue(li);
1783 }
1784 END_TEST
1785
START_TEST(touchpad_3fg_tap_btntool_inverted)1786 START_TEST(touchpad_3fg_tap_btntool_inverted)
1787 {
1788 struct litest_device *dev = litest_current_device();
1789 struct libinput *li = dev->libinput;
1790 enum libinput_config_tap_button_map map = _i; /* ranged test */
1791 unsigned int button = 0;
1792
1793 if (libevdev_get_abs_maximum(dev->evdev,
1794 ABS_MT_SLOT) > 2)
1795 return;
1796
1797 litest_enable_tap(dev->libinput_device);
1798 litest_set_tap_map(dev->libinput_device, map);
1799
1800 switch (map) {
1801 case LIBINPUT_CONFIG_TAP_MAP_LRM:
1802 button = BTN_MIDDLE;
1803 break;
1804 case LIBINPUT_CONFIG_TAP_MAP_LMR:
1805 button = BTN_RIGHT;
1806 break;
1807 default:
1808 litest_abort_msg("invalid map range %d", map);
1809 }
1810
1811 litest_drain_events(li);
1812
1813 litest_touch_down(dev, 0, 50, 50);
1814 litest_touch_down(dev, 1, 70, 50);
1815 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1816 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1817 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1818 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1819 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1820 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1821 litest_touch_up(dev, 0);
1822 litest_touch_up(dev, 1);
1823
1824 libinput_dispatch(li);
1825
1826 litest_assert_button_event(li, button,
1827 LIBINPUT_BUTTON_STATE_PRESSED);
1828 litest_timeout_tap();
1829 litest_assert_button_event(li, button,
1830 LIBINPUT_BUTTON_STATE_RELEASED);
1831
1832 litest_assert_empty_queue(li);
1833 }
1834 END_TEST
1835
START_TEST(touchpad_3fg_tap_btntool_pointerjump)1836 START_TEST(touchpad_3fg_tap_btntool_pointerjump)
1837 {
1838 struct litest_device *dev = litest_current_device();
1839 struct libinput *li = dev->libinput;
1840 enum libinput_config_tap_button_map map = _i; /* ranged test */
1841 unsigned int button = 0;
1842
1843 if (libevdev_get_abs_maximum(dev->evdev,
1844 ABS_MT_SLOT) > 2)
1845 return;
1846
1847 litest_enable_tap(dev->libinput_device);
1848 litest_set_tap_map(dev->libinput_device, map);
1849
1850 switch (map) {
1851 case LIBINPUT_CONFIG_TAP_MAP_LRM:
1852 button = BTN_MIDDLE;
1853 break;
1854 case LIBINPUT_CONFIG_TAP_MAP_LMR:
1855 button = BTN_RIGHT;
1856 break;
1857 default:
1858 litest_abort_msg("Invalid map range %d", map);
1859 }
1860
1861 litest_drain_events(li);
1862
1863 litest_touch_down(dev, 0, 50, 50);
1864 litest_touch_down(dev, 1, 70, 50);
1865 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1866 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1867 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1868 /* Pointer jump should be ignored */
1869 litest_touch_move_to(dev, 0, 50, 50, 20, 20, 0);
1870 libinput_dispatch(li);
1871 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1872 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
1873 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1874 litest_touch_up(dev, 1);
1875 litest_touch_up(dev, 0);
1876
1877 libinput_dispatch(li);
1878
1879 litest_assert_button_event(li, button,
1880 LIBINPUT_BUTTON_STATE_PRESSED);
1881 litest_timeout_tap();
1882 litest_assert_button_event(li, button,
1883 LIBINPUT_BUTTON_STATE_RELEASED);
1884
1885 litest_assert_empty_queue(li);
1886 }
1887 END_TEST
1888
START_TEST(touchpad_3fg_tap_slot_release_btntool)1889 START_TEST(touchpad_3fg_tap_slot_release_btntool)
1890 {
1891 struct litest_device *dev = litest_current_device();
1892 struct libinput *li = dev->libinput;
1893
1894 /* Synaptics touchpads sometimes end one touch point after
1895 * setting BTN_TOOL_TRIPLETAP.
1896 * https://gitlab.freedesktop.org/libinput/libinput/issues/99
1897 */
1898 litest_drain_events(li);
1899 litest_enable_tap(dev->libinput_device);
1900
1901 /* touch 1 down */
1902 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1903 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 1);
1904 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2200);
1905 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3200);
1906 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
1907 litest_event(dev, EV_ABS, ABS_X, 2200);
1908 litest_event(dev, EV_ABS, ABS_Y, 3200);
1909 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
1910 litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
1911 litest_event(dev, EV_KEY, BTN_TOUCH, 1);
1912 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1913 libinput_dispatch(li);
1914 msleep(2);
1915
1916 /* touch 2 and TRIPLETAP down */
1917 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1918 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 1);
1919 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
1920 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
1921 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 73);
1922 litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
1923 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1924 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1925 libinput_dispatch(li);
1926 msleep(2);
1927
1928 /* touch 2 up, coordinate jump + ends slot 1, TRIPLETAP stays */
1929 litest_disable_log_handler(li);
1930 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1931 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
1932 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
1933 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
1934 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1935 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1936 litest_event(dev, EV_ABS, ABS_X, 2500);
1937 litest_event(dev, EV_ABS, ABS_Y, 3800);
1938 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
1939 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1940 libinput_dispatch(li);
1941 msleep(2);
1942
1943 /* slot 2 reactivated
1944 */
1945 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1946 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 2500);
1947 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3800);
1948 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 78);
1949 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1950 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, 3);
1951 litest_event(dev, EV_ABS, ABS_MT_POSITION_X, 3500);
1952 litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 3500);
1953 litest_event(dev, EV_ABS, ABS_MT_PRESSURE, 73);
1954 litest_event(dev, EV_ABS, ABS_X, 2200);
1955 litest_event(dev, EV_ABS, ABS_Y, 3200);
1956 litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
1957 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1958 libinput_dispatch(li);
1959 litest_restore_log_handler(li);
1960
1961 /* now end all three */
1962 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
1963 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1964 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
1965 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1966 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
1967 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
1968 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1969 litest_timeout_tap();
1970 libinput_dispatch(li);
1971
1972 litest_assert_button_event(li, BTN_MIDDLE,
1973 LIBINPUT_BUTTON_STATE_PRESSED);
1974 litest_assert_button_event(li, BTN_MIDDLE,
1975 LIBINPUT_BUTTON_STATE_RELEASED);
1976
1977 litest_assert_empty_queue(li);
1978 }
1979 END_TEST
1980
START_TEST(touchpad_4fg_tap)1981 START_TEST(touchpad_4fg_tap)
1982 {
1983 struct litest_device *dev = litest_current_device();
1984 struct libinput *li = dev->libinput;
1985 int i;
1986
1987 if (libevdev_get_abs_maximum(dev->evdev,
1988 ABS_MT_SLOT) <= 3)
1989 return;
1990
1991 litest_enable_tap(dev->libinput_device);
1992
1993 for (i = 0; i < 4; i++) {
1994 litest_drain_events(li);
1995
1996 litest_touch_down(dev, 0, 50, 50);
1997 litest_touch_down(dev, 1, 70, 50);
1998 litest_touch_down(dev, 2, 80, 50);
1999 litest_touch_down(dev, 3, 90, 50);
2000
2001 litest_touch_up(dev, (i + 3) % 4);
2002 litest_touch_up(dev, (i + 2) % 4);
2003 litest_touch_up(dev, (i + 1) % 4);
2004 litest_touch_up(dev, (i + 0) % 4);
2005
2006 libinput_dispatch(li);
2007 litest_assert_empty_queue(li);
2008 litest_timeout_tap();
2009 litest_assert_empty_queue(li);
2010 }
2011 }
2012 END_TEST
2013
START_TEST(touchpad_4fg_tap_quickrelease)2014 START_TEST(touchpad_4fg_tap_quickrelease)
2015 {
2016 struct litest_device *dev = litest_current_device();
2017 struct libinput *li = dev->libinput;
2018
2019 if (libevdev_get_abs_maximum(dev->evdev,
2020 ABS_MT_SLOT) <= 3)
2021 return;
2022
2023 litest_enable_tap(dev->libinput_device);
2024
2025 litest_drain_events(li);
2026
2027 litest_touch_down(dev, 0, 50, 50);
2028 litest_touch_down(dev, 1, 70, 50);
2029 litest_touch_down(dev, 2, 80, 50);
2030 litest_touch_down(dev, 3, 90, 50);
2031
2032 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
2033 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2034 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
2035 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2036 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
2037 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2038 litest_event(dev, EV_ABS, ABS_MT_SLOT, 3);
2039 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2040 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0);
2041 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
2042 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2043
2044 libinput_dispatch(li);
2045 litest_assert_empty_queue(li);
2046 litest_timeout_tap();
2047 litest_assert_empty_queue(li);
2048 }
2049 END_TEST
2050
START_TEST(touchpad_5fg_tap)2051 START_TEST(touchpad_5fg_tap)
2052 {
2053 struct litest_device *dev = litest_current_device();
2054 struct libinput *li = dev->libinput;
2055 int i;
2056
2057 if (libevdev_get_abs_maximum(dev->evdev,
2058 ABS_MT_SLOT) <= 4)
2059 return;
2060
2061 litest_enable_tap(dev->libinput_device);
2062
2063 for (i = 0; i < 5; i++) {
2064 litest_drain_events(li);
2065
2066 litest_touch_down(dev, 0, 20, 50);
2067 litest_touch_down(dev, 1, 30, 50);
2068 litest_touch_down(dev, 2, 40, 50);
2069 litest_touch_down(dev, 3, 50, 50);
2070 litest_touch_down(dev, 4, 60, 50);
2071
2072 litest_touch_up(dev, (i + 4) % 5);
2073 litest_touch_up(dev, (i + 3) % 5);
2074 litest_touch_up(dev, (i + 2) % 5);
2075 litest_touch_up(dev, (i + 1) % 5);
2076 litest_touch_up(dev, (i + 0) % 5);
2077
2078 libinput_dispatch(li);
2079 litest_assert_empty_queue(li);
2080 litest_timeout_tap();
2081 litest_assert_empty_queue(li);
2082 }
2083 }
2084 END_TEST
2085
START_TEST(touchpad_5fg_tap_quickrelease)2086 START_TEST(touchpad_5fg_tap_quickrelease)
2087 {
2088 struct litest_device *dev = litest_current_device();
2089 struct libinput *li = dev->libinput;
2090
2091 if (libevdev_get_abs_maximum(dev->evdev,
2092 ABS_MT_SLOT) <= 4)
2093 return;
2094
2095 litest_enable_tap(dev->libinput_device);
2096
2097 litest_drain_events(li);
2098
2099 litest_touch_down(dev, 0, 20, 50);
2100 litest_touch_down(dev, 1, 30, 50);
2101 litest_touch_down(dev, 2, 40, 50);
2102 litest_touch_down(dev, 3, 70, 50);
2103 litest_touch_down(dev, 4, 90, 50);
2104
2105 litest_event(dev, EV_ABS, ABS_MT_SLOT, 0);
2106 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2107 litest_event(dev, EV_ABS, ABS_MT_SLOT, 1);
2108 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2109 litest_event(dev, EV_ABS, ABS_MT_SLOT, 2);
2110 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2111 litest_event(dev, EV_ABS, ABS_MT_SLOT, 3);
2112 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2113 litest_event(dev, EV_ABS, ABS_MT_SLOT, 4);
2114 litest_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
2115 litest_event(dev, EV_KEY, BTN_TOOL_QUINTTAP, 0);
2116 litest_event(dev, EV_KEY, BTN_TOUCH, 0);
2117 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2118
2119 libinput_dispatch(li);
2120 litest_assert_empty_queue(li);
2121 litest_timeout_tap();
2122 litest_assert_empty_queue(li);
2123 }
2124 END_TEST
2125
START_TEST(clickpad_1fg_tap_click)2126 START_TEST(clickpad_1fg_tap_click)
2127 {
2128 struct litest_device *dev = litest_current_device();
2129 struct libinput *li = dev->libinput;
2130
2131 litest_enable_tap(dev->libinput_device);
2132
2133 litest_drain_events(dev->libinput);
2134
2135 /* finger down, button click, finger up
2136 -> only one button left event pair */
2137 litest_touch_down(dev, 0, 50, 50);
2138 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2139 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2140 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2141 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2142 litest_touch_up(dev, 0);
2143 libinput_dispatch(li);
2144 litest_timeout_tap();
2145
2146 libinput_dispatch(li);
2147
2148 litest_assert_button_event(li, BTN_LEFT,
2149 LIBINPUT_BUTTON_STATE_PRESSED);
2150 litest_assert_button_event(li, BTN_LEFT,
2151 LIBINPUT_BUTTON_STATE_RELEASED);
2152
2153 litest_assert_empty_queue(li);
2154 }
2155 END_TEST
2156
START_TEST(touchpad_tap_is_available)2157 START_TEST(touchpad_tap_is_available)
2158 {
2159 struct litest_device *dev = litest_current_device();
2160
2161 ck_assert_int_ge(libinput_device_config_tap_get_finger_count(dev->libinput_device), 1);
2162 }
2163 END_TEST
2164
START_TEST(touchpad_tap_is_not_available)2165 START_TEST(touchpad_tap_is_not_available)
2166 {
2167 struct litest_device *dev = litest_current_device();
2168
2169 ck_assert_int_eq(libinput_device_config_tap_get_finger_count(dev->libinput_device), 0);
2170 ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
2171 LIBINPUT_CONFIG_TAP_DISABLED);
2172 ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
2173 LIBINPUT_CONFIG_TAP_ENABLED),
2174 LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2175 ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
2176 LIBINPUT_CONFIG_TAP_DISABLED),
2177 LIBINPUT_CONFIG_STATUS_SUCCESS);
2178 }
2179 END_TEST
2180
START_TEST(touchpad_tap_default_disabled)2181 START_TEST(touchpad_tap_default_disabled)
2182 {
2183 struct litest_device *dev = litest_current_device();
2184
2185 /* this test is only run on specific devices */
2186
2187 ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
2188 LIBINPUT_CONFIG_TAP_DISABLED);
2189 ck_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
2190 LIBINPUT_CONFIG_TAP_DISABLED);
2191 }
2192 END_TEST
2193
START_TEST(touchpad_tap_default_enabled)2194 START_TEST(touchpad_tap_default_enabled)
2195 {
2196 struct litest_device *dev = litest_current_device();
2197
2198 /* this test is only run on specific devices */
2199
2200 ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
2201 LIBINPUT_CONFIG_TAP_ENABLED);
2202 ck_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
2203 LIBINPUT_CONFIG_TAP_ENABLED);
2204 }
2205 END_TEST
2206
START_TEST(touchpad_tap_invalid)2207 START_TEST(touchpad_tap_invalid)
2208 {
2209 struct litest_device *dev = litest_current_device();
2210
2211 ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
2212 LIBINPUT_CONFIG_STATUS_INVALID);
2213 ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, -1),
2214 LIBINPUT_CONFIG_STATUS_INVALID);
2215 }
2216 END_TEST
2217
START_TEST(touchpad_tap_default_map)2218 START_TEST(touchpad_tap_default_map)
2219 {
2220 struct litest_device *dev = litest_current_device();
2221 enum libinput_config_tap_button_map map;
2222
2223 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
2224 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2225
2226 map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
2227 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2228 }
2229 END_TEST
2230
START_TEST(touchpad_tap_map_unsupported)2231 START_TEST(touchpad_tap_map_unsupported)
2232 {
2233 struct litest_device *dev = litest_current_device();
2234 enum libinput_config_tap_button_map map;
2235 enum libinput_config_status status;
2236
2237 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
2238 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2239 map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
2240 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2241
2242 status = libinput_device_config_tap_set_button_map(dev->libinput_device,
2243 LIBINPUT_CONFIG_TAP_MAP_LMR);
2244 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2245 status = libinput_device_config_tap_set_button_map(dev->libinput_device,
2246 LIBINPUT_CONFIG_TAP_MAP_LRM);
2247 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2248 }
2249 END_TEST
2250
START_TEST(touchpad_tap_set_map)2251 START_TEST(touchpad_tap_set_map)
2252 {
2253 struct litest_device *dev = litest_current_device();
2254 struct libinput_device *device = dev->libinput_device;
2255 enum libinput_config_tap_button_map map;
2256 enum libinput_config_status status;
2257
2258 map = LIBINPUT_CONFIG_TAP_MAP_LRM;
2259 status = libinput_device_config_tap_set_button_map(device, map);
2260 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2261 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
2262 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2263
2264 map = LIBINPUT_CONFIG_TAP_MAP_LMR;
2265 status = libinput_device_config_tap_set_button_map(device, map);
2266 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2267 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
2268 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
2269
2270 map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
2271 status = libinput_device_config_tap_set_button_map(device, map);
2272 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2273
2274 map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
2275 status = libinput_device_config_tap_set_button_map(device, map);
2276 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2277 }
2278 END_TEST
2279
START_TEST(touchpad_tap_set_map_no_tapping)2280 START_TEST(touchpad_tap_set_map_no_tapping)
2281 {
2282 struct litest_device *dev = litest_current_device();
2283 struct libinput_device *device = dev->libinput_device;
2284 enum libinput_config_tap_button_map map;
2285 enum libinput_config_status status;
2286
2287 map = LIBINPUT_CONFIG_TAP_MAP_LRM;
2288 status = libinput_device_config_tap_set_button_map(device, map);
2289 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2290
2291 map = LIBINPUT_CONFIG_TAP_MAP_LMR;
2292 status = libinput_device_config_tap_set_button_map(device, map);
2293 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2294
2295 map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
2296 status = libinput_device_config_tap_set_button_map(device, map);
2297 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2298
2299 map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
2300 status = libinput_device_config_tap_set_button_map(device, map);
2301 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2302 }
2303 END_TEST
2304
START_TEST(touchpad_tap_get_map_no_tapping)2305 START_TEST(touchpad_tap_get_map_no_tapping)
2306 {
2307 struct litest_device *dev = litest_current_device();
2308 struct libinput_device *device = dev->libinput_device;
2309 enum libinput_config_tap_button_map map;
2310
2311 map = libinput_device_config_tap_get_button_map(device);
2312 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2313
2314 map = libinput_device_config_tap_get_default_button_map(device);
2315 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
2316 }
2317 END_TEST
2318
START_TEST(touchpad_tap_map_delayed)2319 START_TEST(touchpad_tap_map_delayed)
2320 {
2321 struct litest_device *dev = litest_current_device();
2322 struct libinput *li = dev->libinput;
2323 enum libinput_config_tap_button_map map;
2324
2325 litest_enable_tap(dev->libinput_device);
2326 litest_set_tap_map(dev->libinput_device,
2327 LIBINPUT_CONFIG_TAP_MAP_LRM);
2328 litest_drain_events(dev->libinput);
2329
2330 litest_touch_down(dev, 0, 50, 50);
2331 litest_touch_down(dev, 1, 70, 70);
2332 libinput_dispatch(li);
2333
2334 litest_set_tap_map(dev->libinput_device,
2335 LIBINPUT_CONFIG_TAP_MAP_LMR);
2336 map = libinput_device_config_tap_get_button_map(dev->libinput_device);
2337 ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
2338
2339 litest_touch_up(dev, 0);
2340 litest_touch_up(dev, 1);
2341
2342 libinput_dispatch(li);
2343
2344 litest_assert_button_event(li,
2345 BTN_RIGHT,
2346 LIBINPUT_BUTTON_STATE_PRESSED);
2347 litest_timeout_tap();
2348 litest_assert_button_event(li, BTN_RIGHT,
2349 LIBINPUT_BUTTON_STATE_RELEASED);
2350
2351 litest_assert_empty_queue(li);
2352 }
2353 END_TEST
2354
START_TEST(touchpad_drag_default_disabled)2355 START_TEST(touchpad_drag_default_disabled)
2356 {
2357 struct litest_device *dev = litest_current_device();
2358
2359 /* this test is only run on specific devices */
2360
2361 ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
2362 LIBINPUT_CONFIG_DRAG_DISABLED);
2363 ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
2364 LIBINPUT_CONFIG_DRAG_DISABLED);
2365 }
2366 END_TEST
2367
START_TEST(touchpad_drag_default_enabled)2368 START_TEST(touchpad_drag_default_enabled)
2369 {
2370 struct litest_device *dev = litest_current_device();
2371
2372 /* this test is only run on specific devices */
2373
2374 ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
2375 LIBINPUT_CONFIG_DRAG_ENABLED);
2376 ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
2377 LIBINPUT_CONFIG_DRAG_ENABLED);
2378 }
2379 END_TEST
2380
START_TEST(touchpad_drag_config_invalid)2381 START_TEST(touchpad_drag_config_invalid)
2382 {
2383 struct litest_device *dev = litest_current_device();
2384
2385 ck_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
2386 LIBINPUT_CONFIG_STATUS_INVALID);
2387 ck_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, -1),
2388 LIBINPUT_CONFIG_STATUS_INVALID);
2389 }
2390 END_TEST
2391
START_TEST(touchpad_drag_config_unsupported)2392 START_TEST(touchpad_drag_config_unsupported)
2393 {
2394 struct litest_device *dev = litest_current_device();
2395 enum libinput_config_status status;
2396
2397 ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
2398 LIBINPUT_CONFIG_DRAG_DISABLED);
2399 ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
2400 LIBINPUT_CONFIG_DRAG_DISABLED);
2401 status = libinput_device_config_tap_set_drag_enabled(dev->libinput_device,
2402 LIBINPUT_CONFIG_DRAG_ENABLED);
2403 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2404 status = libinput_device_config_tap_set_drag_enabled(dev->libinput_device,
2405 LIBINPUT_CONFIG_DRAG_DISABLED);
2406 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2407 }
2408 END_TEST
2409
START_TEST(touchpad_drag_config_enabledisable)2410 START_TEST(touchpad_drag_config_enabledisable)
2411 {
2412 struct litest_device *dev = litest_current_device();
2413 enum libinput_config_drag_state state;
2414
2415 litest_enable_tap(dev->libinput_device);
2416
2417 litest_disable_tap_drag(dev->libinput_device);
2418 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
2419 ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
2420
2421 litest_enable_tap_drag(dev->libinput_device);
2422 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
2423 ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
2424
2425 /* same thing with tapping disabled */
2426 litest_enable_tap(dev->libinput_device);
2427
2428 litest_disable_tap_drag(dev->libinput_device);
2429 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
2430 ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
2431
2432 litest_enable_tap_drag(dev->libinput_device);
2433 state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
2434 ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
2435 }
2436 END_TEST
2437
START_TEST(touchpad_drag_disabled)2438 START_TEST(touchpad_drag_disabled)
2439 {
2440 struct litest_device *dev = litest_current_device();
2441 struct libinput *li = dev->libinput;
2442
2443 litest_enable_tap(dev->libinput_device);
2444 litest_disable_tap_drag(dev->libinput_device);
2445
2446 litest_drain_events(li);
2447
2448 litest_touch_down(dev, 0, 50, 50);
2449 litest_touch_up(dev, 0);
2450 libinput_dispatch(li);
2451 litest_touch_down(dev, 0, 50, 50);
2452 litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10);
2453 litest_touch_up(dev, 0);
2454 libinput_dispatch(li);
2455
2456 litest_assert_button_event(li,
2457 BTN_LEFT,
2458 LIBINPUT_BUTTON_STATE_PRESSED);
2459 litest_assert_button_event(li,
2460 BTN_LEFT,
2461 LIBINPUT_BUTTON_STATE_RELEASED);
2462 litest_assert_only_typed_events(li,
2463 LIBINPUT_EVENT_POINTER_MOTION);
2464
2465 }
2466 END_TEST
2467
START_TEST(touchpad_drag_disabled_immediate)2468 START_TEST(touchpad_drag_disabled_immediate)
2469 {
2470 struct litest_device *dev = litest_current_device();
2471 struct libinput *li = dev->libinput;
2472 struct libinput_event *ev;
2473 struct libinput_event_pointer *ptrev;
2474 uint64_t press_time, release_time;
2475
2476 litest_enable_tap(dev->libinput_device);
2477 litest_disable_tap_drag(dev->libinput_device);
2478
2479 litest_drain_events(li);
2480
2481 litest_touch_down(dev, 0, 50, 50);
2482 msleep(10); /* to force a time difference */
2483 libinput_dispatch(li);
2484 litest_touch_up(dev, 0);
2485 libinput_dispatch(li);
2486
2487 ev = libinput_get_event(li);
2488 ptrev = litest_is_button_event(ev,
2489 BTN_LEFT,
2490 LIBINPUT_BUTTON_STATE_PRESSED);
2491 press_time = libinput_event_pointer_get_time(ptrev);
2492 libinput_event_destroy(ev);
2493
2494 ev = libinput_get_event(li);
2495 ptrev = litest_is_button_event(ev,
2496 BTN_LEFT,
2497 LIBINPUT_BUTTON_STATE_RELEASED);
2498 release_time = libinput_event_pointer_get_time(ptrev);
2499 libinput_event_destroy(ev);
2500
2501 ck_assert_int_gt(release_time, press_time);
2502 }
2503 END_TEST
2504
START_TEST(touchpad_drag_disabled_multitap_no_drag)2505 START_TEST(touchpad_drag_disabled_multitap_no_drag)
2506 {
2507 struct litest_device *dev = litest_current_device();
2508 struct libinput *li = dev->libinput;
2509 struct libinput_event *event;
2510 struct libinput_event_pointer *ptrev;
2511 uint32_t oldtime = 0,
2512 curtime;
2513 int range = _i, /* looped test */
2514 ntaps;
2515
2516 litest_enable_tap(dev->libinput_device);
2517 litest_disable_tap_drag(dev->libinput_device);
2518
2519 litest_drain_events(li);
2520
2521 for (ntaps = 0; ntaps <= range; ntaps++) {
2522 litest_touch_down(dev, 0, 50, 50);
2523 litest_touch_up(dev, 0);
2524 libinput_dispatch(li);
2525 msleep(10);
2526 }
2527
2528 libinput_dispatch(li);
2529 litest_touch_down(dev, 0, 50, 50);
2530 litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
2531 libinput_dispatch(li);
2532
2533 for (ntaps = 0; ntaps <= range; ntaps++) {
2534 event = libinput_get_event(li);
2535 ptrev = litest_is_button_event(event,
2536 BTN_LEFT,
2537 LIBINPUT_BUTTON_STATE_PRESSED);
2538 curtime = libinput_event_pointer_get_time(ptrev);
2539 libinput_event_destroy(event);
2540 ck_assert_int_gt(curtime, oldtime);
2541
2542 event = libinput_get_event(li);
2543 ptrev = litest_is_button_event(event,
2544 BTN_LEFT,
2545 LIBINPUT_BUTTON_STATE_RELEASED);
2546 curtime = libinput_event_pointer_get_time(ptrev);
2547 libinput_event_destroy(event);
2548 ck_assert_int_ge(curtime, oldtime);
2549 oldtime = curtime;
2550 }
2551
2552 litest_assert_only_typed_events(li,
2553 LIBINPUT_EVENT_POINTER_MOTION);
2554 litest_assert_empty_queue(li);
2555 }
2556 END_TEST
2557
START_TEST(touchpad_drag_lock_default_disabled)2558 START_TEST(touchpad_drag_lock_default_disabled)
2559 {
2560 struct litest_device *dev = litest_current_device();
2561 struct libinput_device *device = dev->libinput_device;
2562 enum libinput_config_status status;
2563
2564 ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
2565 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2566 ck_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
2567 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2568
2569 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2570 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
2571 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2572
2573 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2574 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2575 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2576
2577 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2578 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
2579 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2580
2581 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2582 3);
2583 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2584 }
2585 END_TEST
2586
START_TEST(touchpad_drag_lock_default_unavailable)2587 START_TEST(touchpad_drag_lock_default_unavailable)
2588 {
2589 struct litest_device *dev = litest_current_device();
2590 struct libinput_device *device = dev->libinput_device;
2591 enum libinput_config_status status;
2592
2593 ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
2594 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2595 ck_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
2596 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2597
2598 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2599 LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
2600 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
2601
2602 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2603 LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
2604 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
2605
2606 status = libinput_device_config_tap_set_drag_lock_enabled(device,
2607 3);
2608 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
2609 }
2610 END_TEST
2611
2612 static inline bool
touchpad_has_palm_pressure(struct litest_device * dev)2613 touchpad_has_palm_pressure(struct litest_device *dev)
2614 {
2615 struct libevdev *evdev = dev->evdev;
2616
2617 if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_PRESSURE))
2618 return true;
2619
2620 return false;
2621 }
2622
START_TEST(touchpad_tap_palm_on_idle)2623 START_TEST(touchpad_tap_palm_on_idle)
2624 {
2625 struct litest_device *dev = litest_current_device();
2626 struct libinput *li = dev->libinput;
2627 struct axis_replacement axes[] = {
2628 { ABS_MT_PRESSURE, 75 },
2629 { -1, 0 }
2630 };
2631
2632 if (!touchpad_has_palm_pressure(dev))
2633 return;
2634
2635 litest_enable_tap(dev->libinput_device);
2636 litest_drain_events(li);
2637
2638 /* Finger down is immediately palm */
2639
2640 litest_touch_down_extended(dev, 0, 50, 50, axes);
2641 litest_touch_up(dev, 0);
2642
2643 libinput_dispatch(li);
2644
2645 litest_assert_empty_queue(li);
2646 }
2647 END_TEST
2648
START_TEST(touchpad_tap_palm_on_touch)2649 START_TEST(touchpad_tap_palm_on_touch)
2650 {
2651 struct litest_device *dev = litest_current_device();
2652 struct libinput *li = dev->libinput;
2653 struct axis_replacement axes[] = {
2654 { ABS_MT_PRESSURE, 75 },
2655 { -1, 0 }
2656 };
2657
2658 if (!touchpad_has_palm_pressure(dev))
2659 return;
2660
2661 litest_enable_tap(dev->libinput_device);
2662 litest_drain_events(li);
2663
2664 /* Finger down is palm after touch begin */
2665
2666 litest_touch_down(dev, 0, 50, 50);
2667 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2668 litest_touch_up(dev, 0);
2669
2670 libinput_dispatch(li);
2671
2672 litest_assert_empty_queue(li);
2673 }
2674 END_TEST
2675
START_TEST(touchpad_tap_palm_on_touch_hold_timeout)2676 START_TEST(touchpad_tap_palm_on_touch_hold_timeout)
2677 {
2678 struct litest_device *dev = litest_current_device();
2679 struct libinput *li = dev->libinput;
2680 struct axis_replacement axes[] = {
2681 { ABS_MT_PRESSURE, 75 },
2682 { -1, 0 }
2683 };
2684
2685 if (!touchpad_has_palm_pressure(dev))
2686 return;
2687
2688 litest_enable_tap(dev->libinput_device);
2689 litest_drain_events(li);
2690
2691 /* Finger down is palm after tap timeout */
2692
2693 litest_touch_down(dev, 0, 50, 50);
2694 libinput_dispatch(li);
2695 litest_timeout_tap();
2696 libinput_dispatch(li);
2697 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2698 litest_touch_up(dev, 0);
2699
2700 libinput_dispatch(li);
2701
2702 litest_assert_empty_queue(li);
2703 }
2704 END_TEST
2705
START_TEST(touchpad_tap_palm_on_touch_hold_move)2706 START_TEST(touchpad_tap_palm_on_touch_hold_move)
2707 {
2708 struct litest_device *dev = litest_current_device();
2709 struct libinput *li = dev->libinput;
2710 struct axis_replacement axes[] = {
2711 { ABS_MT_PRESSURE, 75 },
2712 { -1, 0 }
2713 };
2714
2715 if (!touchpad_has_palm_pressure(dev))
2716 return;
2717
2718 litest_enable_tap(dev->libinput_device);
2719 litest_drain_events(li);
2720
2721 /* Finger down is palm after tap move threshold */
2722
2723 litest_touch_down(dev, 0, 50, 50);
2724 litest_touch_move_to(dev, 0, 50, 50, 60, 60, 10);
2725 litest_drain_events(li);
2726
2727 litest_touch_move_to_extended(dev, 0, 60, 60, 60, 60, axes, 1);
2728 litest_touch_up(dev, 0);
2729
2730 libinput_dispatch(li);
2731
2732 litest_assert_empty_queue(li);
2733 }
2734 END_TEST
2735
START_TEST(touchpad_tap_palm_on_tapped)2736 START_TEST(touchpad_tap_palm_on_tapped)
2737 {
2738 struct litest_device *dev = litest_current_device();
2739 struct libinput *li = dev->libinput;
2740 struct axis_replacement axes[] = {
2741 { ABS_MT_PRESSURE, 75 },
2742 { -1, 0 }
2743 };
2744
2745 if (!touchpad_has_palm_pressure(dev))
2746 return;
2747
2748 litest_enable_tap(dev->libinput_device);
2749 litest_drain_events(li);
2750
2751 /* tap + palm down */
2752
2753 litest_touch_down(dev, 0, 50, 50);
2754 litest_touch_up(dev, 0);
2755 libinput_dispatch(li);
2756
2757 litest_assert_button_event(li,
2758 BTN_LEFT,
2759 LIBINPUT_BUTTON_STATE_PRESSED);
2760
2761 litest_touch_down(dev, 0, 50, 50);
2762 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2763 litest_touch_up(dev, 0);
2764
2765 libinput_dispatch(li);
2766 litest_timeout_tap();
2767 libinput_dispatch(li);
2768
2769 litest_assert_button_event(li,
2770 BTN_LEFT,
2771 LIBINPUT_BUTTON_STATE_RELEASED);
2772
2773 litest_assert_empty_queue(li);
2774 }
2775 END_TEST
2776
START_TEST(touchpad_tap_palm_on_tapped_palm_down)2777 START_TEST(touchpad_tap_palm_on_tapped_palm_down)
2778 {
2779 struct litest_device *dev = litest_current_device();
2780 struct libinput *li = dev->libinput;
2781 struct axis_replacement axes[] = {
2782 { ABS_MT_PRESSURE, 75 },
2783 { -1, 0 }
2784 };
2785
2786 if (!touchpad_has_palm_pressure(dev))
2787 return;
2788
2789 litest_enable_tap(dev->libinput_device);
2790 litest_drain_events(li);
2791
2792 /* tap + palm down */
2793
2794 litest_touch_down(dev, 0, 50, 50);
2795 litest_touch_up(dev, 0);
2796 libinput_dispatch(li);
2797
2798 litest_assert_button_event(li,
2799 BTN_LEFT,
2800 LIBINPUT_BUTTON_STATE_PRESSED);
2801
2802 litest_touch_down_extended(dev, 0, 50, 50, axes);
2803 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2804 litest_touch_up(dev, 0);
2805
2806 libinput_dispatch(li);
2807 litest_timeout_tap();
2808 libinput_dispatch(li);
2809
2810 litest_assert_button_event(li,
2811 BTN_LEFT,
2812 LIBINPUT_BUTTON_STATE_RELEASED);
2813
2814 litest_assert_empty_queue(li);
2815 }
2816 END_TEST
2817
START_TEST(touchpad_tap_palm_on_tapped_2fg)2818 START_TEST(touchpad_tap_palm_on_tapped_2fg)
2819 {
2820 struct litest_device *dev = litest_current_device();
2821 struct libinput *li = dev->libinput;
2822 struct axis_replacement axes[] = {
2823 { ABS_MT_PRESSURE, 75 },
2824 { -1, 0 }
2825 };
2826
2827 if (!touchpad_has_palm_pressure(dev))
2828 return;
2829
2830 litest_enable_tap(dev->libinput_device);
2831 litest_drain_events(li);
2832
2833 /* tap + palm down + tap with second finger */
2834
2835 litest_touch_down(dev, 0, 50, 50);
2836 litest_touch_up(dev, 0);
2837 libinput_dispatch(li);
2838
2839 litest_assert_button_event(li,
2840 BTN_LEFT,
2841 LIBINPUT_BUTTON_STATE_PRESSED);
2842
2843 litest_touch_down(dev, 0, 50, 50);
2844 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2845
2846 libinput_dispatch(li);
2847
2848 litest_touch_down(dev, 1, 50, 50);
2849 litest_touch_up(dev, 1);
2850 libinput_dispatch(li);
2851
2852 litest_timeout_tap();
2853 libinput_dispatch(li);
2854
2855 litest_assert_button_event(li,
2856 BTN_LEFT,
2857 LIBINPUT_BUTTON_STATE_RELEASED);
2858 litest_assert_button_event(li,
2859 BTN_LEFT,
2860 LIBINPUT_BUTTON_STATE_PRESSED);
2861 litest_assert_button_event(li,
2862 BTN_LEFT,
2863 LIBINPUT_BUTTON_STATE_RELEASED);
2864
2865 litest_touch_up(dev, 0);
2866 litest_assert_empty_queue(li);
2867 }
2868 END_TEST
2869
START_TEST(touchpad_tap_palm_on_drag)2870 START_TEST(touchpad_tap_palm_on_drag)
2871 {
2872 struct litest_device *dev = litest_current_device();
2873 struct libinput *li = dev->libinput;
2874 struct axis_replacement axes[] = {
2875 { ABS_MT_PRESSURE, 75 },
2876 { -1, 0 }
2877 };
2878
2879 if (!touchpad_has_palm_pressure(dev))
2880 return;
2881
2882 litest_enable_tap(dev->libinput_device);
2883 litest_drain_events(li);
2884
2885 /* tap + finger down (->drag), finger turns into palm */
2886
2887 litest_touch_down(dev, 0, 50, 50);
2888 litest_touch_up(dev, 0);
2889 libinput_dispatch(li);
2890
2891 litest_assert_button_event(li,
2892 BTN_LEFT,
2893 LIBINPUT_BUTTON_STATE_PRESSED);
2894
2895 litest_touch_down(dev, 0, 50, 50);
2896 libinput_dispatch(li);
2897 litest_timeout_tap();
2898 libinput_dispatch(li);
2899
2900 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
2901 libinput_dispatch(li);
2902
2903 litest_assert_button_event(li,
2904 BTN_LEFT,
2905 LIBINPUT_BUTTON_STATE_RELEASED);
2906
2907 litest_touch_up(dev, 0);
2908 litest_assert_empty_queue(li);
2909 }
2910 END_TEST
2911
START_TEST(touchpad_tap_palm_on_drag_2fg)2912 START_TEST(touchpad_tap_palm_on_drag_2fg)
2913 {
2914 struct litest_device *dev = litest_current_device();
2915 struct libinput *li = dev->libinput;
2916 struct axis_replacement axes[] = {
2917 { ABS_MT_PRESSURE, 75 },
2918 { -1, 0 }
2919 };
2920 int which = _i; /* ranged test */
2921 int this = which % 2,
2922 other = (which + 1) % 2;
2923
2924 if (!touchpad_has_palm_pressure(dev))
2925 return;
2926
2927 litest_enable_tap(dev->libinput_device);
2928 litest_drain_events(li);
2929
2930 /* tap + finger down, 2nd finger down, finger turns to palm */
2931
2932 litest_touch_down(dev, 0, 50, 50);
2933 litest_touch_up(dev, 0);
2934 libinput_dispatch(li);
2935
2936 litest_assert_button_event(li,
2937 BTN_LEFT,
2938 LIBINPUT_BUTTON_STATE_PRESSED);
2939
2940 litest_touch_down(dev, this, 50, 50);
2941 litest_touch_down(dev, other, 60, 50);
2942 libinput_dispatch(li);
2943
2944 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
2945 libinput_dispatch(li);
2946
2947 litest_touch_move_to(dev, other, 60, 50, 65, 50, 10);
2948 litest_assert_only_typed_events(li,
2949 LIBINPUT_EVENT_POINTER_MOTION);
2950 litest_touch_up(dev, other);
2951
2952 litest_assert_button_event(li,
2953 BTN_LEFT,
2954 LIBINPUT_BUTTON_STATE_RELEASED);
2955
2956 litest_touch_up(dev, this);
2957 litest_assert_empty_queue(li);
2958 }
2959 END_TEST
2960
START_TEST(touchpad_tap_palm_on_touch_2)2961 START_TEST(touchpad_tap_palm_on_touch_2)
2962 {
2963 struct litest_device *dev = litest_current_device();
2964 struct libinput *li = dev->libinput;
2965 struct axis_replacement axes[] = {
2966 { ABS_MT_PRESSURE, 75 },
2967 { -1, 0 }
2968 };
2969 int which = _i; /* ranged test */
2970 int this = which % 2,
2971 other = (which + 1) % 2;
2972
2973 if (!touchpad_has_palm_pressure(dev))
2974 return;
2975
2976 litest_enable_tap(dev->libinput_device);
2977 litest_drain_events(li);
2978
2979 /* 2fg tap with one finger detected as palm */
2980 litest_touch_down(dev, 0, 50, 50);
2981 litest_touch_down(dev, 1, 60, 60);
2982 litest_drain_events(li);
2983 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
2984
2985 litest_touch_up(dev, this);
2986 litest_touch_up(dev, other);
2987
2988 libinput_dispatch(li);
2989 litest_assert_button_event(li,
2990 BTN_LEFT,
2991 LIBINPUT_BUTTON_STATE_PRESSED);
2992 litest_timeout_tap();
2993 litest_assert_button_event(li,
2994 BTN_LEFT,
2995 LIBINPUT_BUTTON_STATE_RELEASED);
2996
2997 litest_assert_empty_queue(li);
2998 }
2999 END_TEST
3000
START_TEST(touchpad_tap_palm_on_touch_2_retouch)3001 START_TEST(touchpad_tap_palm_on_touch_2_retouch)
3002 {
3003 struct litest_device *dev = litest_current_device();
3004 struct libinput *li = dev->libinput;
3005 struct axis_replacement axes[] = {
3006 { ABS_MT_PRESSURE, 75 },
3007 { -1, 0 }
3008 };
3009 int which = _i; /* ranged test */
3010 int this = which % 2,
3011 other = (which + 1) % 2;
3012
3013 if (!touchpad_has_palm_pressure(dev))
3014 return;
3015
3016 litest_enable_tap(dev->libinput_device);
3017 litest_drain_events(li);
3018
3019 /* 2fg tap with one finger detected as palm, that finger is lifted
3020 * and taps again as not-palm */
3021 litest_touch_down(dev, this, 50, 50);
3022 litest_touch_down(dev, other, 60, 60);
3023 litest_drain_events(li);
3024 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
3025 litest_touch_up(dev, this);
3026 libinput_dispatch(li);
3027
3028 litest_touch_down(dev, this, 70, 70);
3029 litest_touch_up(dev, this);
3030 litest_touch_up(dev, other);
3031
3032 libinput_dispatch(li);
3033 litest_assert_button_event(li,
3034 BTN_RIGHT,
3035 LIBINPUT_BUTTON_STATE_PRESSED);
3036 litest_timeout_tap();
3037 litest_assert_button_event(li,
3038 BTN_RIGHT,
3039 LIBINPUT_BUTTON_STATE_RELEASED);
3040
3041 litest_assert_empty_queue(li);
3042 }
3043 END_TEST
3044
START_TEST(touchpad_tap_palm_on_touch_3)3045 START_TEST(touchpad_tap_palm_on_touch_3)
3046 {
3047 struct litest_device *dev = litest_current_device();
3048 struct libinput *li = dev->libinput;
3049 struct axis_replacement axes[] = {
3050 { ABS_MT_PRESSURE, 75 },
3051 { -1, 0 }
3052 };
3053 int which = _i; /* ranged test */
3054 int this = which % 3;
3055
3056 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) <= 3)
3057 return;
3058
3059 if (!touchpad_has_palm_pressure(dev))
3060 return;
3061
3062 litest_enable_tap(dev->libinput_device);
3063 litest_drain_events(li);
3064
3065 /* 3fg tap with one finger detected as palm, that finger is lifted,
3066 other two fingers lifted cause 2fg tap */
3067 litest_touch_down(dev, this, 50, 50);
3068 litest_touch_down(dev, (this + 1) % 3, 60, 50);
3069 litest_touch_down(dev, (this + 2) % 3, 70, 50);
3070 litest_drain_events(li);
3071 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
3072 litest_touch_up(dev, this);
3073 libinput_dispatch(li);
3074
3075 litest_touch_up(dev, (this + 1) % 3);
3076 litest_touch_up(dev, (this + 2) % 3);
3077
3078 libinput_dispatch(li);
3079 litest_assert_button_event(li,
3080 BTN_RIGHT,
3081 LIBINPUT_BUTTON_STATE_PRESSED);
3082 litest_timeout_tap();
3083 litest_assert_button_event(li,
3084 BTN_RIGHT,
3085 LIBINPUT_BUTTON_STATE_RELEASED);
3086
3087 litest_assert_empty_queue(li);
3088 }
3089 END_TEST
3090
START_TEST(touchpad_tap_palm_on_touch_3_retouch)3091 START_TEST(touchpad_tap_palm_on_touch_3_retouch)
3092 {
3093 struct litest_device *dev = litest_current_device();
3094 struct libinput *li = dev->libinput;
3095 struct axis_replacement axes[] = {
3096 { ABS_MT_PRESSURE, 75 },
3097 { -1, 0 }
3098 };
3099 int which = _i; /* ranged test */
3100 int this = which % 3;
3101
3102 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) <= 3)
3103 return;
3104
3105 if (!touchpad_has_palm_pressure(dev))
3106 return;
3107
3108 litest_enable_tap(dev->libinput_device);
3109 litest_drain_events(li);
3110
3111 /* 3fg tap with one finger detected as palm, that finger is lifted,
3112 then put down again as normal finger -> 3fg tap */
3113 litest_touch_down(dev, this, 50, 50);
3114 litest_touch_down(dev, (this + 1) % 3, 60, 50);
3115 litest_touch_down(dev, (this + 2) % 3, 70, 50);
3116 litest_drain_events(li);
3117 litest_timeout_tap();
3118 libinput_dispatch(li);
3119
3120 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
3121 litest_touch_up(dev, this);
3122 libinput_dispatch(li);
3123
3124 litest_touch_down(dev, this, 50, 50);
3125 litest_touch_up(dev, this);
3126 litest_touch_up(dev, (this + 1) % 3);
3127 litest_touch_up(dev, (this + 2) % 3);
3128
3129 libinput_dispatch(li);
3130 litest_assert_button_event(li,
3131 BTN_MIDDLE,
3132 LIBINPUT_BUTTON_STATE_PRESSED);
3133 litest_timeout_tap();
3134 litest_assert_button_event(li,
3135 BTN_MIDDLE,
3136 LIBINPUT_BUTTON_STATE_RELEASED);
3137
3138 litest_assert_empty_queue(li);
3139 }
3140 END_TEST
3141
START_TEST(touchpad_tap_palm_on_touch_4)3142 START_TEST(touchpad_tap_palm_on_touch_4)
3143 {
3144 struct litest_device *dev = litest_current_device();
3145 struct libinput *li = dev->libinput;
3146 struct axis_replacement axes[] = {
3147 { ABS_MT_PRESSURE, 75 },
3148 { -1, 0 }
3149 };
3150 int which = _i; /* ranged test */
3151 int this = which % 4;
3152
3153 if (libevdev_get_abs_maximum(dev->evdev, ABS_MT_SLOT) <= 4)
3154 return;
3155
3156 if (!touchpad_has_palm_pressure(dev))
3157 return;
3158
3159 litest_enable_tap(dev->libinput_device);
3160 litest_drain_events(li);
3161
3162 /* 3fg tap with one finger detected as palm, that finger is lifted,
3163 other two fingers lifted cause 2fg tap */
3164 litest_touch_down(dev, this, 50, 50);
3165 litest_touch_down(dev, (this + 1) % 4, 60, 50);
3166 litest_touch_down(dev, (this + 2) % 4, 70, 50);
3167 litest_touch_down(dev, (this + 3) % 4, 80, 50);
3168 litest_drain_events(li);
3169 litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
3170 litest_touch_up(dev, this);
3171 libinput_dispatch(li);
3172
3173 litest_touch_up(dev, (this + 1) % 4);
3174 litest_touch_up(dev, (this + 2) % 4);
3175 litest_touch_up(dev, (this + 3) % 4);
3176
3177 litest_assert_empty_queue(li);
3178 }
3179 END_TEST
3180
START_TEST(touchpad_tap_palm_after_tap)3181 START_TEST(touchpad_tap_palm_after_tap)
3182 {
3183 struct litest_device *dev = litest_current_device();
3184 struct libinput *li = dev->libinput;
3185 struct axis_replacement axes[] = {
3186 { ABS_MT_PRESSURE, 75 },
3187 { -1, 0 }
3188 };
3189
3190 if (!touchpad_has_palm_pressure(dev))
3191 return;
3192
3193 litest_enable_tap(dev->libinput_device);
3194 litest_drain_events(li);
3195
3196 litest_touch_down(dev, 0, 50, 50);
3197 litest_touch_up(dev, 0);
3198 libinput_dispatch(li);
3199
3200 libinput_dispatch(li);
3201 litest_assert_button_event(li,
3202 BTN_LEFT,
3203 LIBINPUT_BUTTON_STATE_PRESSED);
3204
3205 litest_touch_down(dev, 0, 50, 50);
3206 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3207 litest_touch_up(dev, 0);
3208 libinput_dispatch(li);
3209
3210 litest_timeout_tap();
3211 litest_assert_button_event(li,
3212 BTN_LEFT,
3213 LIBINPUT_BUTTON_STATE_RELEASED);
3214
3215 litest_assert_empty_queue(li);
3216 }
3217 END_TEST
3218
START_TEST(touchpad_tap_palm_multitap)3219 START_TEST(touchpad_tap_palm_multitap)
3220 {
3221 struct litest_device *dev = litest_current_device();
3222 struct libinput *li = dev->libinput;
3223 struct axis_replacement axes[] = {
3224 { ABS_MT_PRESSURE, 75 },
3225 { -1, 0 }
3226 };
3227 int range = _i, /* ranged test */
3228 ntaps;
3229
3230 if (!touchpad_has_palm_pressure(dev))
3231 return;
3232
3233 litest_enable_tap(dev->libinput_device);
3234 litest_drain_events(li);
3235
3236 for (ntaps = 0; ntaps <= range; ntaps++) {
3237 litest_touch_down(dev, 0, 50, 50);
3238 litest_touch_up(dev, 0);
3239 libinput_dispatch(li);
3240 msleep(10);
3241 }
3242
3243 litest_touch_down(dev, 0, 50, 50);
3244 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3245 litest_touch_up(dev, 0);
3246 libinput_dispatch(li);
3247 litest_timeout_tap();
3248 libinput_dispatch(li);
3249
3250 for (ntaps = 0; ntaps <= range; ntaps++) {
3251 litest_assert_button_event(li,
3252 BTN_LEFT,
3253 LIBINPUT_BUTTON_STATE_PRESSED);
3254 litest_assert_button_event(li,
3255 BTN_LEFT,
3256 LIBINPUT_BUTTON_STATE_RELEASED);
3257 }
3258
3259 litest_assert_empty_queue(li);
3260 }
3261 END_TEST
3262
START_TEST(touchpad_tap_palm_multitap_timeout)3263 START_TEST(touchpad_tap_palm_multitap_timeout)
3264 {
3265 struct litest_device *dev = litest_current_device();
3266 struct libinput *li = dev->libinput;
3267 struct axis_replacement axes[] = {
3268 { ABS_MT_PRESSURE, 75 },
3269 { -1, 0 }
3270 };
3271 int range = _i, /* ranged test */
3272 ntaps;
3273
3274 if (!touchpad_has_palm_pressure(dev))
3275 return;
3276
3277 litest_enable_tap(dev->libinput_device);
3278 litest_drain_events(li);
3279
3280 for (ntaps = 0; ntaps <= range; ntaps++) {
3281 litest_touch_down(dev, 0, 50, 50);
3282 litest_touch_up(dev, 0);
3283 libinput_dispatch(li);
3284 msleep(10);
3285 }
3286
3287 litest_touch_down(dev, 0, 50, 50);
3288 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3289 libinput_dispatch(li);
3290 litest_timeout_tap();
3291 libinput_dispatch(li);
3292
3293 for (ntaps = 0; ntaps <= range; ntaps++) {
3294 litest_assert_button_event(li,
3295 BTN_LEFT,
3296 LIBINPUT_BUTTON_STATE_PRESSED);
3297 litest_assert_button_event(li,
3298 BTN_LEFT,
3299 LIBINPUT_BUTTON_STATE_RELEASED);
3300 }
3301
3302 litest_assert_empty_queue(li);
3303 }
3304 END_TEST
3305
START_TEST(touchpad_tap_palm_multitap_down_again)3306 START_TEST(touchpad_tap_palm_multitap_down_again)
3307 {
3308 struct litest_device *dev = litest_current_device();
3309 struct libinput *li = dev->libinput;
3310 struct axis_replacement axes[] = {
3311 { ABS_MT_PRESSURE, 75 },
3312 { -1, 0 }
3313 };
3314 int range = _i, /* ranged test */
3315 ntaps;
3316
3317 if (!touchpad_has_palm_pressure(dev))
3318 return;
3319
3320 litest_enable_tap(dev->libinput_device);
3321 litest_drain_events(li);
3322
3323 for (ntaps = 0; ntaps <= range; ntaps++) {
3324 litest_touch_down(dev, 0, 50, 50);
3325 litest_touch_up(dev, 0);
3326 libinput_dispatch(li);
3327 msleep(10);
3328 }
3329
3330 litest_touch_down(dev, 0, 50, 50);
3331 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3332 libinput_dispatch(li);
3333
3334 /* keep palm finger down */
3335 for (ntaps = 0; ntaps <= range; ntaps++) {
3336 litest_touch_down(dev, 1, 50, 50);
3337 litest_touch_up(dev, 1);
3338 libinput_dispatch(li);
3339 msleep(10);
3340 }
3341
3342 for (ntaps = 0; ntaps <= 2 * range; ntaps++) {
3343 litest_assert_button_event(li,
3344 BTN_LEFT,
3345 LIBINPUT_BUTTON_STATE_PRESSED);
3346 litest_assert_button_event(li,
3347 BTN_LEFT,
3348 LIBINPUT_BUTTON_STATE_RELEASED);
3349 }
3350
3351 litest_touch_up(dev, 0);
3352 litest_assert_empty_queue(li);
3353 }
3354 END_TEST
3355
START_TEST(touchpad_tap_palm_multitap_click)3356 START_TEST(touchpad_tap_palm_multitap_click)
3357 {
3358 struct litest_device *dev = litest_current_device();
3359 struct libinput *li = dev->libinput;
3360 struct axis_replacement axes[] = {
3361 { ABS_MT_PRESSURE, 75 },
3362 { -1, 0 }
3363 };
3364 int range = _i, /* ranged test */
3365 ntaps;
3366
3367 if (!touchpad_has_palm_pressure(dev))
3368 return;
3369
3370 litest_enable_tap(dev->libinput_device);
3371 litest_drain_events(li);
3372
3373 for (ntaps = 0; ntaps <= range; ntaps++) {
3374 litest_touch_down(dev, 0, 50, 50);
3375 litest_touch_up(dev, 0);
3376 libinput_dispatch(li);
3377 msleep(10);
3378 }
3379
3380 litest_touch_down(dev, 0, 50, 50);
3381 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3382 libinput_dispatch(li);
3383 /* keep palm finger down */
3384
3385 litest_button_click(dev, BTN_LEFT, true);
3386 litest_button_click(dev, BTN_LEFT, false);
3387 libinput_dispatch(li);
3388
3389 for (ntaps = 0; ntaps <= range; ntaps++) {
3390 litest_assert_button_event(li,
3391 BTN_LEFT,
3392 LIBINPUT_BUTTON_STATE_PRESSED);
3393 litest_assert_button_event(li,
3394 BTN_LEFT,
3395 LIBINPUT_BUTTON_STATE_RELEASED);
3396 }
3397
3398 /* the click */
3399 litest_assert_button_event(li,
3400 BTN_LEFT,
3401 LIBINPUT_BUTTON_STATE_PRESSED);
3402 litest_assert_button_event(li,
3403 BTN_LEFT,
3404 LIBINPUT_BUTTON_STATE_RELEASED);
3405 litest_touch_up(dev, 0);
3406 litest_assert_empty_queue(li);
3407 }
3408 END_TEST
3409
START_TEST(touchpad_tap_palm_click_then_tap)3410 START_TEST(touchpad_tap_palm_click_then_tap)
3411 {
3412 struct litest_device *dev = litest_current_device();
3413 struct libinput *li = dev->libinput;
3414 struct axis_replacement axes[] = {
3415 { ABS_MT_PRESSURE, 75 },
3416 { -1, 0 }
3417 };
3418
3419 if (!touchpad_has_palm_pressure(dev))
3420 return;
3421
3422 litest_enable_tap(dev->libinput_device);
3423 litest_drain_events(li);
3424
3425 litest_touch_down_extended(dev, 0, 50, 50, axes);
3426 libinput_dispatch(li);
3427
3428 litest_button_click(dev, BTN_LEFT, true);
3429 litest_button_click(dev, BTN_LEFT, false);
3430 libinput_dispatch(li);
3431
3432 litest_assert_button_event(li,
3433 BTN_LEFT,
3434 LIBINPUT_BUTTON_STATE_PRESSED);
3435 litest_assert_button_event(li,
3436 BTN_LEFT,
3437 LIBINPUT_BUTTON_STATE_RELEASED);
3438
3439 litest_touch_up(dev, 0);
3440 litest_assert_empty_queue(li);
3441
3442 litest_touch_down(dev, 0, 50, 50);
3443 litest_touch_up(dev, 0);
3444 libinput_dispatch(li);
3445 litest_timeout_tap();
3446 libinput_dispatch(li);
3447
3448 litest_assert_button_event(li,
3449 BTN_LEFT,
3450 LIBINPUT_BUTTON_STATE_PRESSED);
3451 litest_assert_button_event(li,
3452 BTN_LEFT,
3453 LIBINPUT_BUTTON_STATE_RELEASED);
3454
3455 litest_assert_empty_queue(li);
3456 }
3457 END_TEST
3458
START_TEST(touchpad_tap_palm_dwt_tap)3459 START_TEST(touchpad_tap_palm_dwt_tap)
3460 {
3461 struct litest_device *dev = litest_current_device();
3462 struct litest_device *keyboard;
3463 struct libinput *li = dev->libinput;
3464 struct axis_replacement axes[] = {
3465 { ABS_MT_PRESSURE, 75 },
3466 { -1, 0 }
3467 };
3468
3469 if (!touchpad_has_palm_pressure(dev))
3470 return;
3471
3472 keyboard = litest_add_device(li, LITEST_KEYBOARD);
3473
3474 litest_enable_tap(dev->libinput_device);
3475 litest_drain_events(li);
3476
3477 litest_keyboard_key(keyboard, KEY_A, true);
3478 litest_keyboard_key(keyboard, KEY_B, true);
3479 litest_keyboard_key(keyboard, KEY_A, false);
3480 litest_drain_events(li);
3481
3482 litest_touch_down(dev, 0, 50, 50);
3483 libinput_dispatch(li);
3484
3485 litest_keyboard_key(keyboard, KEY_B, false);
3486 litest_drain_events(li);
3487 litest_timeout_dwt_long();
3488 libinput_dispatch(li);
3489
3490 /* Changes to palm after dwt timeout */
3491 litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
3492 libinput_dispatch(li);
3493
3494 litest_touch_up(dev, 0);
3495 libinput_dispatch(li);
3496
3497 litest_assert_empty_queue(li);
3498
3499 litest_delete_device(keyboard);
3500 }
3501 END_TEST
3502
TEST_COLLECTION(touchpad_tap)3503 TEST_COLLECTION(touchpad_tap)
3504 {
3505 struct range multitap_range = {3, 5};
3506 struct range tap_map_range = { LIBINPUT_CONFIG_TAP_MAP_LRM,
3507 LIBINPUT_CONFIG_TAP_MAP_LMR + 1 };
3508 struct range range_2fg = {0, 2};
3509 struct range range_3fg = {0, 3};
3510 struct range range_4fg = {0, 4};
3511
3512 litest_add("tap-1fg:1fg", touchpad_1fg_tap, LITEST_TOUCHPAD, LITEST_ANY);
3513 litest_add("tap-1fg:1fg", touchpad_1fg_doubletap, LITEST_TOUCHPAD, LITEST_ANY);
3514 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3515 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_timeout, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3516 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_timeout, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3517 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_tap, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3518 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_move, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3519 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &multitap_range);
3520 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_click, LITEST_CLICKPAD, LITEST_ANY, &multitap_range);
3521 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY);
3522 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag_draglock, LITEST_TOUCHPAD, LITEST_ANY);
3523 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag_draglock_tap, LITEST_TOUCHPAD, LITEST_ANY);
3524 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag_draglock_timeout, LITEST_TOUCHPAD, LITEST_ANY);
3525 litest_add("tap-2fg:2fg", touchpad_2fg_tap_n_drag, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3526 litest_add("tap-2fg:2fg", touchpad_2fg_tap_n_drag_3fg_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_APPLE_CLICKPAD);
3527 litest_add("tap-2fg:2fg", touchpad_2fg_tap_n_drag_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3528 litest_add_ranged("tap-2fg:2fg", touchpad_2fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT, &tap_map_range);
3529 litest_add_ranged("tap-2fg:2fg", touchpad_2fg_tap_inverted, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &tap_map_range);
3530 litest_add("tap-2fg:2fg", touchpad_2fg_tap_move_on_release, LITEST_TOUCHPAD|LITEST_SEMI_MT, LITEST_SINGLE_TOUCH);
3531 litest_add("tap-2fg:2fg", touchpad_2fg_tap_n_hold_first, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3532 litest_add("tap-2fg:2fg", touchpad_2fg_tap_n_hold_second, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3533 litest_add("tap-2fg:2fg", touchpad_2fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3534 litest_add("tap-2fg:2fg", touchpad_1fg_tap_click, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_CLICKPAD);
3535 litest_add("tap-2fg:2fg", touchpad_2fg_tap_click, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_SINGLE_TOUCH|LITEST_CLICKPAD);
3536
3537 litest_add("tap-2fg:2fg", touchpad_2fg_tap_click_apple, LITEST_APPLE_CLICKPAD, LITEST_ANY);
3538 litest_add("tap-2fg:2fg", touchpad_no_2fg_tap_after_move, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3539 litest_add("tap-2fg:2fg", touchpad_no_2fg_tap_after_timeout, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3540 litest_add("tap-2fg:2fg", touchpad_no_first_fg_tap_after_move, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3541 litest_add_ranged("tap-3fg:3fg", touchpad_3fg_tap_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &tap_map_range);
3542 litest_add_ranged("tap-3fg:3fg", touchpad_3fg_tap_btntool_inverted, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &tap_map_range);
3543 litest_add_ranged("tap-3fg:3fg", touchpad_3fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &tap_map_range);
3544 litest_add("tap-3fg:3fg", touchpad_3fg_tap_tap_again, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3545 litest_add("tap-3fg:3fg", touchpad_3fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3546 litest_add("tap-3fg:3fg", touchpad_3fg_tap_hover_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3547 litest_add("tap-3fg:3fg", touchpad_3fg_tap_pressure_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3548 litest_add_for_device("tap-3fg:3fg", touchpad_3fg_tap_btntool_pointerjump, LITEST_SYNAPTICS_TOPBUTTONPAD);
3549 litest_add_for_device("tap-3fg:3fg", touchpad_3fg_tap_slot_release_btntool, LITEST_SYNAPTICS_TOPBUTTONPAD);
3550
3551 litest_add("tap-4fg:4fg", touchpad_4fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3552 litest_add("tap-4fg:4fg", touchpad_4fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3553 litest_add("tap-5fg:5fg", touchpad_5fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3554 litest_add("tap-5fg:5fg", touchpad_5fg_tap_quickrelease, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3555
3556 /* Real buttons don't interfere with tapping, so don't run those for
3557 pads with buttons */
3558 litest_add("tap-1fg:1fg", touchpad_1fg_double_tap_click, LITEST_CLICKPAD, LITEST_ANY);
3559 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag_click, LITEST_CLICKPAD, LITEST_ANY);
3560 litest_add_ranged("tap-multitap:1fg", touchpad_1fg_multitap_n_drag_tap_click, LITEST_CLICKPAD, LITEST_ANY, &multitap_range);
3561 litest_add("tap-1fg:1fg", touchpad_1fg_tap_n_drag_draglock_tap_click, LITEST_CLICKPAD, LITEST_ANY);
3562
3563 litest_add("tap:config", touchpad_tap_default_disabled, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_ANY);
3564 litest_add("tap:config", touchpad_tap_default_enabled, LITEST_TOUCHPAD, LITEST_BUTTON);
3565 litest_add("tap:config", touchpad_tap_invalid, LITEST_TOUCHPAD, LITEST_ANY);
3566 litest_add("tap:config", touchpad_tap_is_available, LITEST_TOUCHPAD, LITEST_ANY);
3567 litest_add("tap:config", touchpad_tap_is_not_available, LITEST_ANY, LITEST_TOUCHPAD);
3568
3569 litest_add("tap:config", touchpad_tap_default_map, LITEST_TOUCHPAD, LITEST_ANY);
3570 litest_add("tap:config", touchpad_tap_map_unsupported, LITEST_ANY, LITEST_TOUCHPAD);
3571 litest_add("tap:config", touchpad_tap_set_map, LITEST_TOUCHPAD, LITEST_ANY);
3572 litest_add("tap:config", touchpad_tap_set_map_no_tapping, LITEST_ANY, LITEST_TOUCHPAD);
3573 litest_add("tap:config", touchpad_tap_get_map_no_tapping, LITEST_ANY, LITEST_TOUCHPAD);
3574 litest_add("tap:config", touchpad_tap_map_delayed, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
3575
3576 litest_add("tap-1fg:1fg", clickpad_1fg_tap_click, LITEST_CLICKPAD, LITEST_ANY);
3577 litest_add("tap-2fg:2fg", clickpad_2fg_tap_click, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH|LITEST_APPLE_CLICKPAD);
3578
3579 litest_add("tap:draglock", touchpad_drag_lock_default_disabled, LITEST_TOUCHPAD, LITEST_ANY);
3580 litest_add("tap:draglock", touchpad_drag_lock_default_unavailable, LITEST_ANY, LITEST_TOUCHPAD);
3581
3582 litest_add("tap:drag", touchpad_drag_default_disabled, LITEST_ANY, LITEST_TOUCHPAD);
3583 litest_add("tap:drag", touchpad_drag_default_enabled, LITEST_TOUCHPAD, LITEST_BUTTON);
3584 litest_add("tap:drag", touchpad_drag_config_invalid, LITEST_TOUCHPAD, LITEST_ANY);
3585 litest_add("tap:drag", touchpad_drag_config_unsupported, LITEST_ANY, LITEST_TOUCHPAD);
3586 litest_add("tap:drag", touchpad_drag_config_enabledisable, LITEST_TOUCHPAD, LITEST_ANY);
3587 litest_add("tap:drag", touchpad_drag_disabled, LITEST_TOUCHPAD, LITEST_ANY);
3588 litest_add("tap:drag", touchpad_drag_disabled_immediate, LITEST_TOUCHPAD, LITEST_ANY);
3589 litest_add_ranged("tap-multitap:drag", touchpad_drag_disabled_multitap_no_drag, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3590
3591 litest_add("tap:palm", touchpad_tap_palm_on_idle, LITEST_TOUCHPAD, LITEST_ANY);
3592 litest_add("tap:palm", touchpad_tap_palm_on_touch, LITEST_TOUCHPAD, LITEST_ANY);
3593 litest_add("tap:palm", touchpad_tap_palm_on_touch_hold_timeout, LITEST_TOUCHPAD, LITEST_ANY);
3594 litest_add("tap:palm", touchpad_tap_palm_on_touch_hold_move, LITEST_TOUCHPAD, LITEST_ANY);
3595 litest_add("tap:palm", touchpad_tap_palm_on_tapped, LITEST_TOUCHPAD, LITEST_ANY);
3596 litest_add("tap:palm", touchpad_tap_palm_on_tapped_palm_down, LITEST_TOUCHPAD, LITEST_ANY);
3597 litest_add("tap:palm", touchpad_tap_palm_on_tapped_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
3598 litest_add("tap:palm", touchpad_tap_palm_on_drag, LITEST_TOUCHPAD, LITEST_ANY);
3599 litest_add_ranged("tap:palm", touchpad_tap_palm_on_drag_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_2fg);
3600 litest_add_ranged("tap:palm", touchpad_tap_palm_on_touch_2, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_2fg);
3601 litest_add_ranged("tap:palm", touchpad_tap_palm_on_touch_2_retouch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_2fg);
3602 litest_add_ranged("tap:palm", touchpad_tap_palm_on_touch_3, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_3fg);
3603 litest_add_ranged("tap:palm", touchpad_tap_palm_on_touch_3_retouch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_3fg);
3604 litest_add_ranged("tap:palm", touchpad_tap_palm_on_touch_4, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_4fg);
3605 litest_add("tap:palm", touchpad_tap_palm_after_tap, LITEST_TOUCHPAD, LITEST_ANY);
3606 litest_add_ranged("tap:palm", touchpad_tap_palm_multitap, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3607 litest_add_ranged("tap:palm", touchpad_tap_palm_multitap_timeout, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3608 litest_add_ranged("tap:palm", touchpad_tap_palm_multitap_down_again, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &multitap_range);
3609 litest_add_ranged("tap:palm", touchpad_tap_palm_multitap_click, LITEST_TOUCHPAD, LITEST_ANY, &multitap_range);
3610 litest_add("tap:palm", touchpad_tap_palm_click_then_tap, LITEST_TOUCHPAD, LITEST_ANY);
3611 litest_add("tap:palm", touchpad_tap_palm_dwt_tap, LITEST_TOUCHPAD, LITEST_ANY);
3612 }
3613