test/touchpad.c

   1 /*
   2  * Copyright © 2014 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include <config.h>
  24
  25 #include <check.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <libinput.h>
  29 #include <unistd.h>
  30
  31 #include "libinput-util.h"
  32 #include "litest.h"
  33
  34 START_TEST(touchpad_1fg_motion)
  35 {
  36         struct litest_device *dev = litest_current_device();
  37         struct libinput *li = dev->libinput;
  38         struct libinput_event *event;
  39         struct libinput_event_pointer *ptrev;
  40
  41         litest_drain_events(li);
  42
  43         litest_touch_down(dev, 0, 50, 50);
  44         litest_touch_move_to(dev, 0, 50, 50, 80, 50, 5);
  45         litest_touch_up(dev, 0);
  46
  47         libinput_dispatch(li);
  48
  49         event = libinput_get_event(li);
  50         ck_assert(event != NULL);
  51
  52         while (event) {
  53                 ck_assert_int_eq(libinput_event_get_type(event),
  54                                  LIBINPUT_EVENT_POINTER_MOTION);
  55
  56                 ptrev = libinput_event_get_pointer_event(event);
  57                 ck_assert_int_ge(libinput_event_pointer_get_dx(ptrev), 0);
  58                 ck_assert_int_eq(libinput_event_pointer_get_dy(ptrev), 0);
  59                 libinput_event_destroy(event);
  60                 event = libinput_get_event(li);
  61         }
  62 }
  63 END_TEST
  64
  65 START_TEST(touchpad_2fg_no_motion)
  66 {
  67         struct litest_device *dev = litest_current_device();
  68         struct libinput *li = dev->libinput;
  69         struct libinput_event *event;
  70
  71         litest_drain_events(li);
  72
  73         litest_touch_down(dev, 0, 20, 20);
  74         litest_touch_down(dev, 1, 70, 20);
  75         litest_touch_move_to(dev, 0, 20, 20, 80, 80, 5);
  76         litest_touch_move_to(dev, 1, 70, 20, 80, 50, 5);
  77         litest_touch_up(dev, 1);
  78         litest_touch_up(dev, 0);
  79
  80         libinput_dispatch(li);
  81
  82         event = libinput_get_event(li);
  83         while (event) {
  84                 ck_assert_int_ne(libinput_event_get_type(event),
  85                                  LIBINPUT_EVENT_POINTER_MOTION);
  86                 libinput_event_destroy(event);
  87                 event = libinput_get_event(li);
  88         }
  89 }
  90 END_TEST
  91
  92 static void
  93 assert_button_event(struct libinput *li, int button,
  94                     enum libinput_button_state state)
  95 {
  96         struct libinput_event *event;
  97         struct libinput_event_pointer *ptrev;
  98
  99         libinput_dispatch(li);
 100         event = libinput_get_event(li);
 101
 102         ck_assert(event != NULL);
 103         ck_assert_int_eq(libinput_event_get_type(event),
 104                          LIBINPUT_EVENT_POINTER_BUTTON);
 105         ptrev = libinput_event_get_pointer_event(event);
 106         ck_assert_int_eq(libinput_event_pointer_get_button(ptrev),
 107                          button);
 108         ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrev),
 109                          state);
 110         libinput_event_destroy(event);
 111 }
 112
 113 START_TEST(touchpad_1fg_tap)
 114 {
 115         struct litest_device *dev = litest_current_device();
 116         struct libinput *li = dev->libinput;
 117         struct libinput_event *event;
 118
 119         litest_drain_events(li);
 120
 121         litest_touch_down(dev, 0, 50, 50);
 122         litest_touch_up(dev, 0);
 123
 124         libinput_dispatch(li);
 125
 126         assert_button_event(li, BTN_LEFT,
 127                             LIBINPUT_BUTTON_STATE_PRESSED);
 128         usleep(300000); /* tap-n-drag timeout */
 129         assert_button_event(li, BTN_LEFT,
 130                             LIBINPUT_BUTTON_STATE_RELEASED);
 131
 132         libinput_dispatch(li);
 133         event = libinput_get_event(li);
 134         ck_assert(event == NULL);
 135 }
 136 END_TEST
 137
 138 START_TEST(touchpad_1fg_tap_n_drag)
 139 {
 140         struct litest_device *dev = litest_current_device();
 141         struct libinput *li = dev->libinput;
 142         struct libinput_event *event;
 143
 144         litest_drain_events(li);
 145
 146         litest_touch_down(dev, 0, 50, 50);
 147         litest_touch_up(dev, 0);
 148         litest_touch_down(dev, 0, 50, 50);
 149         litest_touch_move_to(dev, 0, 50, 50, 80, 80, 5);
 150         litest_touch_up(dev, 0);
 151
 152         libinput_dispatch(li);
 153
 154         assert_button_event(li, BTN_LEFT,
 155                             LIBINPUT_BUTTON_STATE_PRESSED);
 156
 157         libinput_dispatch(li);
 158         while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION) {
 159                 event = libinput_get_event(li);
 160                 libinput_event_destroy(event);
 161                 libinput_dispatch(li);
 162         }
 163
 164         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 165
 166         /* lift finger, set down again, should continue dragging */
 167         litest_touch_down(dev, 0, 50, 50);
 168         litest_touch_move_to(dev, 0, 50, 50, 80, 80, 5);
 169         litest_touch_up(dev, 0);
 170
 171         libinput_dispatch(li);
 172         while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION) {
 173                 event = libinput_get_event(li);
 174                 libinput_event_destroy(event);
 175                 libinput_dispatch(li);
 176         }
 177
 178         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 179
 180         usleep(300000); /* tap-n-drag timeout */
 181
 182         assert_button_event(li, BTN_LEFT,
 183                             LIBINPUT_BUTTON_STATE_RELEASED);
 184
 185         litest_assert_empty_queue(li);
 186 }
 187 END_TEST
 188
 189 START_TEST(touchpad_2fg_tap)
 190 {
 191         struct litest_device *dev = litest_current_device();
 192         struct libinput *li = dev->libinput;
 193
 194         litest_drain_events(dev->libinput);
 195
 196         litest_touch_down(dev, 0, 50, 50);
 197         litest_touch_down(dev, 1, 70, 70);
 198         litest_touch_up(dev, 0);
 199         litest_touch_up(dev, 1);
 200
 201         libinput_dispatch(li);
 202
 203         assert_button_event(li, BTN_RIGHT,
 204                             LIBINPUT_BUTTON_STATE_PRESSED);
 205         usleep(300000); /* tap-n-drag timeout */
 206         assert_button_event(li, BTN_RIGHT,
 207                             LIBINPUT_BUTTON_STATE_RELEASED);
 208
 209         litest_assert_empty_queue(li);
 210 }
 211 END_TEST
 212
 213 START_TEST(touchpad_1fg_tap_click)
 214 {
 215         struct litest_device *dev = litest_current_device();
 216         struct libinput *li = dev->libinput;
 217
 218         litest_drain_events(dev->libinput);
 219
 220         /* finger down, button click, finger up
 221            -> only one button left event pair */
 222         litest_touch_down(dev, 0, 50, 50);
 223         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 224         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 225         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 226         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 227         litest_touch_up(dev, 0);
 228
 229         libinput_dispatch(li);
 230
 231         assert_button_event(li, BTN_LEFT,
 232                             LIBINPUT_BUTTON_STATE_PRESSED);
 233         assert_button_event(li, BTN_LEFT,
 234                             LIBINPUT_BUTTON_STATE_RELEASED);
 235
 236         litest_assert_empty_queue(li);
 237 }
 238 END_TEST
 239
 240 START_TEST(touchpad_2fg_tap_click)
 241 {
 242         struct litest_device *dev = litest_current_device();
 243         struct libinput *li = dev->libinput;
 244
 245         litest_drain_events(dev->libinput);
 246
 247         /* two fingers down, button click, fingers up
 248            -> only one button left event pair */
 249         litest_touch_down(dev, 0, 50, 50);
 250         litest_touch_down(dev, 1, 70, 50);
 251         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 252         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 253         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 254         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 255         litest_touch_up(dev, 1);
 256         litest_touch_up(dev, 0);
 257
 258         libinput_dispatch(li);
 259
 260         assert_button_event(li, BTN_LEFT,
 261                             LIBINPUT_BUTTON_STATE_PRESSED);
 262         assert_button_event(li, BTN_LEFT,
 263                             LIBINPUT_BUTTON_STATE_RELEASED);
 264
 265         litest_assert_empty_queue(li);
 266 }
 267 END_TEST
 268
 269 START_TEST(touchpad_2fg_tap_click_apple)
 270 {
 271         struct litest_device *dev = litest_current_device();
 272         struct libinput *li = dev->libinput;
 273
 274         litest_drain_events(dev->libinput);
 275
 276         /* two fingers down, button click, fingers up
 277            -> only one button right event pair
 278            (apple have clickfinger enabled by default) */
 279         litest_touch_down(dev, 0, 50, 50);
 280         litest_touch_down(dev, 1, 70, 50);
 281         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 282         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 283         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 284         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 285         litest_touch_up(dev, 1);
 286         litest_touch_up(dev, 0);
 287
 288         libinput_dispatch(li);
 289
 290         assert_button_event(li, BTN_RIGHT,
 291                             LIBINPUT_BUTTON_STATE_PRESSED);
 292         assert_button_event(li, BTN_RIGHT,
 293                             LIBINPUT_BUTTON_STATE_RELEASED);
 294
 295         litest_assert_empty_queue(li);
 296 }
 297 END_TEST
 298
 299 START_TEST(touchpad_1fg_double_tap_click)
 300 {
 301         struct litest_device *dev = litest_current_device();
 302         struct libinput *li = dev->libinput;
 303
 304         litest_drain_events(dev->libinput);
 305
 306         /* one finger down, up, down, button click, finger up
 307            -> two button left event pairs */
 308         litest_touch_down(dev, 0, 50, 50);
 309         litest_touch_up(dev, 0);
 310         litest_touch_down(dev, 0, 50, 50);
 311         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 312         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 313         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 314         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 315         litest_touch_up(dev, 0);
 316
 317         libinput_dispatch(li);
 318
 319         assert_button_event(li, BTN_LEFT,
 320                             LIBINPUT_BUTTON_STATE_PRESSED);
 321         assert_button_event(li, BTN_LEFT,
 322                             LIBINPUT_BUTTON_STATE_RELEASED);
 323         assert_button_event(li, BTN_LEFT,
 324                             LIBINPUT_BUTTON_STATE_PRESSED);
 325         assert_button_event(li, BTN_LEFT,
 326                             LIBINPUT_BUTTON_STATE_RELEASED);
 327
 328         litest_assert_empty_queue(li);
 329 }
 330 END_TEST
 331
 332 START_TEST(touchpad_1fg_tap_n_drag_click)
 333 {
 334         struct litest_device *dev = litest_current_device();
 335         struct libinput *li = dev->libinput;
 336         struct libinput_event *event;
 337
 338         litest_drain_events(dev->libinput);
 339
 340         /* one finger down, up, down, move, button click, finger up
 341            -> two button left event pairs, motion allowed */
 342         litest_touch_down(dev, 0, 50, 50);
 343         litest_touch_up(dev, 0);
 344         litest_touch_down(dev, 0, 50, 50);
 345         litest_touch_move_to(dev, 0, 50, 50, 80, 50, 10);
 346
 347         assert_button_event(li, BTN_LEFT,
 348                             LIBINPUT_BUTTON_STATE_PRESSED);
 349
 350         libinput_dispatch(li);
 351
 352         ck_assert_int_eq(libinput_next_event_type(li),
 353                          LIBINPUT_EVENT_POINTER_MOTION);
 354         while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION) {
 355                 event = libinput_get_event(li);
 356                 libinput_event_destroy(event);
 357                 libinput_dispatch(li);
 358         }
 359
 360         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 361         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 362
 363         assert_button_event(li, BTN_LEFT,
 364                             LIBINPUT_BUTTON_STATE_RELEASED);
 365         assert_button_event(li, BTN_LEFT,
 366                             LIBINPUT_BUTTON_STATE_PRESSED);
 367
 368         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 369         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 370         litest_touch_up(dev, 0);
 371
 372         libinput_dispatch(li);
 373
 374         assert_button_event(li, BTN_LEFT,
 375                             LIBINPUT_BUTTON_STATE_RELEASED);
 376
 377         litest_assert_empty_queue(li);
 378 }
 379 END_TEST
 380
 381 START_TEST(touchpad_1fg_clickfinger)
 382 {
 383         struct litest_device *dev = litest_create_device(LITEST_BCM5974);
 384         struct libinput *li = dev->libinput;
 385
 386         litest_drain_events(li);
 387
 388         litest_touch_down(dev, 0, 50, 50);
 389         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 390         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 391         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 392         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 393         litest_touch_up(dev, 0);
 394
 395         libinput_dispatch(li);
 396
 397         assert_button_event(li, BTN_LEFT,
 398                             LIBINPUT_BUTTON_STATE_PRESSED);
 399         assert_button_event(li, BTN_LEFT,
 400                             LIBINPUT_BUTTON_STATE_RELEASED);
 401
 402         litest_delete_device(dev);
 403 }
 404 END_TEST
 405
 406 START_TEST(touchpad_2fg_clickfinger)
 407 {
 408         struct litest_device *dev = litest_create_device(LITEST_BCM5974);
 409         struct libinput *li = dev->libinput;
 410
 411         litest_drain_events(li);
 412
 413         litest_touch_down(dev, 0, 50, 50);
 414         litest_touch_down(dev, 1, 70, 70);
 415         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 416         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 417         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 418         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 419         litest_touch_up(dev, 0);
 420         litest_touch_up(dev, 1);
 421
 422         libinput_dispatch(li);
 423
 424         assert_button_event(li, BTN_RIGHT,
 425                             LIBINPUT_BUTTON_STATE_PRESSED);
 426         assert_button_event(li, BTN_RIGHT,
 427                             LIBINPUT_BUTTON_STATE_RELEASED);
 428
 429         litest_delete_device(dev);
 430 }
 431 END_TEST
 432
 433 START_TEST(touchpad_btn_left)
 434 {
 435         struct litest_device *dev = litest_current_device();
 436         struct libinput *li = dev->libinput;
 437
 438         litest_drain_events(li);
 439
 440         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 441         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 442         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 443         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 444
 445         libinput_dispatch(li);
 446
 447         assert_button_event(li, BTN_LEFT,
 448                             LIBINPUT_BUTTON_STATE_PRESSED);
 449         assert_button_event(li, BTN_LEFT,
 450                             LIBINPUT_BUTTON_STATE_RELEASED);
 451 }
 452 END_TEST
 453
 454 START_TEST(clickpad_btn_left)
 455 {
 456         struct litest_device *dev = litest_current_device();
 457         struct libinput *li = dev->libinput;
 458
 459         litest_drain_events(li);
 460
 461         /* A clickpad always needs a finger down to tell where the
 462            click happens */
 463         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 464         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 465         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 466         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 467
 468         libinput_dispatch(li);
 469         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 470 }
 471 END_TEST
 472
 473 START_TEST(clickpad_click_n_drag)
 474 {
 475         struct litest_device *dev = litest_current_device();
 476         struct libinput *li = dev->libinput;
 477         struct libinput_event *event;
 478
 479         litest_drain_events(li);
 480
 481         litest_touch_down(dev, 0, 50, 50);
 482         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 483         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 484
 485         libinput_dispatch(li);
 486         assert_button_event(li, BTN_LEFT,
 487                             LIBINPUT_BUTTON_STATE_PRESSED);
 488
 489         libinput_dispatch(li);
 490         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 491
 492         /* now put a second finger down */
 493         litest_touch_down(dev, 1, 70, 70);
 494         litest_touch_move_to(dev, 1, 70, 70, 80, 50, 5);
 495         litest_touch_up(dev, 1);
 496
 497         libinput_dispatch(li);
 498         ck_assert_int_eq(libinput_next_event_type(li),
 499                          LIBINPUT_EVENT_POINTER_MOTION);
 500         do {
 501                 event = libinput_get_event(li);
 502                 libinput_event_destroy(event);
 503                 libinput_dispatch(li);
 504         } while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION);
 505
 506         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 507         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 508         litest_touch_up(dev, 0);
 509
 510         assert_button_event(li, BTN_LEFT,
 511                             LIBINPUT_BUTTON_STATE_RELEASED);
 512 }
 513 END_TEST
 514
 515 START_TEST(clickpad_softbutton_left)
 516 {
 517         struct litest_device *dev = litest_current_device();
 518         struct libinput *li = dev->libinput;
 519
 520         litest_drain_events(li);
 521
 522         litest_touch_down(dev, 0, 10, 90);
 523         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 524         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 525
 526         assert_button_event(li,
 527                             BTN_LEFT,
 528                             LIBINPUT_BUTTON_STATE_PRESSED);
 529
 530         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 531         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 532         litest_touch_up(dev, 0);
 533
 534         assert_button_event(li,
 535                             BTN_LEFT,
 536                             LIBINPUT_BUTTON_STATE_RELEASED);
 537
 538         libinput_dispatch(li);
 539
 540         litest_assert_empty_queue(li);
 541 }
 542 END_TEST
 543
 544 START_TEST(clickpad_softbutton_right)
 545 {
 546         struct litest_device *dev = litest_current_device();
 547         struct libinput *li = dev->libinput;
 548
 549         litest_drain_events(li);
 550
 551         litest_touch_down(dev, 0, 90, 90);
 552         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 553         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 554
 555         assert_button_event(li,
 556                             BTN_RIGHT,
 557                             LIBINPUT_BUTTON_STATE_PRESSED);
 558
 559         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 560         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 561         litest_touch_up(dev, 0);
 562
 563         assert_button_event(li,
 564                             BTN_RIGHT,
 565                             LIBINPUT_BUTTON_STATE_RELEASED);
 566
 567         libinput_dispatch(li);
 568
 569         litest_assert_empty_queue(li);
 570 }
 571 END_TEST
 572
 573 START_TEST(clickpad_softbutton_left_tap_n_drag)
 574 {
 575         struct litest_device *dev = litest_current_device();
 576         struct libinput *li = dev->libinput;
 577
 578         litest_drain_events(li);
 579
 580         /* Tap in left button area, then finger down, button click
 581                 -> expect left button press/release and left button press
 582            Release button, finger up
 583                 -> expect right button release
 584          */
 585         litest_touch_down(dev, 0, 20, 90);
 586         litest_touch_up(dev, 0);
 587         litest_touch_down(dev, 0, 20, 90);
 588         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 589         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 590
 591         assert_button_event(li,
 592                             BTN_LEFT,
 593                             LIBINPUT_BUTTON_STATE_PRESSED);
 594         assert_button_event(li,
 595                             BTN_LEFT,
 596                             LIBINPUT_BUTTON_STATE_RELEASED);
 597         assert_button_event(li,
 598                             BTN_LEFT,
 599                             LIBINPUT_BUTTON_STATE_PRESSED);
 600         litest_assert_empty_queue(li);
 601
 602         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 603         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 604         litest_touch_up(dev, 0);
 605
 606         assert_button_event(li,
 607                             BTN_LEFT,
 608                             LIBINPUT_BUTTON_STATE_RELEASED);
 609         litest_assert_empty_queue(li);
 610 }
 611 END_TEST
 612
 613 START_TEST(clickpad_softbutton_right_tap_n_drag)
 614 {
 615         struct litest_device *dev = litest_current_device();
 616         struct libinput *li = dev->libinput;
 617
 618         litest_drain_events(li);
 619
 620         /* Tap in right button area, then finger down, button click
 621                 -> expect left button press/release and right button press
 622            Release button, finger up
 623                 -> expect right button release
 624          */
 625         litest_touch_down(dev, 0, 90, 90);
 626         litest_touch_up(dev, 0);
 627         litest_touch_down(dev, 0, 90, 90);
 628         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 629         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 630
 631         assert_button_event(li,
 632                             BTN_LEFT,
 633                             LIBINPUT_BUTTON_STATE_PRESSED);
 634         assert_button_event(li,
 635                             BTN_LEFT,
 636                             LIBINPUT_BUTTON_STATE_RELEASED);
 637         assert_button_event(li,
 638                             BTN_RIGHT,
 639                             LIBINPUT_BUTTON_STATE_PRESSED);
 640         litest_assert_empty_queue(li);
 641
 642         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 643         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 644         litest_touch_up(dev, 0);
 645
 646         assert_button_event(li,
 647                             BTN_RIGHT,
 648                             LIBINPUT_BUTTON_STATE_RELEASED);
 649         litest_assert_empty_queue(li);
 650 }
 651 END_TEST
 652
 653 START_TEST(clickpad_softbutton_left_1st_fg_move)
 654 {
 655         struct litest_device *dev = litest_current_device();
 656         struct libinput *li = dev->libinput;
 657         struct libinput_event *event;
 658         double x = 0, y = 0;
 659         int nevents = 0;
 660
 661         litest_drain_events(li);
 662
 663         /* One finger down in the left button area, button press
 664                 -> expect a button event
 665            Move finger up out of the area, wait for timeout
 666            Move finger around diagonally down left
 667                 -> expect motion events down left
 668            Release finger
 669                 -> expect a button event */
 670
 671         /* finger down, press in left button */
 672         litest_touch_down(dev, 0, 20, 90);
 673         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 674         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 675
 676         assert_button_event(li,
 677                             BTN_LEFT,
 678                             LIBINPUT_BUTTON_STATE_PRESSED);
 679         litest_assert_empty_queue(li);
 680
 681         /* move out of the area, then wait for softbutton timer */
 682         litest_touch_move_to(dev, 0, 20, 90, 90, 20, 10);
 683         libinput_dispatch(li);
 684         usleep(400000);
 685         libinput_dispatch(li);
 686         litest_drain_events(li);
 687
 688         /* move down left, expect motion */
 689         litest_touch_move_to(dev, 0, 90, 20, 20, 90, 10);
 690
 691         libinput_dispatch(li);
 692         event = libinput_get_event(li);
 693         ck_assert(event != NULL);
 694         while (event) {
 695                 struct libinput_event_pointer *p;
 696
 697                 ck_assert_int_eq(libinput_event_get_type(event),
 698                                  LIBINPUT_EVENT_POINTER_MOTION);
 699                 p = libinput_event_get_pointer_event(event);
 700
 701                 /* we moved up/right, now down/left so the pointer accel
 702                    code may lag behind with the dx/dy vectors. Hence, add up
 703                    the x/y movements and expect that on average we moved
 704                    left and down */
 705                 x += libinput_event_pointer_get_dx(p);
 706                 y += libinput_event_pointer_get_dy(p);
 707                 nevents++;
 708
 709                 libinput_event_destroy(event);
 710                 libinput_dispatch(li);
 711                 event = libinput_get_event(li);
 712         }
 713
 714         ck_assert(x/nevents < 0);
 715         ck_assert(y/nevents > 0);
 716
 717         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 718         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 719         litest_touch_up(dev, 0);
 720
 721         assert_button_event(li,
 722                             BTN_LEFT,
 723                             LIBINPUT_BUTTON_STATE_RELEASED);
 724
 725         litest_assert_empty_queue(li);
 726 }
 727 END_TEST
 728
 729 START_TEST(clickpad_softbutton_left_2nd_fg_move)
 730 {
 731         struct litest_device *dev = litest_current_device();
 732         struct libinput *li = dev->libinput;
 733         struct libinput_event *event;
 734
 735         litest_drain_events(li);
 736
 737         /* One finger down in the left button area, button press
 738                 -> expect a button event
 739            Put a second finger down in the area, move it right, release
 740                 -> expect motion events right
 741            Put a second finger down in the area, move it down, release
 742                 -> expect motion events down
 743            Release second finger, release first finger
 744                 -> expect a button event */
 745         litest_touch_down(dev, 0, 20, 90);
 746         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 747         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 748
 749         assert_button_event(li,
 750                             BTN_LEFT,
 751                             LIBINPUT_BUTTON_STATE_PRESSED);
 752         litest_assert_empty_queue(li);
 753
 754         litest_touch_down(dev, 1, 20, 20);
 755         litest_touch_move_to(dev, 1, 20, 20, 80, 20, 10);
 756
 757         libinput_dispatch(li);
 758         event = libinput_get_event(li);
 759         ck_assert(event != NULL);
 760         while (event) {
 761                 struct libinput_event_pointer *p;
 762                 double x, y;
 763
 764                 ck_assert_int_eq(libinput_event_get_type(event),
 765                                  LIBINPUT_EVENT_POINTER_MOTION);
 766                 p = libinput_event_get_pointer_event(event);
 767
 768                 x = libinput_event_pointer_get_dx(p);
 769                 y = libinput_event_pointer_get_dy(p);
 770
 771                 ck_assert(x > 0);
 772                 ck_assert(y == 0);
 773
 774                 libinput_event_destroy(event);
 775                 libinput_dispatch(li);
 776                 event = libinput_get_event(li);
 777         }
 778         litest_touch_up(dev, 1);
 779
 780         /* second finger down */
 781         litest_touch_down(dev, 1, 20, 20);
 782         litest_touch_move_to(dev, 1, 20, 20, 20, 80, 10);
 783
 784         libinput_dispatch(li);
 785         event = libinput_get_event(li);
 786         ck_assert(event != NULL);
 787         while (event) {
 788                 struct libinput_event_pointer *p;
 789                 double x, y;
 790
 791                 ck_assert_int_eq(libinput_event_get_type(event),
 792                                  LIBINPUT_EVENT_POINTER_MOTION);
 793                 p = libinput_event_get_pointer_event(event);
 794
 795                 x = libinput_event_pointer_get_dx(p);
 796                 y = libinput_event_pointer_get_dy(p);
 797
 798                 ck_assert(x == 0);
 799                 ck_assert(y > 0);
 800
 801                 libinput_event_destroy(event);
 802                 libinput_dispatch(li);
 803                 event = libinput_get_event(li);
 804         }
 805
 806         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 807         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 808         litest_touch_up(dev, 0);
 809
 810         assert_button_event(li,
 811                             BTN_LEFT,
 812                             LIBINPUT_BUTTON_STATE_RELEASED);
 813
 814         litest_assert_empty_queue(li);
 815 }
 816 END_TEST
 817
 818 START_TEST(clickpad_softbutton_left_to_right)
 819 {
 820         struct litest_device *dev = litest_current_device();
 821         struct libinput *li = dev->libinput;
 822
 823         litest_drain_events(li);
 824
 825         /* One finger down in left software button area,
 826            move to right button area immediately, click
 827                 -> expect right button event
 828         */
 829
 830         litest_touch_down(dev, 0, 20, 90);
 831         litest_touch_move_to(dev, 0, 20, 90, 90, 90, 10);
 832         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 833         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 834
 835         assert_button_event(li,
 836                             BTN_RIGHT,
 837                             LIBINPUT_BUTTON_STATE_PRESSED);
 838         litest_assert_empty_queue(li);
 839
 840         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 841         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 842         litest_touch_up(dev, 0);
 843
 844         assert_button_event(li,
 845                             BTN_RIGHT,
 846                             LIBINPUT_BUTTON_STATE_RELEASED);
 847
 848         litest_assert_empty_queue(li);
 849 }
 850 END_TEST
 851
 852 START_TEST(clickpad_softbutton_right_to_left)
 853 {
 854         struct litest_device *dev = litest_current_device();
 855         struct libinput *li = dev->libinput;
 856
 857         litest_drain_events(li);
 858
 859         /* One finger down in right software button area,
 860            move to left button area immediately, click
 861                 -> expect left button event
 862         */
 863
 864         litest_touch_down(dev, 0, 90, 90);
 865         litest_touch_move_to(dev, 0, 90, 90, 20, 90, 10);
 866         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 867         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 868
 869         assert_button_event(li,
 870                             BTN_LEFT,
 871                             LIBINPUT_BUTTON_STATE_PRESSED);
 872         litest_assert_empty_queue(li);
 873
 874         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 875         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 876         litest_touch_up(dev, 0);
 877
 878         assert_button_event(li,
 879                             BTN_LEFT,
 880                             LIBINPUT_BUTTON_STATE_RELEASED);
 881
 882         litest_assert_empty_queue(li);
 883 }
 884 END_TEST
 885
 886 START_TEST(clickpad_topsoftbuttons_left)
 887 {
 888         struct litest_device *dev = litest_current_device();
 889         struct libinput *li = dev->libinput;
 890
 891         litest_drain_events(li);
 892
 893         litest_touch_down(dev, 0, 10, 5);
 894         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 895         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 896
 897         assert_button_event(li,
 898                             BTN_LEFT,
 899                             LIBINPUT_BUTTON_STATE_PRESSED);
 900         litest_assert_empty_queue(li);
 901
 902         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 903         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 904         litest_touch_up(dev, 0);
 905
 906         assert_button_event(li,
 907                             BTN_LEFT,
 908                             LIBINPUT_BUTTON_STATE_RELEASED);
 909
 910         litest_assert_empty_queue(li);
 911 }
 912 END_TEST
 913
 914 START_TEST(clickpad_topsoftbuttons_right)
 915 {
 916         struct litest_device *dev = litest_current_device();
 917         struct libinput *li = dev->libinput;
 918
 919         litest_drain_events(li);
 920
 921         litest_touch_down(dev, 0, 90, 5);
 922         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 923         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 924
 925         assert_button_event(li,
 926                             BTN_RIGHT,
 927                             LIBINPUT_BUTTON_STATE_PRESSED);
 928         litest_assert_empty_queue(li);
 929
 930         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 931         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 932         litest_touch_up(dev, 0);
 933
 934         assert_button_event(li,
 935                             BTN_RIGHT,
 936                             LIBINPUT_BUTTON_STATE_RELEASED);
 937
 938         litest_assert_empty_queue(li);
 939 }
 940 END_TEST
 941
 942 START_TEST(clickpad_topsoftbuttons_middle)
 943 {
 944         struct litest_device *dev = litest_current_device();
 945         struct libinput *li = dev->libinput;
 946
 947         litest_drain_events(li);
 948
 949         litest_touch_down(dev, 0, 50, 5);
 950         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 951         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 952
 953         assert_button_event(li,
 954                             BTN_MIDDLE,
 955                             LIBINPUT_BUTTON_STATE_PRESSED);
 956         litest_assert_empty_queue(li);
 957
 958         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 959         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 960         litest_touch_up(dev, 0);
 961
 962         assert_button_event(li,
 963                             BTN_MIDDLE,
 964                             LIBINPUT_BUTTON_STATE_RELEASED);
 965
 966         litest_assert_empty_queue(li);
 967 }
 968 END_TEST
 969
 970 START_TEST(clickpad_topsoftbuttons_move_out_ignore)
 971 {
 972         struct litest_device *dev = litest_current_device();
 973         struct libinput *li = dev->libinput;
 974
 975         /* Finger down in top button area, wait past enter timeout
 976            Move into main area, wait past leave timeout
 977            Click
 978              -> expect no events
 979          */
 980
 981         litest_drain_events(li);
 982
 983         litest_touch_down(dev, 0, 50, 5);
 984         libinput_dispatch(li);
 985         usleep(200000);
 986         libinput_dispatch(li);
 987         litest_assert_empty_queue(li);
 988
 989         litest_touch_move_to(dev, 0, 50, 5, 80, 90, 20);
 990         libinput_dispatch(li);
 991         usleep(400000);
 992         libinput_dispatch(li);
 993
 994         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 995         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 996         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 997         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 998
 999         litest_touch_up(dev, 0);
1000
1001         litest_assert_empty_queue(li);
1002 }
1003 END_TEST
1004
1005 int main(int argc, char **argv) {
1006
1007         litest_add("touchpad:motion", touchpad_1fg_motion, LITEST_TOUCHPAD, LITEST_ANY);
1008         litest_add("touchpad:motion", touchpad_2fg_no_motion, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1009
1010         litest_add("touchpad:tap", touchpad_1fg_tap, LITEST_TOUCHPAD, LITEST_ANY);
1011         litest_add("touchpad:tap", touchpad_1fg_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY);
1012         litest_add("touchpad:tap", touchpad_2fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
1013         litest_add("touchpad:tap", touchpad_1fg_tap_click, LITEST_TOUCHPAD, LITEST_ANY);
1014         litest_add("touchpad:tap", touchpad_2fg_tap_click, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH|LITEST_APPLE_CLICKPAD);
1015         litest_add("touchpad:tap", touchpad_2fg_tap_click_apple, LITEST_APPLE_CLICKPAD, LITEST_ANY);
1016         /* Real buttons don't interfere with tapping, so don't run those for
1017            pads with buttons */
1018         litest_add("touchpad:tap", touchpad_1fg_double_tap_click, LITEST_CLICKPAD, LITEST_ANY);
1019         litest_add("touchpad:tap", touchpad_1fg_tap_n_drag_click, LITEST_CLICKPAD, LITEST_ANY);
1020
1021         litest_add_no_device("touchpad:clickfinger", touchpad_1fg_clickfinger);
1022         litest_add_no_device("touchpad:clickfinger", touchpad_2fg_clickfinger);
1023
1024         litest_add("touchpad:click", touchpad_btn_left, LITEST_TOUCHPAD, LITEST_CLICKPAD);
1025         litest_add("touchpad:click", clickpad_btn_left, LITEST_CLICKPAD, LITEST_ANY);
1026         litest_add("touchpad:click", clickpad_click_n_drag, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
1027
1028         litest_add("touchpad:softbutton", clickpad_softbutton_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1029         litest_add("touchpad:softbutton", clickpad_softbutton_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1030         litest_add("touchpad:softbutton", clickpad_softbutton_left_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1031         litest_add("touchpad:softbutton", clickpad_softbutton_right_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1032         litest_add("touchpad:softbutton", clickpad_softbutton_left_1st_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1033         litest_add("touchpad:softbutton", clickpad_softbutton_left_2nd_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1034         litest_add("touchpad:softbutton", clickpad_softbutton_left_to_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1035         litest_add("touchpad:softbutton", clickpad_softbutton_right_to_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
1036
1037         litest_add("touchpad:topsoftbuttons", clickpad_topsoftbuttons_left, LITEST_TOPBUTTONPAD, LITEST_ANY);
1038         litest_add("touchpad:topsoftbuttons", clickpad_topsoftbuttons_right, LITEST_TOPBUTTONPAD, LITEST_ANY);
1039         litest_add("touchpad:topsoftbuttons", clickpad_topsoftbuttons_middle, LITEST_TOPBUTTONPAD, LITEST_ANY);
1040         litest_add("touchpad:topsoftbuttons", clickpad_topsoftbuttons_move_out_ignore, LITEST_TOPBUTTONPAD, LITEST_ANY);
1041
1042         return litest_run(argc, argv);
1043 }