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