1 /*
2 * Copyright © 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 <libinput.h>
28 #include <valgrind/valgrind.h>
29
30 #include "libinput-util.h"
31 #include "litest.h"
32
33 enum cardinal {
34 N, NE, E, SE, S, SW, W, NW, NCARDINALS
35 };
36
37 enum hold_gesture_behaviour {
38 HOLD_GESTURE_IGNORE,
39 HOLD_GESTURE_REQUIRE,
40 };
41
42 static void
test_gesture_swipe_3fg(int cardinal,enum hold_gesture_behaviour hold)43 test_gesture_swipe_3fg(int cardinal, enum hold_gesture_behaviour hold)
44 {
45 struct litest_device *dev = litest_current_device();
46 struct libinput *li = dev->libinput;
47 struct libinput_event *event;
48 struct libinput_event_gesture *gevent;
49 double dx, dy;
50 double dir_x, dir_y;
51 int cardinals[NCARDINALS][2] = {
52 { 0, 30 },
53 { 30, 30 },
54 { 30, 0 },
55 { 30, -30 },
56 { 0, -30 },
57 { -30, -30 },
58 { -30, 0 },
59 { -30, 30 },
60 };
61
62 if (litest_slot_count(dev) < 3)
63 return;
64
65 dir_x = cardinals[cardinal][0];
66 dir_y = cardinals[cardinal][1];
67
68 litest_drain_events(li);
69
70 litest_touch_down(dev, 0, 40, 40);
71 litest_touch_down(dev, 1, 50, 40);
72 litest_touch_down(dev, 2, 60, 40);
73 libinput_dispatch(li);
74
75 if (hold == HOLD_GESTURE_REQUIRE)
76 litest_timeout_gesture_hold();
77
78 litest_touch_move_three_touches(dev, 40, 40, 50, 40, 60, 40, dir_x,
79 dir_y, 10);
80 libinput_dispatch(li);
81
82 if (hold == HOLD_GESTURE_REQUIRE) {
83 litest_assert_gesture_event(li,
84 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
85 3);
86 litest_assert_gesture_event(li,
87 LIBINPUT_EVENT_GESTURE_HOLD_END,
88 3);
89 }
90
91 event = libinput_get_event(li);
92 gevent = litest_is_gesture_event(event,
93 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
94 3);
95 dx = libinput_event_gesture_get_dx(gevent);
96 dy = libinput_event_gesture_get_dy(gevent);
97 ck_assert(dx == 0.0);
98 ck_assert(dy == 0.0);
99 libinput_event_destroy(event);
100
101 while ((event = libinput_get_event(li)) != NULL) {
102 gevent = litest_is_gesture_event(event,
103 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
104 3);
105
106 dx = libinput_event_gesture_get_dx(gevent);
107 dy = libinput_event_gesture_get_dy(gevent);
108 if (dir_x == 0.0)
109 ck_assert(dx == 0.0);
110 else if (dir_x < 0.0)
111 ck_assert(dx < 0.0);
112 else if (dir_x > 0.0)
113 ck_assert(dx > 0.0);
114
115 if (dir_y == 0.0)
116 ck_assert(dy == 0.0);
117 else if (dir_y < 0.0)
118 ck_assert(dy < 0.0);
119 else if (dir_y > 0.0)
120 ck_assert(dy > 0.0);
121
122 dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
123 dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
124 if (dir_x == 0.0)
125 ck_assert(dx == 0.0);
126 else if (dir_x < 0.0)
127 ck_assert(dx < 0.0);
128 else if (dir_x > 0.0)
129 ck_assert(dx > 0.0);
130
131 if (dir_y == 0.0)
132 ck_assert(dy == 0.0);
133 else if (dir_y < 0.0)
134 ck_assert(dy < 0.0);
135 else if (dir_y > 0.0)
136 ck_assert(dy > 0.0);
137
138 libinput_event_destroy(event);
139 }
140
141 litest_touch_up(dev, 0);
142 litest_touch_up(dev, 1);
143 litest_touch_up(dev, 2);
144 libinput_dispatch(li);
145 event = libinput_get_event(li);
146 gevent = litest_is_gesture_event(event,
147 LIBINPUT_EVENT_GESTURE_SWIPE_END,
148 3);
149 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
150 libinput_event_destroy(event);
151 }
152
153 static void
test_gesture_swipe_4fg(int cardinal,enum hold_gesture_behaviour hold)154 test_gesture_swipe_4fg(int cardinal, enum hold_gesture_behaviour hold)
155 {
156 struct litest_device *dev = litest_current_device();
157 struct libinput *li = dev->libinput;
158 struct libinput_event *event;
159 struct libinput_event_gesture *gevent;
160 double dx, dy;
161 double dir_x, dir_y;
162 int cardinals[NCARDINALS][2] = {
163 { 0, 3 },
164 { 3, 3 },
165 { 3, 0 },
166 { 3, -3 },
167 { 0, -3 },
168 { -3, -3 },
169 { -3, 0 },
170 { -3, 3 },
171 };
172 int i;
173
174 if (litest_slot_count(dev) < 4)
175 return;
176
177 dir_x = cardinals[cardinal][0];
178 dir_y = cardinals[cardinal][1];
179
180 litest_drain_events(li);
181
182 litest_touch_down(dev, 0, 40, 40);
183 litest_touch_down(dev, 1, 50, 40);
184 litest_touch_down(dev, 2, 60, 40);
185 litest_touch_down(dev, 3, 70, 40);
186 libinput_dispatch(li);
187
188 if (hold == HOLD_GESTURE_REQUIRE)
189 litest_timeout_gesture_hold();
190
191 for (i = 0; i < 8; i++) {
192 litest_push_event_frame(dev);
193
194 dir_x += cardinals[cardinal][0];
195 dir_y += cardinals[cardinal][1];
196
197 litest_touch_move(dev,
198 0,
199 40 + dir_x,
200 40 + dir_y);
201 litest_touch_move(dev,
202 1,
203 50 + dir_x,
204 40 + dir_y);
205 litest_touch_move(dev,
206 2,
207 60 + dir_x,
208 40 + dir_y);
209 litest_touch_move(dev,
210 3,
211 70 + dir_x,
212 40 + dir_y);
213 litest_pop_event_frame(dev);
214 libinput_dispatch(li);
215 }
216
217 libinput_dispatch(li);
218
219 if (hold == HOLD_GESTURE_REQUIRE) {
220 litest_assert_gesture_event(li,
221 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
222 4);
223 litest_assert_gesture_event(li,
224 LIBINPUT_EVENT_GESTURE_HOLD_END,
225 4);
226 }
227
228 event = libinput_get_event(li);
229 gevent = litest_is_gesture_event(event,
230 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
231 4);
232 dx = libinput_event_gesture_get_dx(gevent);
233 dy = libinput_event_gesture_get_dy(gevent);
234 ck_assert(dx == 0.0);
235 ck_assert(dy == 0.0);
236 libinput_event_destroy(event);
237
238 while ((event = libinput_get_event(li)) != NULL) {
239 gevent = litest_is_gesture_event(event,
240 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
241 4);
242
243 dx = libinput_event_gesture_get_dx(gevent);
244 dy = libinput_event_gesture_get_dy(gevent);
245 if (dir_x == 0.0)
246 ck_assert(dx == 0.0);
247 else if (dir_x < 0.0)
248 ck_assert(dx < 0.0);
249 else if (dir_x > 0.0)
250 ck_assert(dx > 0.0);
251
252 if (dir_y == 0.0)
253 ck_assert(dy == 0.0);
254 else if (dir_y < 0.0)
255 ck_assert(dy < 0.0);
256 else if (dir_y > 0.0)
257 ck_assert(dy > 0.0);
258
259 dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
260 dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
261 if (dir_x == 0.0)
262 ck_assert(dx == 0.0);
263 else if (dir_x < 0.0)
264 ck_assert(dx < 0.0);
265 else if (dir_x > 0.0)
266 ck_assert(dx > 0.0);
267
268 if (dir_y == 0.0)
269 ck_assert(dy == 0.0);
270 else if (dir_y < 0.0)
271 ck_assert(dy < 0.0);
272 else if (dir_y > 0.0)
273 ck_assert(dy > 0.0);
274
275 libinput_event_destroy(event);
276 }
277
278 litest_touch_up(dev, 0);
279 litest_touch_up(dev, 1);
280 litest_touch_up(dev, 2);
281 litest_touch_up(dev, 3);
282 libinput_dispatch(li);
283 event = libinput_get_event(li);
284 gevent = litest_is_gesture_event(event,
285 LIBINPUT_EVENT_GESTURE_SWIPE_END,
286 4);
287 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
288 libinput_event_destroy(event);
289 }
290
291 static void
test_gesture_pinch_2fg(int cardinal,enum hold_gesture_behaviour hold)292 test_gesture_pinch_2fg(int cardinal, enum hold_gesture_behaviour hold)
293 {
294 struct litest_device *dev = litest_current_device();
295 struct libinput *li = dev->libinput;
296 struct libinput_event *event;
297 struct libinput_event_gesture *gevent;
298 double dx, dy;
299 double dir_x, dir_y;
300 int i;
301 double scale, oldscale;
302 double angle;
303 int cardinals[NCARDINALS][2] = {
304 { 0, 30 },
305 { 30, 30 },
306 { 30, 0 },
307 { 30, -30 },
308 { 0, -30 },
309 { -30, -30 },
310 { -30, 0 },
311 { -30, 30 },
312 };
313
314 if (litest_slot_count(dev) < 2 ||
315 !libinput_device_has_capability(dev->libinput_device,
316 LIBINPUT_DEVICE_CAP_GESTURE))
317 return;
318
319 /* If the device is too small to provide a finger spread wide enough
320 * to avoid the scroll bias, skip the test */
321 if (cardinal == E || cardinal == W) {
322 double w = 0, h = 0;
323 libinput_device_get_size(dev->libinput_device, &w, &h);
324 /* 0.6 because the code below gives us points like 20/y and
325 * 80/y. 45 because the threshold in the code is 40mm */
326 if (w * 0.6 < 45)
327 return;
328 }
329
330 dir_x = cardinals[cardinal][0];
331 dir_y = cardinals[cardinal][1];
332
333 litest_drain_events(li);
334
335 litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
336 litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
337 libinput_dispatch(li);
338
339 if (hold == HOLD_GESTURE_REQUIRE)
340 litest_timeout_gesture_hold();
341
342 for (i = 0; i < 8; i++) {
343 litest_push_event_frame(dev);
344 if (dir_x > 0.0)
345 dir_x -= 2;
346 else if (dir_x < 0.0)
347 dir_x += 2;
348 if (dir_y > 0.0)
349 dir_y -= 2;
350 else if (dir_y < 0.0)
351 dir_y += 2;
352 litest_touch_move(dev,
353 0,
354 50 + dir_x,
355 50 + dir_y);
356 litest_touch_move(dev,
357 1,
358 50 - dir_x,
359 50 - dir_y);
360 litest_pop_event_frame(dev);
361 libinput_dispatch(li);
362 }
363
364 if (hold == HOLD_GESTURE_REQUIRE) {
365 litest_assert_gesture_event(li,
366 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
367 2);
368 litest_assert_gesture_event(li,
369 LIBINPUT_EVENT_GESTURE_HOLD_END,
370 2);
371 }
372
373 event = libinput_get_event(li);
374 gevent = litest_is_gesture_event(event,
375 LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
376 2);
377 dx = libinput_event_gesture_get_dx(gevent);
378 dy = libinput_event_gesture_get_dy(gevent);
379 scale = libinput_event_gesture_get_scale(gevent);
380 ck_assert(dx == 0.0);
381 ck_assert(dy == 0.0);
382 ck_assert(scale == 1.0);
383
384 libinput_event_destroy(event);
385
386 while ((event = libinput_get_event(li)) != NULL) {
387 gevent = litest_is_gesture_event(event,
388 LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
389 2);
390
391 oldscale = scale;
392 scale = libinput_event_gesture_get_scale(gevent);
393
394 ck_assert(scale < oldscale);
395
396 angle = libinput_event_gesture_get_angle_delta(gevent);
397 ck_assert_double_le(fabs(angle), 1.0);
398
399 libinput_event_destroy(event);
400 libinput_dispatch(li);
401 }
402
403 litest_touch_up(dev, 0);
404 litest_touch_up(dev, 1);
405 libinput_dispatch(li);
406 event = libinput_get_event(li);
407 gevent = litest_is_gesture_event(event,
408 LIBINPUT_EVENT_GESTURE_PINCH_END,
409 2);
410 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
411 libinput_event_destroy(event);
412 }
413
414 static void
test_gesture_pinch_3fg(int cardinal,enum hold_gesture_behaviour hold)415 test_gesture_pinch_3fg(int cardinal, enum hold_gesture_behaviour hold)
416 {
417 struct litest_device *dev = litest_current_device();
418 struct libinput *li = dev->libinput;
419 struct libinput_event *event;
420 struct libinput_event_gesture *gevent;
421 double dx, dy;
422 double dir_x, dir_y;
423 int i;
424 double scale, oldscale;
425 double angle;
426 int cardinals[NCARDINALS][2] = {
427 { 0, 30 },
428 { 30, 30 },
429 { 30, 0 },
430 { 30, -30 },
431 { 0, -30 },
432 { -30, -30 },
433 { -30, 0 },
434 { -30, 30 },
435 };
436
437 if (litest_slot_count(dev) < 3)
438 return;
439
440 dir_x = cardinals[cardinal][0];
441 dir_y = cardinals[cardinal][1];
442
443 litest_drain_events(li);
444
445 litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
446 litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
447 litest_touch_down(dev, 2, 51 - dir_x, 51 - dir_y);
448 libinput_dispatch(li);
449
450 if (hold == HOLD_GESTURE_REQUIRE)
451 litest_timeout_gesture_hold();
452
453 for (i = 0; i < 8; i++) {
454 litest_push_event_frame(dev);
455 if (dir_x > 0.0)
456 dir_x -= 2;
457 else if (dir_x < 0.0)
458 dir_x += 2;
459 if (dir_y > 0.0)
460 dir_y -= 2;
461 else if (dir_y < 0.0)
462 dir_y += 2;
463 litest_touch_move(dev,
464 0,
465 50 + dir_x,
466 50 + dir_y);
467 litest_touch_move(dev,
468 1,
469 50 - dir_x,
470 50 - dir_y);
471 litest_touch_move(dev,
472 2,
473 51 - dir_x,
474 51 - dir_y);
475 litest_pop_event_frame(dev);
476 libinput_dispatch(li);
477 }
478
479 if (hold == HOLD_GESTURE_REQUIRE) {
480 litest_assert_gesture_event(li,
481 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
482 3);
483 litest_assert_gesture_event(li,
484 LIBINPUT_EVENT_GESTURE_HOLD_END,
485 3);
486 }
487 event = libinput_get_event(li);
488 gevent = litest_is_gesture_event(event,
489 LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
490 3);
491 dx = libinput_event_gesture_get_dx(gevent);
492 dy = libinput_event_gesture_get_dy(gevent);
493 scale = libinput_event_gesture_get_scale(gevent);
494 ck_assert(dx == 0.0);
495 ck_assert(dy == 0.0);
496 ck_assert(scale == 1.0);
497
498 libinput_event_destroy(event);
499
500 while ((event = libinput_get_event(li)) != NULL) {
501 gevent = litest_is_gesture_event(event,
502 LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
503 3);
504
505 oldscale = scale;
506 scale = libinput_event_gesture_get_scale(gevent);
507
508 ck_assert(scale < oldscale);
509
510 angle = libinput_event_gesture_get_angle_delta(gevent);
511 ck_assert_double_le(fabs(angle), 1.0);
512
513 libinput_event_destroy(event);
514 libinput_dispatch(li);
515 }
516
517 litest_touch_up(dev, 0);
518 litest_touch_up(dev, 1);
519 litest_touch_up(dev, 2);
520 libinput_dispatch(li);
521 event = libinput_get_event(li);
522 gevent = litest_is_gesture_event(event,
523 LIBINPUT_EVENT_GESTURE_PINCH_END,
524 3);
525 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
526 libinput_event_destroy(event);
527 }
528
529 static void
test_gesture_pinch_4fg(int cardinal,enum hold_gesture_behaviour hold)530 test_gesture_pinch_4fg(int cardinal, enum hold_gesture_behaviour hold)
531 {
532 struct litest_device *dev = litest_current_device();
533 struct libinput *li = dev->libinput;
534 struct libinput_event *event;
535 struct libinput_event_gesture *gevent;
536 double dx, dy;
537 double dir_x, dir_y;
538 int i;
539 double scale, oldscale;
540 double angle;
541 int cardinals[NCARDINALS][2] = {
542 { 0, 30 },
543 { 30, 30 },
544 { 30, 0 },
545 { 30, -30 },
546 { 0, -30 },
547 { -30, -30 },
548 { -30, 0 },
549 { -30, 30 },
550 };
551
552 if (litest_slot_count(dev) < 4)
553 return;
554
555 dir_x = cardinals[cardinal][0];
556 dir_y = cardinals[cardinal][1];
557
558 litest_drain_events(li);
559
560 litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
561 litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
562 litest_touch_down(dev, 2, 51 - dir_x, 51 - dir_y);
563 litest_touch_down(dev, 3, 52 - dir_x, 52 - dir_y);
564 libinput_dispatch(li);
565
566 if (hold == HOLD_GESTURE_REQUIRE)
567 litest_timeout_gesture_hold();
568
569 for (i = 0; i < 7; i++) {
570 litest_push_event_frame(dev);
571 if (dir_x > 0.0)
572 dir_x -= 2;
573 else if (dir_x < 0.0)
574 dir_x += 2;
575 if (dir_y > 0.0)
576 dir_y -= 2;
577 else if (dir_y < 0.0)
578 dir_y += 2;
579 litest_touch_move(dev,
580 0,
581 50 + dir_x,
582 50 + dir_y);
583 litest_touch_move(dev,
584 1,
585 50 - dir_x,
586 50 - dir_y);
587 litest_touch_move(dev,
588 2,
589 51 - dir_x,
590 51 - dir_y);
591 litest_touch_move(dev,
592 3,
593 52 - dir_x,
594 52 - dir_y);
595 litest_pop_event_frame(dev);
596 libinput_dispatch(li);
597 }
598
599 if (hold == HOLD_GESTURE_REQUIRE) {
600 litest_assert_gesture_event(li,
601 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
602 4);
603 litest_assert_gesture_event(li,
604 LIBINPUT_EVENT_GESTURE_HOLD_END,
605 4);
606 }
607
608 event = libinput_get_event(li);
609 gevent = litest_is_gesture_event(event,
610 LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
611 4);
612 dx = libinput_event_gesture_get_dx(gevent);
613 dy = libinput_event_gesture_get_dy(gevent);
614 scale = libinput_event_gesture_get_scale(gevent);
615 ck_assert(dx == 0.0);
616 ck_assert(dy == 0.0);
617 ck_assert(scale == 1.0);
618
619 libinput_event_destroy(event);
620
621 while ((event = libinput_get_event(li)) != NULL) {
622 gevent = litest_is_gesture_event(event,
623 LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
624 4);
625
626 oldscale = scale;
627 scale = libinput_event_gesture_get_scale(gevent);
628
629 ck_assert(scale < oldscale);
630
631 angle = libinput_event_gesture_get_angle_delta(gevent);
632 ck_assert_double_le(fabs(angle), 1.0);
633
634 libinput_event_destroy(event);
635 libinput_dispatch(li);
636 }
637
638 litest_touch_up(dev, 0);
639 litest_touch_up(dev, 1);
640 litest_touch_up(dev, 2);
641 litest_touch_up(dev, 3);
642 libinput_dispatch(li);
643 event = libinput_get_event(li);
644 gevent = litest_is_gesture_event(event,
645 LIBINPUT_EVENT_GESTURE_PINCH_END,
646 4);
647 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
648 libinput_event_destroy(event);
649 }
650
651 static void
test_gesture_spread(int cardinal,enum hold_gesture_behaviour hold)652 test_gesture_spread(int cardinal, enum hold_gesture_behaviour hold)
653 {
654 struct litest_device *dev = litest_current_device();
655 struct libinput *li = dev->libinput;
656 struct libinput_event *event;
657 struct libinput_event_gesture *gevent;
658 double dx, dy;
659 double dir_x, dir_y;
660 int i;
661 double scale, oldscale;
662 double angle;
663 int cardinals[NCARDINALS][2] = {
664 { 0, 30 },
665 { 30, 30 },
666 { 30, 0 },
667 { 30, -30 },
668 { 0, -30 },
669 { -30, -30 },
670 { -30, 0 },
671 { -30, 30 },
672 };
673
674 if (litest_slot_count(dev) < 2 ||
675 !libinput_device_has_capability(dev->libinput_device,
676 LIBINPUT_DEVICE_CAP_GESTURE))
677 return;
678
679 /* If the device is too small to provide a finger spread wide enough
680 * to avoid the scroll bias, skip the test */
681 if (cardinal == E || cardinal == W) {
682 double w = 0, h = 0;
683 libinput_device_get_size(dev->libinput_device, &w, &h);
684 /* 0.6 because the code below gives us points like 20/y and
685 * 80/y. 45 because the threshold in the code is 40mm */
686 if (w * 0.6 < 45)
687 return;
688 }
689
690 dir_x = cardinals[cardinal][0];
691 dir_y = cardinals[cardinal][1];
692
693 litest_drain_events(li);
694
695 litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
696 litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
697 libinput_dispatch(li);
698
699 if (hold == HOLD_GESTURE_REQUIRE)
700 litest_timeout_gesture_hold();
701
702 for (i = 0; i < 15; i++) {
703 litest_push_event_frame(dev);
704 if (dir_x > 0.0)
705 dir_x += 1;
706 else if (dir_x < 0.0)
707 dir_x -= 1;
708 if (dir_y > 0.0)
709 dir_y += 1;
710 else if (dir_y < 0.0)
711 dir_y -= 1;
712 litest_touch_move(dev,
713 0,
714 50 + dir_x,
715 50 + dir_y);
716 litest_touch_move(dev,
717 1,
718 50 - dir_x,
719 50 - dir_y);
720 litest_pop_event_frame(dev);
721 libinput_dispatch(li);
722 }
723
724 if (hold == HOLD_GESTURE_REQUIRE) {
725 litest_assert_gesture_event(li,
726 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
727 2);
728 litest_assert_gesture_event(li,
729 LIBINPUT_EVENT_GESTURE_HOLD_END,
730 2);
731 }
732
733 event = libinput_get_event(li);
734 gevent = litest_is_gesture_event(event,
735 LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
736 2);
737 dx = libinput_event_gesture_get_dx(gevent);
738 dy = libinput_event_gesture_get_dy(gevent);
739 scale = libinput_event_gesture_get_scale(gevent);
740 ck_assert(dx == 0.0);
741 ck_assert(dy == 0.0);
742 ck_assert(scale == 1.0);
743
744 libinput_event_destroy(event);
745
746 while ((event = libinput_get_event(li)) != NULL) {
747 gevent = litest_is_gesture_event(event,
748 LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
749 2);
750 oldscale = scale;
751 scale = libinput_event_gesture_get_scale(gevent);
752 ck_assert(scale > oldscale);
753
754 angle = libinput_event_gesture_get_angle_delta(gevent);
755 ck_assert_double_le(fabs(angle), 1.0);
756
757 libinput_event_destroy(event);
758 libinput_dispatch(li);
759 }
760
761 litest_touch_up(dev, 0);
762 litest_touch_up(dev, 1);
763 libinput_dispatch(li);
764 event = libinput_get_event(li);
765 gevent = litest_is_gesture_event(event,
766 LIBINPUT_EVENT_GESTURE_PINCH_END,
767 2);
768 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
769 libinput_event_destroy(event);
770 }
771
772 static void
test_gesture_3fg_buttonarea_scroll(enum hold_gesture_behaviour hold)773 test_gesture_3fg_buttonarea_scroll(enum hold_gesture_behaviour hold)
774 {
775 struct litest_device *dev = litest_current_device();
776 struct libinput *li = dev->libinput;
777
778 if (litest_slot_count(dev) < 3)
779 return;
780
781 litest_enable_buttonareas(dev);
782 litest_enable_2fg_scroll(dev);
783 litest_drain_events(li);
784
785 litest_touch_down(dev, 0, 40, 20);
786 litest_touch_down(dev, 1, 30, 20);
787 /* third finger in btnarea */
788 litest_touch_down(dev, 2, 50, 99);
789 libinput_dispatch(li);
790
791 if (hold == HOLD_GESTURE_REQUIRE)
792 litest_timeout_gesture_hold();
793
794 litest_touch_move_two_touches(dev, 40, 20, 30, 20, 0, 40, 10);
795
796 litest_touch_up(dev, 0);
797 litest_touch_up(dev, 1);
798 libinput_dispatch(li);
799
800 if (hold == HOLD_GESTURE_REQUIRE) {
801 litest_assert_gesture_event(li,
802 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
803 2);
804 litest_assert_gesture_event(li,
805 LIBINPUT_EVENT_GESTURE_HOLD_END,
806 2);
807 }
808
809 litest_assert_scroll(li,
810 LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
811 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
812 4);
813 }
814
815 static void
test_gesture_hold(int nfingers)816 test_gesture_hold(int nfingers)
817 {
818 struct litest_device *dev = litest_current_device();
819 struct libinput *li = dev->libinput;
820
821 if (litest_slot_count(dev) < nfingers)
822 return;
823
824 litest_drain_events(li);
825
826 switch (nfingers) {
827 case 4:
828 litest_touch_down(dev, 3, 70, 30);
829 _fallthrough_;
830 case 3:
831 litest_touch_down(dev, 2, 60, 30);
832 _fallthrough_;
833 case 2:
834 litest_touch_down(dev, 1, 50, 30);
835 _fallthrough_;
836 case 1:
837 litest_touch_down(dev, 0, 40, 30);
838 break;
839 }
840
841 libinput_dispatch(li);
842 litest_timeout_gesture_hold();
843
844 if (libinput_device_has_capability(dev->libinput_device,
845 LIBINPUT_DEVICE_CAP_GESTURE)) {
846 litest_assert_gesture_event(li,
847 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
848 nfingers);
849 } else {
850 litest_assert_empty_queue(li);
851 }
852
853 switch (nfingers) {
854 case 4:
855 litest_touch_up(dev, 3);
856 _fallthrough_;
857 case 3:
858 litest_touch_up(dev, 2);
859 _fallthrough_;
860 case 2:
861 litest_touch_up(dev, 1);
862 _fallthrough_;
863 case 1:
864 litest_touch_up(dev, 0);
865 break;
866 }
867
868 libinput_dispatch(li);
869 if (libinput_device_has_capability(dev->libinput_device,
870 LIBINPUT_DEVICE_CAP_GESTURE)) {
871 litest_assert_gesture_event(li,
872 LIBINPUT_EVENT_GESTURE_HOLD_END,
873 nfingers);
874 }
875
876 litest_assert_empty_queue(li);
877 }
878
879 static void
test_gesture_hold_cancel(int nfingers)880 test_gesture_hold_cancel(int nfingers)
881 {
882 struct litest_device *dev = litest_current_device();
883 struct libinput *li = dev->libinput;
884 int last_finger = (nfingers - 1);
885
886 if (litest_slot_count(dev) < nfingers)
887 return;
888
889 litest_drain_events(li);
890
891 switch (nfingers) {
892 case 4:
893 litest_touch_down(dev, 3, 70, 30);
894 _fallthrough_;
895 case 3:
896 litest_touch_down(dev, 2, 60, 30);
897 _fallthrough_;
898 case 2:
899 litest_touch_down(dev, 1, 50, 30);
900 _fallthrough_;
901 case 1:
902 litest_touch_down(dev, 0, 40, 30);
903 break;
904 }
905
906 libinput_dispatch(li);
907 litest_timeout_gesture_hold();
908
909 litest_touch_up(dev, last_finger);
910
911 if (libinput_device_has_capability(dev->libinput_device,
912 LIBINPUT_DEVICE_CAP_GESTURE)) {
913 litest_assert_gesture_event(li,
914 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
915 nfingers);
916 litest_assert_gesture_event(li,
917 LIBINPUT_EVENT_GESTURE_HOLD_END,
918 nfingers);
919 }
920
921 litest_assert_empty_queue(li);
922 }
923
START_TEST(gestures_cap)924 START_TEST(gestures_cap)
925 {
926 struct litest_device *dev = litest_current_device();
927 struct libinput_device *device = dev->libinput_device;
928
929 if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT))
930 ck_assert(!libinput_device_has_capability(device,
931 LIBINPUT_DEVICE_CAP_GESTURE));
932 else
933 ck_assert(libinput_device_has_capability(device,
934 LIBINPUT_DEVICE_CAP_GESTURE));
935 }
936 END_TEST
937
START_TEST(gestures_nocap)938 START_TEST(gestures_nocap)
939 {
940 struct litest_device *dev = litest_current_device();
941 struct libinput_device *device = dev->libinput_device;
942
943 ck_assert(!libinput_device_has_capability(device,
944 LIBINPUT_DEVICE_CAP_GESTURE));
945 }
946 END_TEST
947
START_TEST(gestures_swipe_3fg)948 START_TEST(gestures_swipe_3fg)
949 {
950 int cardinal = _i; /* ranged test */
951 test_gesture_swipe_3fg(cardinal, HOLD_GESTURE_IGNORE);
952 }
953 END_TEST
954
START_TEST(gestures_swipe_3fg_btntool)955 START_TEST(gestures_swipe_3fg_btntool)
956 {
957 struct litest_device *dev = litest_current_device();
958 struct libinput *li = dev->libinput;
959 struct libinput_event *event;
960 struct libinput_event_gesture *gevent;
961 double dx, dy;
962 int cardinal = _i; /* ranged test */
963 double dir_x, dir_y;
964 int cardinals[NCARDINALS][2] = {
965 { 0, 30 },
966 { 30, 30 },
967 { 30, 0 },
968 { 30, -30 },
969 { 0, -30 },
970 { -30, -30 },
971 { -30, 0 },
972 { -30, 30 },
973 };
974
975 if (litest_slot_count(dev) > 2 ||
976 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP) ||
977 !libinput_device_has_capability(dev->libinput_device,
978 LIBINPUT_DEVICE_CAP_GESTURE))
979 return;
980
981 dir_x = cardinals[cardinal][0];
982 dir_y = cardinals[cardinal][1];
983
984 litest_drain_events(li);
985
986 litest_touch_down(dev, 0, 40, 40);
987 litest_touch_down(dev, 1, 50, 40);
988 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
989 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
990 litest_event(dev, EV_SYN, SYN_REPORT, 0);
991
992 libinput_dispatch(li);
993 litest_touch_move_two_touches(dev, 40, 40, 50, 40, dir_x, dir_y, 10);
994 libinput_dispatch(li);
995
996 event = libinput_get_event(li);
997 gevent = litest_is_gesture_event(event,
998 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
999 3);
1000 dx = libinput_event_gesture_get_dx(gevent);
1001 dy = libinput_event_gesture_get_dy(gevent);
1002 ck_assert(dx == 0.0);
1003 ck_assert(dy == 0.0);
1004 libinput_event_destroy(event);
1005
1006 while ((event = libinput_get_event(li)) != NULL) {
1007 gevent = litest_is_gesture_event(event,
1008 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
1009 3);
1010
1011 dx = libinput_event_gesture_get_dx(gevent);
1012 dy = libinput_event_gesture_get_dy(gevent);
1013 if (dir_x == 0.0)
1014 ck_assert(dx == 0.0);
1015 else if (dir_x < 0.0)
1016 ck_assert(dx < 0.0);
1017 else if (dir_x > 0.0)
1018 ck_assert(dx > 0.0);
1019
1020 if (dir_y == 0.0)
1021 ck_assert(dy == 0.0);
1022 else if (dir_y < 0.0)
1023 ck_assert(dy < 0.0);
1024 else if (dir_y > 0.0)
1025 ck_assert(dy > 0.0);
1026
1027 dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
1028 dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
1029 if (dir_x == 0.0)
1030 ck_assert(dx == 0.0);
1031 else if (dir_x < 0.0)
1032 ck_assert(dx < 0.0);
1033 else if (dir_x > 0.0)
1034 ck_assert(dx > 0.0);
1035
1036 if (dir_y == 0.0)
1037 ck_assert(dy == 0.0);
1038 else if (dir_y < 0.0)
1039 ck_assert(dy < 0.0);
1040 else if (dir_y > 0.0)
1041 ck_assert(dy > 0.0);
1042
1043 libinput_event_destroy(event);
1044 }
1045
1046 litest_touch_up(dev, 0);
1047 litest_touch_up(dev, 1);
1048 libinput_dispatch(li);
1049 event = libinput_get_event(li);
1050 gevent = litest_is_gesture_event(event,
1051 LIBINPUT_EVENT_GESTURE_SWIPE_END,
1052 3);
1053 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
1054 libinput_event_destroy(event);
1055 }
1056 END_TEST
1057
START_TEST(gestures_swipe_3fg_btntool_pinch_like)1058 START_TEST(gestures_swipe_3fg_btntool_pinch_like)
1059 {
1060 struct litest_device *dev = litest_current_device();
1061 struct libinput *li = dev->libinput;
1062 struct libinput_event *event;
1063 struct libinput_event_gesture *gevent;
1064
1065 if (litest_slot_count(dev) > 2 ||
1066 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP) ||
1067 !libinput_device_has_capability(dev->libinput_device,
1068 LIBINPUT_DEVICE_CAP_GESTURE))
1069 return;
1070
1071 litest_drain_events(li);
1072
1073 /* Technically a pinch position + pinch movement, but expect swipe
1074 * for nfingers > nslots */
1075 litest_touch_down(dev, 0, 20, 60);
1076 litest_touch_down(dev, 1, 50, 20);
1077 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1078 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1079 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1080
1081 libinput_dispatch(li);
1082 litest_touch_move_to(dev, 0, 20, 60, 10, 80, 20);
1083 libinput_dispatch(li);
1084
1085 event = libinput_get_event(li);
1086 litest_is_gesture_event(event, LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN, 3);
1087 libinput_event_destroy(event);
1088
1089 while ((event = libinput_get_event(li)) != NULL) {
1090 litest_is_gesture_event(event,
1091 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
1092 3);
1093 libinput_event_destroy(event);
1094 }
1095
1096 litest_touch_up(dev, 0);
1097 litest_touch_up(dev, 1);
1098 libinput_dispatch(li);
1099 event = libinput_get_event(li);
1100 gevent = litest_is_gesture_event(event,
1101 LIBINPUT_EVENT_GESTURE_SWIPE_END,
1102 3);
1103 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
1104 libinput_event_destroy(event);
1105 }
1106 END_TEST
1107
START_TEST(gestures_swipe_4fg)1108 START_TEST(gestures_swipe_4fg)
1109 {
1110 int cardinal = _i; /* ranged test */
1111 test_gesture_swipe_4fg(cardinal, HOLD_GESTURE_IGNORE);
1112 }
1113 END_TEST
1114
START_TEST(gestures_swipe_4fg_btntool)1115 START_TEST(gestures_swipe_4fg_btntool)
1116 {
1117 struct litest_device *dev = litest_current_device();
1118 struct libinput *li = dev->libinput;
1119 struct libinput_event *event;
1120 struct libinput_event_gesture *gevent;
1121 double dx, dy;
1122 int cardinal = _i; /* ranged test */
1123 double dir_x, dir_y;
1124 int cardinals[NCARDINALS][2] = {
1125 { 0, 30 },
1126 { 30, 30 },
1127 { 30, 0 },
1128 { 30, -30 },
1129 { 0, -30 },
1130 { -30, -30 },
1131 { -30, 0 },
1132 { -30, 30 },
1133 };
1134
1135 if (litest_slot_count(dev) > 2 ||
1136 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_QUADTAP) ||
1137 !libinput_device_has_capability(dev->libinput_device,
1138 LIBINPUT_DEVICE_CAP_GESTURE))
1139 return;
1140
1141 dir_x = cardinals[cardinal][0];
1142 dir_y = cardinals[cardinal][1];
1143
1144 litest_drain_events(li);
1145
1146 litest_touch_down(dev, 0, 40, 40);
1147 litest_touch_down(dev, 1, 50, 40);
1148 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1149 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
1150 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1151
1152 libinput_dispatch(li);
1153 litest_touch_move_two_touches(dev, 40, 40, 50, 40, dir_x, dir_y, 10);
1154 libinput_dispatch(li);
1155
1156 event = libinput_get_event(li);
1157 gevent = litest_is_gesture_event(event,
1158 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
1159 4);
1160 dx = libinput_event_gesture_get_dx(gevent);
1161 dy = libinput_event_gesture_get_dy(gevent);
1162 ck_assert(dx == 0.0);
1163 ck_assert(dy == 0.0);
1164 libinput_event_destroy(event);
1165
1166 while ((event = libinput_get_event(li)) != NULL) {
1167 gevent = litest_is_gesture_event(event,
1168 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
1169 4);
1170
1171 dx = libinput_event_gesture_get_dx(gevent);
1172 dy = libinput_event_gesture_get_dy(gevent);
1173 if (dir_x == 0.0)
1174 ck_assert(dx == 0.0);
1175 else if (dir_x < 0.0)
1176 ck_assert(dx < 0.0);
1177 else if (dir_x > 0.0)
1178 ck_assert(dx > 0.0);
1179
1180 if (dir_y == 0.0)
1181 ck_assert(dy == 0.0);
1182 else if (dir_y < 0.0)
1183 ck_assert(dy < 0.0);
1184 else if (dir_y > 0.0)
1185 ck_assert(dy > 0.0);
1186
1187 dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
1188 dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
1189 if (dir_x == 0.0)
1190 ck_assert(dx == 0.0);
1191 else if (dir_x < 0.0)
1192 ck_assert(dx < 0.0);
1193 else if (dir_x > 0.0)
1194 ck_assert(dx > 0.0);
1195
1196 if (dir_y == 0.0)
1197 ck_assert(dy == 0.0);
1198 else if (dir_y < 0.0)
1199 ck_assert(dy < 0.0);
1200 else if (dir_y > 0.0)
1201 ck_assert(dy > 0.0);
1202
1203 libinput_event_destroy(event);
1204 }
1205
1206 litest_touch_up(dev, 0);
1207 litest_touch_up(dev, 1);
1208 libinput_dispatch(li);
1209 event = libinput_get_event(li);
1210 gevent = litest_is_gesture_event(event,
1211 LIBINPUT_EVENT_GESTURE_SWIPE_END,
1212 4);
1213 ck_assert(!libinput_event_gesture_get_cancelled(gevent));
1214 libinput_event_destroy(event);
1215 }
1216 END_TEST
1217
START_TEST(gestures_pinch)1218 START_TEST(gestures_pinch)
1219 {
1220 int cardinal = _i; /* ranged test */
1221 test_gesture_pinch_2fg(cardinal, HOLD_GESTURE_IGNORE);
1222 }
1223 END_TEST
1224
START_TEST(gestures_pinch_3fg)1225 START_TEST(gestures_pinch_3fg)
1226 {
1227 int cardinal = _i; /* ranged test */
1228 test_gesture_pinch_3fg(cardinal, HOLD_GESTURE_IGNORE);
1229 }
1230 END_TEST
1231
START_TEST(gestures_pinch_4fg)1232 START_TEST(gestures_pinch_4fg)
1233 {
1234 int cardinal = _i; /* ranged test */
1235 test_gesture_pinch_4fg(cardinal, HOLD_GESTURE_IGNORE);
1236 }
1237 END_TEST
1238
START_TEST(gestures_spread)1239 START_TEST(gestures_spread)
1240 {
1241 int cardinal = _i; /* ranged test */
1242 test_gesture_spread(cardinal, HOLD_GESTURE_IGNORE);
1243 }
1244 END_TEST
1245
START_TEST(gestures_time_usec)1246 START_TEST(gestures_time_usec)
1247 {
1248 struct litest_device *dev = litest_current_device();
1249 struct libinput *li = dev->libinput;
1250 struct libinput_event *event;
1251 struct libinput_event_gesture *gevent;
1252 uint64_t time_usec;
1253
1254 if (litest_slot_count(dev) < 3)
1255 return;
1256
1257 litest_drain_events(li);
1258
1259 litest_touch_down(dev, 0, 40, 40);
1260 litest_touch_down(dev, 1, 50, 40);
1261 litest_touch_down(dev, 2, 60, 40);
1262 libinput_dispatch(li);
1263 litest_touch_move_three_touches(dev, 40, 40, 50, 40, 60, 40, 0, 30,
1264 30);
1265
1266 libinput_dispatch(li);
1267 event = libinput_get_event(li);
1268 gevent = litest_is_gesture_event(event,
1269 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
1270 3);
1271 time_usec = libinput_event_gesture_get_time_usec(gevent);
1272 ck_assert_int_eq(libinput_event_gesture_get_time(gevent),
1273 (uint32_t) (time_usec / 1000));
1274 libinput_event_destroy(event);
1275 }
1276 END_TEST
1277
START_TEST(gestures_3fg_buttonarea_scroll)1278 START_TEST(gestures_3fg_buttonarea_scroll)
1279 {
1280 test_gesture_3fg_buttonarea_scroll(HOLD_GESTURE_IGNORE);
1281 }
1282 END_TEST
1283
START_TEST(gestures_3fg_buttonarea_scroll_btntool)1284 START_TEST(gestures_3fg_buttonarea_scroll_btntool)
1285 {
1286 struct litest_device *dev = litest_current_device();
1287 struct libinput *li = dev->libinput;
1288
1289 if (litest_slot_count(dev) > 2)
1290 return;
1291
1292 litest_enable_buttonareas(dev);
1293 litest_enable_2fg_scroll(dev);
1294 litest_drain_events(li);
1295
1296 /* first finger in btnarea */
1297 litest_touch_down(dev, 0, 20, 99);
1298 litest_touch_down(dev, 1, 30, 20);
1299 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
1300 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
1301 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1302 libinput_dispatch(li);
1303 litest_touch_move_to(dev, 1, 30, 20, 30, 70, 10);
1304
1305 litest_touch_up(dev, 1);
1306 libinput_dispatch(li);
1307 litest_assert_scroll(li,
1308 LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
1309 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
1310 4);
1311 }
1312 END_TEST
1313
START_TEST(gestures_swipe_3fg_unaccel)1314 START_TEST(gestures_swipe_3fg_unaccel)
1315 {
1316 struct litest_device *dev = litest_current_device();
1317 struct libinput *li = dev->libinput;
1318 struct libinput_event *event;
1319 double reference_ux = 0, reference_uy = 0;
1320
1321 /**
1322 * This magic number is an artifact of the acceleration code.
1323 * The maximum factor in the touchpad accel profile is 4.8 times the
1324 * speed setting (1.000875 at default setting 0). The factor
1325 * applied to the const acceleration is the 0.9 baseline.
1326 * So our two sets of coordinates are:
1327 * accel = 4.8 * delta * normalize_magic
1328 * unaccel = 0.9 * delta * normalize_magic
1329 *
1330 * Since delta and the normalization magic are the same for both,
1331 * our accelerated deltas can be a maximum of 4.8/0.9 bigger than
1332 * the unaccelerated deltas.
1333 *
1334 * If any of the accel methods numbers change, this will have to
1335 * change here too.
1336 */
1337 const double max_factor = 5.34;
1338
1339 if (litest_slot_count(dev) < 3)
1340 return;
1341
1342 litest_drain_events(li);
1343 litest_touch_down(dev, 0, 40, 20);
1344 litest_touch_down(dev, 1, 50, 20);
1345 litest_touch_down(dev, 2, 60, 20);
1346 libinput_dispatch(li);
1347 litest_touch_move_three_touches(dev,
1348 40, 20,
1349 50, 20,
1350 60, 20,
1351 30, 40,
1352 10);
1353 libinput_dispatch(li);
1354
1355 event = libinput_get_event(li);
1356 litest_is_gesture_event(event,
1357 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
1358 3);
1359 libinput_event_destroy(event);
1360 event = libinput_get_event(li);
1361 do {
1362 struct libinput_event_gesture *gevent;
1363 double dx, dy;
1364 double ux, uy;
1365
1366 gevent = litest_is_gesture_event(event,
1367 LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
1368 3);
1369 dx = libinput_event_gesture_get_dx(gevent);
1370 dy = libinput_event_gesture_get_dy(gevent);
1371 ux = libinput_event_gesture_get_dx_unaccelerated(gevent);
1372 uy = libinput_event_gesture_get_dy_unaccelerated(gevent);
1373
1374 ck_assert_double_ne(ux, 0.0);
1375 ck_assert_double_ne(uy, 0.0);
1376
1377 if (!reference_ux)
1378 reference_ux = ux;
1379 if (!reference_uy)
1380 reference_uy = uy;
1381
1382 /* The unaccelerated delta should be the same for every
1383 * event, but we have rounding errors since we only control
1384 * input data as percentage of the touchpad size.
1385 * so we just eyeball it */
1386 ck_assert_double_gt(ux, reference_ux - 2);
1387 ck_assert_double_lt(ux, reference_ux + 2);
1388 ck_assert_double_gt(uy, reference_uy - 2);
1389 ck_assert_double_lt(uy, reference_uy + 2);
1390
1391 /* All our touchpads are large enough to make this is a fast
1392 * swipe, we don't expect deceleration, unaccel should
1393 * always be less than accel delta */
1394 ck_assert_double_lt(ux, dx);
1395 ck_assert_double_lt(ux, dx);
1396
1397 /* Check our accelerated delta is within the expected
1398 * maximum. */
1399 ck_assert_double_lt(dx, ux * max_factor);
1400 ck_assert_double_lt(dy, uy * max_factor);
1401
1402 libinput_event_destroy(event);
1403 } while ((event = libinput_get_event(li)));
1404
1405 litest_touch_up(dev, 0);
1406 litest_touch_up(dev, 1);
1407 litest_touch_up(dev, 2);
1408 }
1409 END_TEST
1410
START_TEST(gestures_hold_config_default_disabled)1411 START_TEST(gestures_hold_config_default_disabled)
1412 {
1413 struct litest_device *dev = litest_current_device();
1414 struct libinput_device *device = dev->libinput_device;
1415
1416 ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1417 0);
1418 ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
1419 LIBINPUT_CONFIG_HOLD_DISABLED);
1420 ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
1421 LIBINPUT_CONFIG_HOLD_DISABLED);
1422 }
1423 END_TEST
1424
START_TEST(gestures_hold_config_default_enabled)1425 START_TEST(gestures_hold_config_default_enabled)
1426 {
1427 struct litest_device *dev = litest_current_device();
1428 struct libinput_device *device = dev->libinput_device;
1429
1430 ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1431 1);
1432 ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
1433 LIBINPUT_CONFIG_HOLD_ENABLED);
1434 ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
1435 LIBINPUT_CONFIG_HOLD_ENABLED);
1436 }
1437 END_TEST
1438
START_TEST(gestures_hold_config_set_invalid)1439 START_TEST(gestures_hold_config_set_invalid)
1440 {
1441 struct litest_device *dev = litest_current_device();
1442 struct libinput_device *device = dev->libinput_device;
1443
1444 ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, -1),
1445 LIBINPUT_CONFIG_STATUS_INVALID);
1446 ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, 2),
1447 LIBINPUT_CONFIG_STATUS_INVALID);
1448 }
1449 END_TEST
1450
START_TEST(gestures_hold_config_is_available)1451 START_TEST(gestures_hold_config_is_available)
1452 {
1453 struct litest_device *dev = litest_current_device();
1454 struct libinput_device *device = dev->libinput_device;
1455
1456 ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1457 1);
1458 ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
1459 LIBINPUT_CONFIG_HOLD_ENABLED);
1460 ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
1461 LIBINPUT_CONFIG_STATUS_SUCCESS);
1462 ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
1463 LIBINPUT_CONFIG_HOLD_DISABLED);
1464 }
1465 END_TEST
1466
START_TEST(gestures_hold_config_is_not_available)1467 START_TEST(gestures_hold_config_is_not_available)
1468 {
1469 struct litest_device *dev = litest_current_device();
1470 struct libinput_device *device = dev->libinput_device;
1471
1472 ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1473 0);
1474 ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
1475 LIBINPUT_CONFIG_HOLD_DISABLED);
1476 ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_ENABLED),
1477 LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
1478 ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
1479 LIBINPUT_CONFIG_STATUS_SUCCESS);
1480 }
1481 END_TEST
1482
START_TEST(gestures_hold)1483 START_TEST(gestures_hold)
1484 {
1485 struct litest_device *dev = litest_current_device();
1486 struct libinput *li = dev->libinput;
1487 int nfingers = _i; /* ranged test */
1488
1489 litest_disable_tap(dev->libinput_device);
1490 litest_drain_events(li);
1491
1492 test_gesture_hold(nfingers);
1493 }
1494 END_TEST
1495
START_TEST(gestures_hold_tap_enabled)1496 START_TEST(gestures_hold_tap_enabled)
1497 {
1498 struct litest_device *dev = litest_current_device();
1499 struct libinput *li = dev->libinput;
1500 int nfingers = _i; /* ranged test */
1501
1502 litest_enable_tap(dev->libinput_device);
1503 litest_drain_events(li);
1504
1505 test_gesture_hold(nfingers);
1506 }
1507 END_TEST
1508
START_TEST(gestures_hold_cancel)1509 START_TEST(gestures_hold_cancel)
1510 {
1511 struct litest_device *dev = litest_current_device();
1512 struct libinput *li = dev->libinput;
1513 int nfingers = _i; /* ranged test */
1514
1515 litest_disable_tap(dev->libinput_device);
1516 litest_drain_events(li);
1517
1518 test_gesture_hold_cancel(nfingers);
1519 }
1520 END_TEST
1521
START_TEST(gestures_hold_cancel_tap_enabled)1522 START_TEST(gestures_hold_cancel_tap_enabled)
1523 {
1524 struct litest_device *dev = litest_current_device();
1525 struct libinput *li = dev->libinput;
1526 int nfingers = _i; /* ranged test */
1527
1528 litest_enable_tap(dev->libinput_device);
1529 litest_drain_events(li);
1530
1531 test_gesture_hold_cancel(nfingers);
1532 }
1533 END_TEST
1534
START_TEST(gestures_hold_then_swipe_3fg)1535 START_TEST(gestures_hold_then_swipe_3fg)
1536 {
1537 int cardinal = _i; /* ranged test */
1538 test_gesture_swipe_3fg(cardinal, HOLD_GESTURE_REQUIRE);
1539 }
1540 END_TEST
1541
START_TEST(gestures_hold_then_swipe_4fg)1542 START_TEST(gestures_hold_then_swipe_4fg)
1543 {
1544 int cardinal = _i; /* ranged test */
1545 test_gesture_swipe_4fg(cardinal, HOLD_GESTURE_REQUIRE);
1546 }
1547 END_TEST
1548
START_TEST(gestures_hold_then_pinch_2fg)1549 START_TEST(gestures_hold_then_pinch_2fg)
1550 {
1551 int cardinal = _i; /* ranged test */
1552 test_gesture_pinch_2fg(cardinal, HOLD_GESTURE_REQUIRE);
1553 }
1554 END_TEST
1555
START_TEST(gestures_hold_then_pinch_3fg)1556 START_TEST(gestures_hold_then_pinch_3fg)
1557 {
1558 int cardinal = _i; /* ranged test */
1559 test_gesture_pinch_3fg(cardinal, HOLD_GESTURE_REQUIRE);
1560 }
1561 END_TEST
1562
START_TEST(gestures_hold_then_pinch_4fg)1563 START_TEST(gestures_hold_then_pinch_4fg)
1564 {
1565 int cardinal = _i; /* ranged test */
1566 test_gesture_pinch_4fg(cardinal, HOLD_GESTURE_REQUIRE);
1567 }
1568 END_TEST
1569
START_TEST(gestures_hold_then_spread)1570 START_TEST(gestures_hold_then_spread)
1571 {
1572 int cardinal = _i; /* ranged test */
1573 test_gesture_spread(cardinal, HOLD_GESTURE_REQUIRE);
1574 }
1575 END_TEST
1576
START_TEST(gestures_hold_then_3fg_buttonarea_scroll)1577 START_TEST(gestures_hold_then_3fg_buttonarea_scroll)
1578 {
1579 test_gesture_3fg_buttonarea_scroll(HOLD_GESTURE_REQUIRE);
1580 }
1581 END_TEST
1582
START_TEST(gestures_hold_once_on_double_tap)1583 START_TEST(gestures_hold_once_on_double_tap)
1584 {
1585 struct litest_device *dev = litest_current_device();
1586 struct libinput *li = dev->libinput;
1587
1588 if (!libinput_device_has_capability(dev->libinput_device,
1589 LIBINPUT_DEVICE_CAP_GESTURE))
1590 return;
1591
1592 litest_enable_tap(dev->libinput_device);
1593 litest_drain_events(li);
1594
1595 /* First tap, a hold gesture must be generated */
1596 litest_touch_down(dev, 0, 50, 50);
1597 libinput_dispatch(li);
1598 litest_timeout_gesture_quick_hold();
1599 litest_touch_up(dev, 0);
1600 libinput_dispatch(li);
1601
1602 litest_assert_gesture_event(li,
1603 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
1604 1);
1605 litest_assert_gesture_event(li,
1606 LIBINPUT_EVENT_GESTURE_HOLD_END,
1607 1);
1608 litest_assert_button_event(li, BTN_LEFT,
1609 LIBINPUT_BUTTON_STATE_PRESSED);
1610 litest_assert_button_event(li, BTN_LEFT,
1611 LIBINPUT_BUTTON_STATE_RELEASED);
1612 litest_assert_empty_queue(li);
1613
1614 /* Double tap, don't generate an extra hold gesture */
1615 litest_touch_down(dev, 0, 50, 50);
1616 litest_touch_up(dev, 0);
1617 libinput_dispatch(li);
1618 litest_timeout_gesture_quick_hold();
1619
1620 litest_assert_button_event(li, BTN_LEFT,
1621 LIBINPUT_BUTTON_STATE_PRESSED);
1622 litest_assert_button_event(li, BTN_LEFT,
1623 LIBINPUT_BUTTON_STATE_RELEASED);
1624
1625 litest_assert_empty_queue(li);
1626 }
1627 END_TEST
1628
START_TEST(gestures_hold_once_tap_n_drag)1629 START_TEST(gestures_hold_once_tap_n_drag)
1630 {
1631 struct litest_device *dev = litest_current_device();
1632 struct libinput *li = dev->libinput;
1633 int nfingers = _i; /* ranged test */
1634 unsigned int button = 0;
1635
1636 if (nfingers > litest_slot_count(dev))
1637 return;
1638
1639 if (!libinput_device_has_capability(dev->libinput_device,
1640 LIBINPUT_DEVICE_CAP_GESTURE))
1641 return;
1642
1643 litest_enable_tap(dev->libinput_device);
1644 litest_disable_drag_lock(dev->libinput_device);
1645 litest_drain_events(li);
1646
1647 switch (nfingers) {
1648 case 1:
1649 button = BTN_LEFT;
1650 break;
1651 case 2:
1652 button = BTN_RIGHT;
1653 break;
1654 case 3:
1655 button = BTN_MIDDLE;
1656 break;
1657 default:
1658 abort();
1659 }
1660
1661 switch (nfingers) {
1662 case 3:
1663 litest_touch_down(dev, 2, 60, 30);
1664 _fallthrough_;
1665 case 2:
1666 litest_touch_down(dev, 1, 50, 30);
1667 _fallthrough_;
1668 case 1:
1669 litest_touch_down(dev, 0, 40, 30);
1670 break;
1671 }
1672 libinput_dispatch(li);
1673 litest_timeout_gesture_quick_hold();
1674
1675 switch (nfingers) {
1676 case 3:
1677 litest_touch_up(dev, 2);
1678 _fallthrough_;
1679 case 2:
1680 litest_touch_up(dev, 1);
1681 _fallthrough_;
1682 case 1:
1683 litest_touch_up(dev, 0);
1684 break;
1685 }
1686 libinput_dispatch(li);
1687
1688 /* "Quick" hold gestures are only generated when using 1 or 2 fingers */
1689 if (nfingers == 1 || nfingers == 2) {
1690 litest_assert_gesture_event(li,
1691 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
1692 nfingers);
1693 litest_assert_gesture_event(li,
1694 LIBINPUT_EVENT_GESTURE_HOLD_END,
1695 nfingers);
1696 }
1697
1698 /* Tap and drag, don't generate an extra hold gesture */
1699 litest_touch_down(dev, 0, 50, 50);
1700 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
1701 libinput_dispatch(li);
1702
1703 litest_assert_button_event(li, button,
1704 LIBINPUT_BUTTON_STATE_PRESSED);
1705 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1706
1707 litest_touch_up(dev, 0);
1708 libinput_dispatch(li);
1709
1710 litest_assert_button_event(li, button,
1711 LIBINPUT_BUTTON_STATE_RELEASED);
1712 litest_assert_empty_queue(li);
1713 }
1714 END_TEST
1715
START_TEST(gestures_hold_and_motion_before_timeout)1716 START_TEST(gestures_hold_and_motion_before_timeout)
1717 {
1718 struct litest_device *dev = litest_current_device();
1719 struct libinput *li = dev->libinput;
1720
1721 if (!libinput_device_has_capability(dev->libinput_device,
1722 LIBINPUT_DEVICE_CAP_GESTURE))
1723 return;
1724
1725 litest_drain_events(li);
1726
1727 litest_touch_down(dev, 0, 50, 50);
1728 libinput_dispatch(li);
1729
1730 litest_touch_move_to(dev, 0, 50, 50, 51, 51, 1);
1731 litest_touch_move_to(dev, 0, 51, 51, 50, 50, 1);
1732 libinput_dispatch(li);
1733
1734 litest_timeout_gesture_quick_hold();
1735
1736 litest_drain_events_of_type(li, LIBINPUT_EVENT_POINTER_MOTION, -1);
1737
1738 litest_assert_gesture_event(li,
1739 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
1740 1);
1741
1742 litest_touch_up(dev, 0);
1743 libinput_dispatch(li);
1744
1745 litest_assert_gesture_event(li,
1746 LIBINPUT_EVENT_GESTURE_HOLD_END,
1747 1);
1748 litest_assert_empty_queue(li);
1749 }
1750 END_TEST
1751
START_TEST(gestures_hold_and_motion_after_timeout)1752 START_TEST(gestures_hold_and_motion_after_timeout)
1753 {
1754 struct litest_device *dev = litest_current_device();
1755 struct libinput *li = dev->libinput;
1756
1757 if (!libinput_device_has_capability(dev->libinput_device,
1758 LIBINPUT_DEVICE_CAP_GESTURE))
1759 return;
1760
1761 litest_drain_events(li);
1762
1763 litest_touch_down(dev, 0, 50, 50);
1764 libinput_dispatch(li);
1765 litest_timeout_gesture_quick_hold();
1766
1767 litest_assert_gesture_event(li,
1768 LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
1769 1);
1770
1771 litest_touch_move_to(dev, 0, 50, 50, 51, 51, 1);
1772 litest_touch_move_to(dev, 0, 51, 51, 50, 50, 1);
1773 libinput_dispatch(li);
1774 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1775
1776 litest_touch_up(dev, 0);
1777 libinput_dispatch(li);
1778
1779 litest_assert_gesture_event(li,
1780 LIBINPUT_EVENT_GESTURE_HOLD_END,
1781 1);
1782 litest_assert_empty_queue(li);
1783 }
1784 END_TEST
1785
TEST_COLLECTION(gestures)1786 TEST_COLLECTION(gestures)
1787 {
1788 struct range cardinals = { N, N + NCARDINALS };
1789 struct range range_hold = { 1, 5 };
1790 struct range range_multifinger_tap = {1, 4};
1791
1792 litest_add(gestures_cap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1793 litest_add(gestures_nocap, LITEST_ANY, LITEST_TOUCHPAD);
1794
1795 litest_add_ranged(gestures_swipe_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1796 litest_add_ranged(gestures_swipe_3fg_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1797 litest_add(gestures_swipe_3fg_btntool_pinch_like, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1798 litest_add_ranged(gestures_swipe_4fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1799 litest_add_ranged(gestures_swipe_4fg_btntool, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1800 litest_add_ranged(gestures_pinch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1801 litest_add_ranged(gestures_pinch_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1802 litest_add_ranged(gestures_pinch_4fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1803 litest_add_ranged(gestures_spread, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1804
1805 litest_add(gestures_3fg_buttonarea_scroll, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
1806 litest_add(gestures_3fg_buttonarea_scroll_btntool, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
1807
1808 litest_add(gestures_time_usec, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1809
1810 litest_add(gestures_hold_config_default_disabled, LITEST_TOUCHPAD|LITEST_SEMI_MT, LITEST_ANY);
1811 litest_add(gestures_hold_config_default_enabled, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
1812 litest_add(gestures_hold_config_set_invalid, LITEST_TOUCHPAD, LITEST_ANY);
1813 litest_add(gestures_hold_config_is_available, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_SEMI_MT);
1814 litest_add(gestures_hold_config_is_not_available, LITEST_TOUCHPAD|LITEST_SEMI_MT, LITEST_ANY);
1815
1816 litest_add_ranged(gestures_hold, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_hold);
1817 litest_add_ranged(gestures_hold_tap_enabled, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_hold);
1818 litest_add_ranged(gestures_hold_cancel, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_hold);
1819 litest_add_ranged(gestures_hold_cancel_tap_enabled, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &range_hold);
1820 litest_add_ranged(gestures_hold_then_swipe_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1821 litest_add_ranged(gestures_hold_then_swipe_4fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1822 litest_add_ranged(gestures_hold_then_pinch_2fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1823 litest_add_ranged(gestures_hold_then_pinch_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1824 litest_add_ranged(gestures_hold_then_pinch_4fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1825 litest_add_ranged(gestures_hold_then_spread, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
1826 litest_add(gestures_hold_then_3fg_buttonarea_scroll, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
1827
1828 litest_add(gestures_hold_once_on_double_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1829 litest_add_ranged(gestures_hold_once_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY, &range_multifinger_tap);
1830
1831 litest_add(gestures_hold_and_motion_before_timeout, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1832 litest_add(gestures_hold_and_motion_after_timeout, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1833
1834 /* Timing-sensitive test, valgrind is too slow */
1835 if (!RUNNING_ON_VALGRIND)
1836 litest_add(gestures_swipe_3fg_unaccel, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1837 }
1838