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_clickfinger)
 214 {
 215         struct litest_device *dev = litest_create_device(LITEST_BCM5974);
 216         struct libinput *li = dev->libinput;
 217
 218         litest_drain_events(li);
 219
 220         litest_touch_down(dev, 0, 50, 50);
 221         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 222         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 223         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 224         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 225         litest_touch_up(dev, 0);
 226
 227         libinput_dispatch(li);
 228
 229         assert_button_event(li, BTN_LEFT,
 230                             LIBINPUT_BUTTON_STATE_PRESSED);
 231         assert_button_event(li, BTN_LEFT,
 232                             LIBINPUT_BUTTON_STATE_RELEASED);
 233
 234         litest_delete_device(dev);
 235 }
 236 END_TEST
 237
 238 START_TEST(touchpad_2fg_clickfinger)
 239 {
 240         struct litest_device *dev = litest_create_device(LITEST_BCM5974);
 241         struct libinput *li = dev->libinput;
 242
 243         litest_drain_events(li);
 244
 245         litest_touch_down(dev, 0, 50, 50);
 246         litest_touch_down(dev, 1, 70, 70);
 247         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 248         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 249         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 250         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 251         litest_touch_up(dev, 0);
 252         litest_touch_up(dev, 1);
 253
 254         libinput_dispatch(li);
 255
 256         assert_button_event(li, BTN_RIGHT,
 257                             LIBINPUT_BUTTON_STATE_PRESSED);
 258         assert_button_event(li, BTN_RIGHT,
 259                             LIBINPUT_BUTTON_STATE_RELEASED);
 260
 261         litest_delete_device(dev);
 262 }
 263 END_TEST
 264
 265 START_TEST(touchpad_btn_left)
 266 {
 267         struct litest_device *dev = litest_current_device();
 268         struct libinput *li = dev->libinput;
 269
 270         litest_drain_events(li);
 271
 272         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 273         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 274         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 275         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 276
 277         libinput_dispatch(li);
 278
 279         assert_button_event(li, BTN_LEFT,
 280                             LIBINPUT_BUTTON_STATE_PRESSED);
 281         assert_button_event(li, BTN_LEFT,
 282                             LIBINPUT_BUTTON_STATE_RELEASED);
 283 }
 284 END_TEST
 285
 286 START_TEST(clickpad_btn_left)
 287 {
 288         struct litest_device *dev = litest_current_device();
 289         struct libinput *li = dev->libinput;
 290
 291         litest_drain_events(li);
 292
 293         /* A clickpad always needs a finger down to tell where the
 294            click happens */
 295         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 296         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 297         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 298         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 299
 300         libinput_dispatch(li);
 301         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 302 }
 303 END_TEST
 304
 305 START_TEST(clickpad_click_n_drag)
 306 {
 307         struct litest_device *dev = litest_current_device();
 308         struct libinput *li = dev->libinput;
 309         struct libinput_event *event;
 310
 311         litest_drain_events(li);
 312
 313         litest_touch_down(dev, 0, 50, 50);
 314         litest_event(dev, EV_KEY, BTN_LEFT, 1);
 315         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 316
 317         libinput_dispatch(li);
 318         assert_button_event(li, BTN_LEFT,
 319                             LIBINPUT_BUTTON_STATE_PRESSED);
 320
 321         libinput_dispatch(li);
 322         ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
 323
 324         /* now put a second finger down */
 325         litest_touch_down(dev, 1, 70, 70);
 326         litest_touch_move_to(dev, 1, 70, 70, 80, 50, 5);
 327         litest_touch_up(dev, 1);
 328
 329         libinput_dispatch(li);
 330         ck_assert_int_eq(libinput_next_event_type(li),
 331                          LIBINPUT_EVENT_POINTER_MOTION);
 332         do {
 333                 event = libinput_get_event(li);
 334                 libinput_event_destroy(event);
 335                 libinput_dispatch(li);
 336         } while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION);
 337
 338         litest_event(dev, EV_KEY, BTN_LEFT, 0);
 339         litest_event(dev, EV_SYN, SYN_REPORT, 0);
 340         litest_touch_up(dev, 0);
 341
 342         assert_button_event(li, BTN_LEFT,
 343                             LIBINPUT_BUTTON_STATE_RELEASED);
 344 }
 345 END_TEST
 346
 347 int main(int argc, char **argv) {
 348
 349         litest_add("touchpad:motion", touchpad_1fg_motion, LITEST_TOUCHPAD, LITEST_ANY);
 350         litest_add("touchpad:motion", touchpad_2fg_no_motion, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
 351
 352         litest_add("touchpad:tap", touchpad_1fg_tap, LITEST_TOUCHPAD, LITEST_ANY);
 353         litest_add("touchpad:tap", touchpad_1fg_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY);
 354         litest_add("touchpad:tap", touchpad_2fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
 355
 356         litest_add_no_device("touchpad:clickfinger", touchpad_1fg_clickfinger);
 357         litest_add_no_device("touchpad:clickfinger", touchpad_2fg_clickfinger);
 358
 359         litest_add("touchpad:click", touchpad_btn_left, LITEST_TOUCHPAD, LITEST_CLICKPAD);
 360         litest_add("touchpad:click", clickpad_btn_left, LITEST_CLICKPAD, LITEST_ANY);
 361         litest_add("touchpad:click", clickpad_click_n_drag, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
 362
 363         return litest_run(argc, argv);
 364 }