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