test/test-libevdev-events.c

   1 /*
   2  * Copyright © 2013 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <config.h>
  24 #include <linux/input.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <stdio.h>
  29
  30 #include "test-common.h"
  31
  32 START_TEST(test_next_event)
  33 {
  34         struct uinput_device* uidev;
  35         struct libevdev *dev;
  36         int rc;
  37         struct input_event ev;
  38
  39         rc = test_create_device(&uidev, &dev,
  40                                 EV_REL, REL_X,
  41                                 EV_REL, REL_Y,
  42                                 EV_KEY, BTN_LEFT,
  43                                 -1);
  44         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
  45
  46         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
  47         ck_assert_int_eq(rc, -EAGAIN);
  48
  49         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
  50         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
  51         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
  52         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
  53         ck_assert_int_eq(ev.type, EV_KEY);
  54         ck_assert_int_eq(ev.code, BTN_LEFT);
  55         ck_assert_int_eq(ev.value, 1);
  56
  57         libevdev_free(dev);
  58         uinput_device_free(uidev);
  59
  60 }
  61 END_TEST
  62
  63 START_TEST(test_syn_dropped_event)
  64 {
  65         struct uinput_device* uidev;
  66         struct libevdev *dev;
  67         int rc;
  68         struct input_event ev;
  69         int pipefd[2];
  70
  71         rc = test_create_device(&uidev, &dev,
  72                                 EV_SYN, SYN_REPORT,
  73                                 EV_SYN, SYN_DROPPED,
  74                                 EV_REL, REL_X,
  75                                 EV_REL, REL_Y,
  76                                 EV_KEY, BTN_LEFT,
  77                                 -1);
  78         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
  79
  80         /* This is a bit complicated:
  81            we can't get SYN_DROPPED through uinput, so we push two events down
  82            uinput, and fetch one off libevdev (reading in the other one on the
  83            way). Then write a SYN_DROPPED on a pipe, switch the fd and read
  84            one event off the wire (but returning the second event from
  85            before). Switch back, so that when we do read off the SYN_DROPPED
  86            we have the fd back on the device and the ioctls work.
  87          */
  88         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
  89         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
  90         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
  91         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
  92         ck_assert_int_eq(ev.type, EV_KEY);
  93         ck_assert_int_eq(ev.code, BTN_LEFT);
  94         rc = pipe2(pipefd, O_NONBLOCK);
  95         ck_assert_int_eq(rc, 0);
  96
  97         libevdev_change_fd(dev, pipefd[0]);
  98         ev.type = EV_SYN;
  99         ev.code = SYN_DROPPED;
 100         ev.value = 0;
 101         rc = write(pipefd[1], &ev, sizeof(ev));
 102         ck_assert_int_eq(rc, sizeof(ev));
 103         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 104
 105         libevdev_change_fd(dev, uinput_device_get_fd(uidev));
 106
 107         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 108         ck_assert_int_eq(ev.type, EV_SYN);
 109         ck_assert_int_eq(ev.code, SYN_REPORT);
 110         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 111         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 112         ck_assert_int_eq(ev.type, EV_SYN);
 113         ck_assert_int_eq(ev.code, SYN_DROPPED);
 114
 115         /* only check for the rc, nothing actually changed on the device */
 116
 117         libevdev_free(dev);
 118         uinput_device_free(uidev);
 119
 120         close(pipefd[0]);
 121         close(pipefd[1]);
 122
 123 }
 124 END_TEST
 125
 126 void double_syn_dropped_logfunc(enum libevdev_log_priority priority,
 127                                 void *data,
 128                                 const char *file, int line,
 129                                 const char *func,
 130                                 const char *format, va_list args)
 131 {
 132         unsigned int *hit = data;
 133         *hit = 1;
 134 }
 135
 136 START_TEST(test_double_syn_dropped_event)
 137 {
 138         struct uinput_device* uidev;
 139         struct libevdev *dev;
 140         int rc;
 141         struct input_event ev;
 142         int pipefd[2];
 143         unsigned int logfunc_hit = 0;
 144
 145         rc = test_create_device(&uidev, &dev,
 146                                 EV_SYN, SYN_REPORT,
 147                                 EV_SYN, SYN_DROPPED,
 148                                 EV_REL, REL_X,
 149                                 EV_REL, REL_Y,
 150                                 EV_KEY, BTN_LEFT,
 151                                 -1);
 152         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 153
 154         libevdev_set_log_function(double_syn_dropped_logfunc,  &logfunc_hit);
 155
 156         /* This is a bit complicated:
 157            we can't get SYN_DROPPED through uinput, so we push two events down
 158            uinput, and fetch one off libevdev (reading in the other one on the
 159            way). Then write a SYN_DROPPED on a pipe, switch the fd and read
 160            one event off the wire (but returning the second event from
 161            before). Switch back, so that when we do read off the SYN_DROPPED
 162            we have the fd back on the device and the ioctls work.
 163          */
 164         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
 165         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 166         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 167         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 168         ck_assert_int_eq(ev.type, EV_KEY);
 169         ck_assert_int_eq(ev.code, BTN_LEFT);
 170         rc = pipe2(pipefd, O_NONBLOCK);
 171         ck_assert_int_eq(rc, 0);
 172
 173         libevdev_change_fd(dev, pipefd[0]);
 174         ev.type = EV_SYN;
 175         ev.code = SYN_DROPPED;
 176         ev.value = 0;
 177         rc = write(pipefd[1], &ev, sizeof(ev));
 178         ck_assert_int_eq(rc, sizeof(ev));
 179         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 180
 181         /* sneak in a button change event while we're not looking, this way
 182          * the sync queue contains 2 events: BTN_LEFT and SYN_REPORT. */
 183         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 0);
 184         read(pipefd[0], &ev, sizeof(ev));
 185
 186         libevdev_change_fd(dev, uinput_device_get_fd(uidev));
 187
 188         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 189         ck_assert_int_eq(ev.type, EV_SYN);
 190         ck_assert_int_eq(ev.code, SYN_REPORT);
 191         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 192         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 193         ck_assert_int_eq(ev.type, EV_SYN);
 194         ck_assert_int_eq(ev.code, SYN_DROPPED);
 195
 196         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 197         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 198         ck_assert_int_eq(ev.type, EV_KEY);
 199         ck_assert_int_eq(ev.code, BTN_LEFT);
 200         ck_assert_int_eq(ev.value, 0);
 201
 202         /* now write the second SYN_DROPPED on the pipe so we pick it up
 203          * before we finish syncing. */
 204         libevdev_change_fd(dev, pipefd[0]);
 205         ev.type = EV_SYN;
 206         ev.code = SYN_DROPPED;
 207         ev.value = 0;
 208         rc = write(pipefd[1], &ev, sizeof(ev));
 209         ck_assert_int_eq(rc, sizeof(ev));
 210
 211         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 212         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 213         ck_assert_int_eq(ev.type, EV_SYN);
 214         ck_assert_int_eq(ev.code, SYN_REPORT);
 215         ck_assert_int_eq(ev.value, 0);
 216
 217         /* back to enable the ioctls again */
 218         libevdev_change_fd(dev, uinput_device_get_fd(uidev));
 219
 220         ck_assert_int_eq(logfunc_hit, 1);
 221
 222         libevdev_free(dev);
 223         uinput_device_free(uidev);
 224
 225         close(pipefd[0]);
 226         close(pipefd[1]);
 227
 228         libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
 229 }
 230 END_TEST
 231
 232 START_TEST(test_event_type_filtered)
 233 {
 234         struct uinput_device* uidev;
 235         struct libevdev *dev;
 236         int rc;
 237         struct input_event ev;
 238
 239         rc = test_create_device(&uidev, &dev,
 240                                 EV_REL, REL_X,
 241                                 EV_REL, REL_Y,
 242                                 EV_KEY, BTN_LEFT,
 243                                 -1);
 244         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 245
 246         libevdev_disable_event_type(dev, EV_REL);
 247
 248         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 249         ck_assert_int_eq(rc, -EAGAIN);
 250
 251         uinput_device_event(uidev, EV_REL, REL_X, 1);
 252         uinput_device_event(uidev, EV_KEY, REL_Y, 1);
 253         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 254         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 255         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 256         ck_assert_int_eq(ev.type, EV_SYN);
 257         ck_assert_int_eq(ev.code, SYN_REPORT);
 258
 259         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 260         ck_assert_int_eq(rc, -EAGAIN);
 261
 262         libevdev_free(dev);
 263         uinput_device_free(uidev);
 264
 265 }
 266 END_TEST
 267 START_TEST(test_event_code_filtered)
 268 {
 269         struct uinput_device* uidev;
 270         struct libevdev *dev;
 271         int rc;
 272         struct input_event ev;
 273
 274         rc = test_create_device(&uidev, &dev,
 275                                 EV_REL, REL_X,
 276                                 EV_REL, REL_Y,
 277                                 EV_KEY, BTN_LEFT,
 278                                 -1);
 279         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 280
 281         libevdev_disable_event_code(dev, EV_REL, REL_X);
 282
 283         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 284         ck_assert_int_eq(rc, -EAGAIN);
 285
 286         uinput_device_event(uidev, EV_REL, REL_X, 1);
 287         uinput_device_event(uidev, EV_REL, REL_Y, 1);
 288         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 289         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 290         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 291         ck_assert_int_eq(ev.type, EV_REL);
 292         ck_assert_int_eq(ev.code, REL_Y);
 293         ck_assert_int_eq(ev.value, 1);
 294
 295         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 296         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
 297         ck_assert_int_eq(ev.type, EV_SYN);
 298         ck_assert_int_eq(ev.code, SYN_REPORT);
 299
 300         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 301         ck_assert_int_eq(rc, -EAGAIN);
 302
 303         libevdev_free(dev);
 304         uinput_device_free(uidev);
 305
 306 }
 307 END_TEST
 308
 309 START_TEST(test_has_event_pending)
 310 {
 311         struct uinput_device* uidev;
 312         struct libevdev *dev;
 313         int rc;
 314         struct input_event ev;
 315
 316         rc = test_create_device(&uidev, &dev,
 317                                 EV_REL, REL_X,
 318                                 EV_REL, REL_Y,
 319                                 EV_KEY, BTN_LEFT,
 320                                 -1);
 321         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 322
 323         ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
 324
 325         uinput_device_event(uidev, EV_REL, REL_X, 1);
 326         uinput_device_event(uidev, EV_REL, REL_Y, 1);
 327         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 328
 329         ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
 330
 331         libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 332
 333         ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
 334
 335         while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN)
 336                         ;
 337
 338         ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
 339
 340         libevdev_change_fd(dev, -1);
 341         ck_assert_int_eq(libevdev_has_event_pending(dev), -EBADF);
 342
 343         libevdev_free(dev);
 344         uinput_device_free(uidev);
 345
 346 }
 347 END_TEST
 348 START_TEST(test_syn_delta_button)
 349 {
 350         struct uinput_device* uidev;
 351         struct libevdev *dev;
 352         int rc;
 353         struct input_event ev;
 354
 355         rc = test_create_device(&uidev, &dev,
 356                                 EV_SYN, SYN_REPORT,
 357                                 EV_SYN, SYN_DROPPED,
 358                                 EV_REL, REL_X,
 359                                 EV_REL, REL_Y,
 360                                 EV_KEY, BTN_LEFT,
 361                                 EV_KEY, BTN_MIDDLE,
 362                                 EV_KEY, BTN_RIGHT,
 363                                 EV_KEY, KEY_MAX,
 364                                 -1);
 365         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 366
 367         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
 368         uinput_device_event(uidev, EV_KEY, BTN_RIGHT, 1);
 369         uinput_device_event(uidev, EV_KEY, KEY_MAX, 1);
 370         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 371         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 372         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 373
 374         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 375         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 376         ck_assert_int_eq(ev.type, EV_KEY);
 377         ck_assert_int_eq(ev.code, BTN_LEFT);
 378         ck_assert_int_eq(ev.value, 1);
 379         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 380         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 381         ck_assert_int_eq(ev.type, EV_KEY);
 382         ck_assert_int_eq(ev.code, BTN_RIGHT);
 383         ck_assert_int_eq(ev.value, 1);
 384         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 385         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 386         ck_assert_int_eq(ev.type, EV_KEY);
 387         ck_assert_int_eq(ev.code, KEY_MAX);
 388         ck_assert_int_eq(ev.value, 1);
 389         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 390         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 391         ck_assert_int_eq(ev.type, EV_SYN);
 392         ck_assert_int_eq(ev.code, SYN_REPORT);
 393         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 394         ck_assert_int_eq(rc, -EAGAIN);
 395
 396         ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT));
 397         ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT));
 398         ck_assert(!libevdev_get_event_value(dev, EV_KEY, BTN_MIDDLE));
 399         ck_assert(libevdev_get_event_value(dev, EV_KEY, KEY_MAX));
 400
 401         uinput_device_free(uidev);
 402         libevdev_free(dev);
 403 }
 404 END_TEST
 405
 406 START_TEST(test_syn_delta_abs)
 407 {
 408         struct uinput_device* uidev;
 409         struct libevdev *dev;
 410         int rc;
 411         struct input_event ev;
 412         struct input_absinfo abs[3];
 413
 414         memset(abs, 0, sizeof(abs));
 415         abs[0].value = ABS_X;
 416         abs[0].maximum = 1000;
 417
 418         abs[1].value = ABS_Y;
 419         abs[1].maximum = 1000;
 420
 421         abs[2].value = ABS_MAX;
 422         abs[2].maximum = 1000;
 423
 424         rc = test_create_abs_device(&uidev, &dev,
 425                                     3, abs,
 426                                     EV_SYN, SYN_REPORT,
 427                                     EV_SYN, SYN_DROPPED,
 428                                     EV_KEY, BTN_LEFT,
 429                                     EV_KEY, BTN_MIDDLE,
 430                                     EV_KEY, BTN_RIGHT,
 431                                     -1);
 432         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 433
 434         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 435         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 436         uinput_device_event(uidev, EV_ABS, ABS_MAX, 700);
 437         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 438         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 439         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 440
 441         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 442         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 443         ck_assert_int_eq(ev.type, EV_ABS);
 444         ck_assert_int_eq(ev.code, ABS_X);
 445         ck_assert_int_eq(ev.value, 100);
 446         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 447         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 448         ck_assert_int_eq(ev.type, EV_ABS);
 449         ck_assert_int_eq(ev.code, ABS_Y);
 450         ck_assert_int_eq(ev.value, 500);
 451         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 452         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 453         ck_assert_int_eq(ev.type, EV_ABS);
 454         ck_assert_int_eq(ev.code, ABS_MAX);
 455         ck_assert_int_eq(ev.value, 700);
 456         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 457         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 458         ck_assert_int_eq(ev.type, EV_SYN);
 459         ck_assert_int_eq(ev.code, SYN_REPORT);
 460         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 461         ck_assert_int_eq(rc, -EAGAIN);
 462
 463         uinput_device_free(uidev);
 464         libevdev_free(dev);
 465 }
 466 END_TEST
 467
 468 START_TEST(test_syn_delta_mt)
 469 {
 470         struct uinput_device* uidev;
 471         struct libevdev *dev;
 472         int rc;
 473         struct input_event ev;
 474         struct input_absinfo abs[6];
 475
 476         memset(abs, 0, sizeof(abs));
 477         abs[0].value = ABS_X;
 478         abs[0].maximum = 1000;
 479         abs[1].value = ABS_MT_POSITION_X;
 480         abs[1].maximum = 1000;
 481
 482         abs[2].value = ABS_Y;
 483         abs[2].maximum = 1000;
 484         abs[3].value = ABS_MT_POSITION_Y;
 485         abs[3].maximum = 1000;
 486
 487
 488         abs[4].value = ABS_MT_SLOT;
 489         abs[4].maximum = 1;
 490         abs[5].value = ABS_MT_TRACKING_ID;
 491         abs[5].minimum = -1;
 492         abs[5].maximum = 2;
 493
 494         rc = test_create_abs_device(&uidev, &dev,
 495                                     6, abs,
 496                                     EV_SYN, SYN_REPORT,
 497                                     -1);
 498         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 499
 500         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
 501         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 502         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 503         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
 504         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
 505         uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
 506         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
 507         uinput_device_event(uidev, EV_ABS, ABS_X, 1);
 508         uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
 509         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
 510         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
 511         uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
 512         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 513
 514         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 515         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 516
 517         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 518         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 519         ck_assert_int_eq(ev.type, EV_ABS);
 520         ck_assert_int_eq(ev.code, ABS_X);
 521         ck_assert_int_eq(ev.value, 1);
 522         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 523         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 524         ck_assert_int_eq(ev.type, EV_ABS);
 525         ck_assert_int_eq(ev.code, ABS_Y);
 526         ck_assert_int_eq(ev.value, 5);
 527         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 528         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 529         ck_assert_int_eq(ev.type, EV_ABS);
 530         ck_assert_int_eq(ev.code, ABS_MT_SLOT);
 531         ck_assert_int_eq(ev.value, 0);
 532         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 533         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 534         ck_assert_int_eq(ev.type, EV_ABS);
 535         ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
 536         ck_assert_int_eq(ev.value, 100);
 537         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 538         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 539         ck_assert_int_eq(ev.type, EV_ABS);
 540         ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
 541         ck_assert_int_eq(ev.value, 500);
 542         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 543         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 544         ck_assert_int_eq(ev.type, EV_ABS);
 545         ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
 546         ck_assert_int_eq(ev.value, 1);
 547         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 548         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 549         ck_assert_int_eq(ev.type, EV_ABS);
 550         ck_assert_int_eq(ev.code, ABS_MT_SLOT);
 551         ck_assert_int_eq(ev.value, 1);
 552         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 553         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 554         ck_assert_int_eq(ev.type, EV_ABS);
 555         ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
 556         ck_assert_int_eq(ev.value, 1);
 557         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 558         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 559         ck_assert_int_eq(ev.type, EV_ABS);
 560         ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
 561         ck_assert_int_eq(ev.value, 5);
 562         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 563         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 564         ck_assert_int_eq(ev.type, EV_ABS);
 565         ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
 566         ck_assert_int_eq(ev.value, 2);
 567
 568         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 569         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 570         ck_assert_int_eq(ev.type, EV_SYN);
 571         ck_assert_int_eq(ev.code, SYN_REPORT);
 572         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 573         ck_assert_int_eq(rc, -EAGAIN);
 574
 575         uinput_device_free(uidev);
 576         libevdev_free(dev);
 577 }
 578 END_TEST
 579
 580 START_TEST(test_syn_delta_led)
 581 {
 582         struct uinput_device* uidev;
 583         struct libevdev *dev;
 584         int rc;
 585         struct input_event ev;
 586
 587         rc = test_create_device(&uidev, &dev,
 588                                 EV_SYN, SYN_REPORT,
 589                                 EV_SYN, SYN_DROPPED,
 590                                 EV_LED, LED_NUML,
 591                                 EV_LED, LED_CAPSL,
 592                                 EV_LED, LED_MAX,
 593                                 -1);
 594         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 595
 596         uinput_device_event(uidev, EV_LED, LED_NUML, 1);
 597         uinput_device_event(uidev, EV_LED, LED_CAPSL, 1);
 598         uinput_device_event(uidev, EV_LED, LED_MAX, 1);
 599         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 600         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 601         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 602
 603         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 604         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 605         ck_assert_int_eq(ev.type, EV_LED);
 606         ck_assert_int_eq(ev.code, LED_NUML);
 607         ck_assert_int_eq(ev.value, 1);
 608         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 609         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 610         ck_assert_int_eq(ev.type, EV_LED);
 611         ck_assert_int_eq(ev.code, LED_CAPSL);
 612         ck_assert_int_eq(ev.value, 1);
 613         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 614         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 615         ck_assert_int_eq(ev.type, EV_LED);
 616         ck_assert_int_eq(ev.code, LED_MAX);
 617         ck_assert_int_eq(ev.value, 1);
 618         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 619         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 620         ck_assert_int_eq(ev.type, EV_SYN);
 621         ck_assert_int_eq(ev.code, SYN_REPORT);
 622         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 623         ck_assert_int_eq(rc, -EAGAIN);
 624
 625         ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
 626         ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
 627         ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_MAX), 1);
 628
 629         uinput_device_free(uidev);
 630         libevdev_free(dev);
 631 }
 632 END_TEST
 633
 634 START_TEST(test_syn_delta_sw)
 635 {
 636         struct uinput_device* uidev;
 637         struct libevdev *dev;
 638         int rc;
 639         struct input_event ev;
 640
 641         rc = test_create_device(&uidev, &dev,
 642                                 EV_SYN, SYN_REPORT,
 643                                 EV_SYN, SYN_DROPPED,
 644                                 EV_SW, SW_LID,
 645                                 EV_SW, SW_MICROPHONE_INSERT,
 646                                 EV_SW, SW_MAX,
 647                                 -1);
 648         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 649
 650         uinput_device_event(uidev, EV_SW, SW_LID, 1);
 651         uinput_device_event(uidev, EV_SW, SW_MICROPHONE_INSERT, 1);
 652         uinput_device_event(uidev, EV_SW, SW_MAX, 1);
 653         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 654         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 655         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 656
 657         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 658         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 659         ck_assert_int_eq(ev.type, EV_SW);
 660         ck_assert_int_eq(ev.code, SW_LID);
 661         ck_assert_int_eq(ev.value, 1);
 662         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 663         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 664         ck_assert_int_eq(ev.type, EV_SW);
 665         ck_assert_int_eq(ev.code, SW_MICROPHONE_INSERT);
 666         ck_assert_int_eq(ev.value, 1);
 667         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 668         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 669         ck_assert_int_eq(ev.type, EV_SW);
 670         ck_assert_int_eq(ev.code, SW_MAX);
 671         ck_assert_int_eq(ev.value, 1);
 672         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 673         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 674         ck_assert_int_eq(ev.type, EV_SYN);
 675         ck_assert_int_eq(ev.code, SYN_REPORT);
 676         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 677         ck_assert_int_eq(rc, -EAGAIN);
 678
 679         ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
 680         ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MICROPHONE_INSERT), 1);
 681         ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MAX), 1);
 682
 683         uinput_device_free(uidev);
 684         libevdev_free(dev);
 685 }
 686 END_TEST
 687
 688 START_TEST(test_skipped_sync)
 689 {
 690         struct uinput_device* uidev;
 691         struct libevdev *dev;
 692         int rc;
 693         struct input_event ev;
 694         struct input_absinfo abs[2];
 695
 696         memset(abs, 0, sizeof(abs));
 697         abs[0].value = ABS_X;
 698         abs[0].maximum = 1000;
 699
 700         abs[1].value = ABS_Y;
 701         abs[1].maximum = 1000;
 702
 703         rc = test_create_abs_device(&uidev, &dev,
 704                                     2, abs,
 705                                     EV_SYN, SYN_REPORT,
 706                                     EV_SYN, SYN_DROPPED,
 707                                     EV_KEY, BTN_LEFT,
 708                                     EV_KEY, BTN_MIDDLE,
 709                                     EV_KEY, BTN_RIGHT,
 710                                     -1);
 711         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 712
 713         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
 714         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 715         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 716         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 717         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 718         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 719
 720         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 721         ck_assert_int_eq(rc, -EAGAIN);
 722
 723         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
 724         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
 725         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
 726
 727         uinput_device_free(uidev);
 728         libevdev_free(dev);
 729 }
 730 END_TEST
 731
 732 START_TEST(test_incomplete_sync)
 733 {
 734         struct uinput_device* uidev;
 735         struct libevdev *dev;
 736         int rc;
 737         struct input_event ev;
 738         struct input_absinfo abs[2];
 739
 740         memset(abs, 0, sizeof(abs));
 741         abs[0].value = ABS_X;
 742         abs[0].maximum = 1000;
 743
 744         abs[1].value = ABS_Y;
 745         abs[1].maximum = 1000;
 746
 747         rc = test_create_abs_device(&uidev, &dev,
 748                                     2, abs,
 749                                     EV_SYN, SYN_REPORT,
 750                                     EV_SYN, SYN_DROPPED,
 751                                     EV_KEY, BTN_LEFT,
 752                                     EV_KEY, BTN_MIDDLE,
 753                                     EV_KEY, BTN_RIGHT,
 754                                     -1);
 755         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 756
 757         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
 758         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 759         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 760         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 761         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 762         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 763
 764         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 765         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 766         ck_assert_int_eq(ev.type, EV_KEY);
 767         ck_assert_int_eq(ev.code, BTN_LEFT);
 768         ck_assert_int_eq(ev.value, 1);
 769
 770         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 771         ck_assert_int_eq(rc, -EAGAIN);
 772
 773         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
 774         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
 775         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
 776
 777         uinput_device_free(uidev);
 778         libevdev_free(dev);
 779 }
 780 END_TEST
 781
 782 START_TEST(test_empty_sync)
 783 {
 784         struct uinput_device* uidev;
 785         struct libevdev *dev;
 786         int rc;
 787         struct input_event ev;
 788
 789         rc = test_create_device(&uidev, &dev,
 790                                 EV_SYN, SYN_REPORT,
 791                                 EV_SYN, SYN_DROPPED,
 792                                 EV_KEY, BTN_LEFT,
 793                                 EV_KEY, BTN_MIDDLE,
 794                                 EV_KEY, BTN_RIGHT,
 795                                 -1);
 796         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 797
 798         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
 799         ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
 800
 801         rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
 802         ck_assert_int_eq(rc, -EAGAIN);
 803
 804         uinput_device_free(uidev);
 805         libevdev_free(dev);
 806 }
 807 END_TEST
 808
 809 START_TEST(test_event_values)
 810 {
 811         struct uinput_device* uidev;
 812         struct libevdev *dev;
 813         int rc;
 814         struct input_event ev;
 815         struct input_absinfo abs[2];
 816         int value;
 817
 818         memset(abs, 0, sizeof(abs));
 819         abs[0].value = ABS_X;
 820         abs[0].maximum = 1000;
 821
 822         abs[1].value = ABS_Y;
 823         abs[1].maximum = 1000;
 824
 825         rc = test_create_abs_device(&uidev, &dev,
 826                                     2, abs,
 827                                     EV_SYN, SYN_REPORT,
 828                                     EV_SYN, SYN_DROPPED,
 829                                     EV_REL, REL_X,
 830                                     EV_REL, REL_Y,
 831                                     EV_KEY, BTN_LEFT,
 832                                     EV_KEY, BTN_MIDDLE,
 833                                     EV_KEY, BTN_RIGHT,
 834                                     -1);
 835         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 836
 837         uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
 838         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 839         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 840         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 841
 842         /* must still be on old values */
 843         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
 844         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
 845         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
 846         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
 847         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
 848
 849         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
 850         ck_assert_int_eq(value, 0);
 851
 852         do {
 853                 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 854         } while (rc == 0);
 855         ck_assert_int_eq(rc, -EAGAIN);
 856
 857         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
 858         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
 859         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
 860
 861         /* always 0 */
 862         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
 863         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
 864
 865         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
 866         ck_assert_int_eq(value, 1);
 867         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_X, &value), 1);
 868         ck_assert_int_eq(value, 100);
 869         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Y, &value), 1);
 870         ck_assert_int_eq(value, 500);
 871
 872         uinput_device_free(uidev);
 873         libevdev_free(dev);
 874
 875 }
 876 END_TEST
 877
 878
 879 START_TEST(test_event_values_invalid)
 880 {
 881         struct uinput_device* uidev;
 882         struct libevdev *dev;
 883         int rc;
 884         struct input_absinfo abs[2];
 885         int value;
 886
 887         memset(abs, 0, sizeof(abs));
 888         abs[0].value = ABS_X;
 889         abs[0].maximum = 1000;
 890
 891         abs[1].value = ABS_Y;
 892         abs[1].maximum = 1000;
 893
 894         rc = test_create_abs_device(&uidev, &dev,
 895                                     2, abs,
 896                                     EV_SYN, SYN_REPORT,
 897                                     EV_SYN, SYN_DROPPED,
 898                                     EV_REL, REL_X,
 899                                     EV_REL, REL_Y,
 900                                     EV_KEY, BTN_LEFT,
 901                                     EV_KEY, BTN_MIDDLE,
 902                                     EV_KEY, BTN_RIGHT,
 903                                     -1);
 904         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 905
 906         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_EXTRA), 0);
 907         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Z), 0);
 908         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Z), 0);
 909
 910         value = 0xab;
 911         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_EXTRA, &value), 0);
 912         ck_assert_int_eq(value, 0xab);
 913         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Z, &value), 0);
 914         ck_assert_int_eq(value, 0xab);
 915         ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_REL, REL_Z, &value), 0);
 916         ck_assert_int_eq(value, 0xab);
 917
 918
 919         uinput_device_free(uidev);
 920         libevdev_free(dev);
 921
 922 }
 923 END_TEST
 924
 925 START_TEST(test_mt_event_values)
 926 {
 927         struct uinput_device* uidev;
 928         struct libevdev *dev;
 929         int rc;
 930         struct input_event ev;
 931         struct input_absinfo abs[5];
 932         int value;
 933
 934         memset(abs, 0, sizeof(abs));
 935         abs[0].value = ABS_X;
 936         abs[0].maximum = 1000;
 937         abs[1].value = ABS_MT_POSITION_X;
 938         abs[1].maximum = 1000;
 939
 940         abs[2].value = ABS_Y;
 941         abs[2].maximum = 1000;
 942         abs[3].value = ABS_MT_POSITION_Y;
 943         abs[3].maximum = 1000;
 944
 945         abs[4].value = ABS_MT_SLOT;
 946         abs[4].maximum = 2;
 947
 948         rc = test_create_abs_device(&uidev, &dev,
 949                                     5, abs,
 950                                     EV_SYN, SYN_REPORT,
 951                                     -1);
 952         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 953
 954         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
 955         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 956         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 957         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
 958         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
 959         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
 960         uinput_device_event(uidev, EV_ABS, ABS_X, 1);
 961         uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
 962         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
 963         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
 964         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 965
 966         /* must still be on old values */
 967         ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
 968         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 0);
 969         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 0);
 970         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 0);
 971         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 0);
 972
 973         do {
 974                 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
 975         } while (rc == LIBEVDEV_READ_STATUS_SUCCESS);
 976         ck_assert_int_eq(rc, -EAGAIN);
 977
 978         ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
 979         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
 980         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
 981         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
 982         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
 983
 984         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 1);
 985         ck_assert_int_eq(value, 100);
 986         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_Y, &value), 1);
 987         ck_assert_int_eq(value, 500);
 988         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_X, &value), 1);
 989         ck_assert_int_eq(value, 1);
 990         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_Y, &value), 1);
 991         ck_assert_int_eq(value, 5);
 992
 993         uinput_device_free(uidev);
 994         libevdev_free(dev);
 995
 996 }
 997 END_TEST
 998
 999 START_TEST(test_mt_event_values_invalid)
1000 {
1001         struct uinput_device* uidev;
1002         struct libevdev *dev;
1003         int rc;
1004         struct input_absinfo abs[5];
1005         int value;
1006
1007         memset(abs, 0, sizeof(abs));
1008         abs[0].value = ABS_X;
1009         abs[0].maximum = 1000;
1010         abs[1].value = ABS_MT_POSITION_X;
1011         abs[1].maximum = 1000;
1012
1013         abs[2].value = ABS_Y;
1014         abs[2].maximum = 1000;
1015         abs[3].value = ABS_MT_POSITION_Y;
1016         abs[3].maximum = 1000;
1017
1018         abs[4].value = ABS_MT_SLOT;
1019         abs[4].maximum = 2;
1020
1021         rc = test_create_abs_device(&uidev, &dev,
1022                                     5, abs,
1023                                     EV_SYN, SYN_REPORT,
1024                                     -1);
1025         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1026
1027         ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1028         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_TOUCH_MINOR), 0);
1029         value = 0xab;
1030         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_TOUCH_MINOR, &value), 0);
1031         ck_assert_int_eq(value, 0xab);
1032
1033         ck_assert_int_eq(libevdev_get_slot_value(dev, 10, ABS_MT_POSITION_X), 0);
1034         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_X), 0);
1035
1036         uinput_device_free(uidev);
1037         libevdev_free(dev);
1038 }
1039 END_TEST
1040
1041 START_TEST(test_ev_rep_values)
1042 {
1043         struct uinput_device* uidev;
1044         struct libevdev *dev;
1045         int rc;
1046         int delay = 500, period = 200;
1047         rc = test_create_device(&uidev, &dev,
1048                                 EV_KEY, BTN_LEFT,
1049                                 EV_REL, REL_X,
1050                                 EV_REL, REL_Y,
1051                                 EV_SYN, SYN_REPORT,
1052                                 -1);
1053         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1054
1055         libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
1056         libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
1057
1058         ck_assert_int_eq(libevdev_has_event_type(dev, EV_REP), 1);
1059         ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_DELAY), 1);
1060         ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_PERIOD), 1);
1061         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_DELAY), 500);
1062         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_PERIOD), 200);
1063 }
1064 END_TEST
1065
1066 START_TEST(test_event_value_setters)
1067 {
1068         struct uinput_device* uidev;
1069         struct libevdev *dev;
1070         int rc;
1071         struct input_absinfo abs[2];
1072
1073         memset(abs, 0, sizeof(abs));
1074         abs[0].value = ABS_X;
1075         abs[0].maximum = 1000;
1076
1077         abs[1].value = ABS_Y;
1078         abs[1].maximum = 1000;
1079
1080         rc = test_create_abs_device(&uidev, &dev,
1081                                     2, abs,
1082                                     EV_SYN, SYN_REPORT,
1083                                     EV_REL, REL_X,
1084                                     EV_REL, REL_Y,
1085                                     EV_KEY, BTN_LEFT,
1086                                     EV_KEY, BTN_MIDDLE,
1087                                     EV_KEY, BTN_RIGHT,
1088                                     EV_LED, LED_NUML,
1089                                     EV_LED, LED_CAPSL,
1090                                     EV_SW, SW_LID,
1091                                     EV_SW, SW_TABLET_MODE,
1092                                     -1);
1093         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1094
1095         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
1096         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
1097         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
1098         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
1099         ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
1100
1101         ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_LEFT, 1), 0);
1102         ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_RIGHT, 1), 0);
1103
1104         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
1105         ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT), 1);
1106
1107         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_X, 10), 0);
1108         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Y, 20), 0);
1109
1110         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 10);
1111         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 20);
1112
1113         ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_NUML, 1), 0);
1114         ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_CAPSL, 1), 0);
1115
1116         ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
1117         ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
1118
1119         ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_LID, 1), 0);
1120         ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_TABLET_MODE, 1), 0);
1121
1122         ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
1123         ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_TABLET_MODE), 1);
1124
1125         uinput_device_free(uidev);
1126         libevdev_free(dev);
1127
1128 }
1129 END_TEST
1130
1131 START_TEST(test_event_value_setters_invalid)
1132 {
1133         struct uinput_device* uidev;
1134         struct libevdev *dev;
1135         int rc;
1136         struct input_absinfo abs[2];
1137
1138         memset(abs, 0, sizeof(abs));
1139         abs[0].value = ABS_X;
1140         abs[0].maximum = 1000;
1141
1142         abs[1].value = ABS_Y;
1143         abs[1].maximum = 1000;
1144
1145         rc = test_create_abs_device(&uidev, &dev,
1146                                     2, abs,
1147                                     EV_SYN, SYN_REPORT,
1148                                     EV_REL, REL_X,
1149                                     EV_REL, REL_Y,
1150                                     EV_KEY, BTN_LEFT,
1151                                     EV_KEY, BTN_MIDDLE,
1152                                     EV_KEY, BTN_RIGHT,
1153                                     -1);
1154         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1155
1156         ck_assert_int_eq(libevdev_set_event_value(dev, EV_REL, REL_X, 1), -1);
1157         ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_DOCK, 1), -1);
1158         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Z, 1), -1);
1159         ck_assert_int_eq(libevdev_set_event_value(dev, EV_MAX + 1, 0, 1), -1);
1160         ck_assert_int_eq(libevdev_set_event_value(dev, EV_SYN, SYN_REPORT, 0), -1);
1161
1162         uinput_device_free(uidev);
1163         libevdev_free(dev);
1164
1165 }
1166 END_TEST
1167
1168 START_TEST(test_event_mt_value_setters)
1169 {
1170         struct uinput_device* uidev;
1171         struct libevdev *dev;
1172         int rc;
1173         struct input_absinfo abs[5];
1174
1175         memset(abs, 0, sizeof(abs));
1176         abs[0].value = ABS_X;
1177         abs[0].maximum = 1000;
1178         abs[1].value = ABS_MT_POSITION_X;
1179         abs[1].maximum = 1000;
1180
1181         abs[2].value = ABS_Y;
1182         abs[2].maximum = 1000;
1183         abs[3].value = ABS_MT_POSITION_Y;
1184         abs[3].maximum = 1000;
1185
1186         abs[4].value = ABS_MT_SLOT;
1187         abs[4].maximum = 2;
1188
1189         rc = test_create_abs_device(&uidev, &dev,
1190                                     5, abs,
1191                                     EV_SYN, SYN_REPORT,
1192                                     -1);
1193         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1194
1195         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_X, 1), 0);
1196         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_Y, 2), 0);
1197         ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
1198         ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_Y, 4), 0);
1199
1200         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
1201         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 2);
1202         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 3);
1203         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 4);
1204
1205         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_SLOT, 1), 0);
1206         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_SLOT), 1);
1207         ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1208
1209         uinput_device_free(uidev);
1210         libevdev_free(dev);
1211 }
1212 END_TEST
1213
1214 START_TEST(test_event_mt_value_setters_invalid)
1215 {
1216         struct uinput_device* uidev;
1217         struct libevdev *dev;
1218         int rc;
1219         struct input_absinfo abs[5];
1220
1221         memset(abs, 0, sizeof(abs));
1222         abs[0].value = ABS_X;
1223         abs[0].maximum = 1000;
1224         abs[1].value = ABS_MT_POSITION_X;
1225         abs[1].maximum = 1000;
1226
1227         abs[2].value = ABS_Y;
1228         abs[2].maximum = 1000;
1229         abs[3].value = ABS_MT_POSITION_Y;
1230         abs[3].maximum = 1000;
1231
1232         abs[4].value = ABS_MT_SLOT;
1233         abs[4].maximum = 2;
1234
1235         rc = test_create_abs_device(&uidev, &dev,
1236                                     5, abs,
1237                                     EV_SYN, SYN_REPORT,
1238                                     -1);
1239         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1240
1241         /* invalid axis */
1242         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_Z, 1), -1);
1243         /* valid, but non-mt axis */
1244         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_X, 1), -1);
1245         /* invalid mt axis */
1246         ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_PRESSURE, 1), -1);
1247         /* invalid slot no */
1248         ck_assert_int_eq(libevdev_set_slot_value(dev, 4, ABS_X, 1), -1);
1249
1250         uinput_device_free(uidev);
1251         libevdev_free(dev);
1252 }
1253 END_TEST
1254
1255 START_TEST(test_event_mt_value_setters_current_slot)
1256 {
1257         struct uinput_device* uidev;
1258         struct libevdev *dev;
1259         int rc;
1260         struct input_absinfo abs[5];
1261
1262         memset(abs, 0, sizeof(abs));
1263         abs[0].value = ABS_X;
1264         abs[0].maximum = 1000;
1265         abs[1].value = ABS_MT_POSITION_X;
1266         abs[1].maximum = 1000;
1267
1268         abs[2].value = ABS_Y;
1269         abs[2].maximum = 1000;
1270         abs[3].value = ABS_MT_POSITION_Y;
1271         abs[3].maximum = 1000;
1272
1273         abs[4].value = ABS_MT_SLOT;
1274         abs[4].maximum = 2;
1275
1276         rc = test_create_abs_device(&uidev, &dev,
1277                                     5, abs,
1278                                     EV_SYN, SYN_REPORT,
1279                                     -1);
1280         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1281
1282         /* set_event_value/get_event_value works on the current slot */
1283
1284         ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1285         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 1), 0);
1286         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 1);
1287         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 1);
1288
1289         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
1290         ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1291         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 2), 0);
1292         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
1293         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 2);
1294
1295         /* set slot 0, but current is still slot 1 */
1296         ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
1297         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
1298
1299         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 0), 0);
1300         ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1301         ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 3);
1302
1303         uinput_device_free(uidev);
1304         libevdev_free(dev);
1305 }
1306 END_TEST
1307
1308 Suite *
1309 libevdev_events(void)
1310 {
1311         Suite *s = suite_create("libevdev event tests");
1312
1313         TCase *tc = tcase_create("event polling");
1314         tcase_add_test(tc, test_next_event);
1315         tcase_add_test(tc, test_syn_dropped_event);
1316         tcase_add_test(tc, test_double_syn_dropped_event);
1317         tcase_add_test(tc, test_event_type_filtered);
1318         tcase_add_test(tc, test_event_code_filtered);
1319         tcase_add_test(tc, test_has_event_pending);
1320         suite_add_tcase(s, tc);
1321
1322         tc = tcase_create("SYN_DROPPED deltas");
1323         tcase_add_test(tc, test_syn_delta_button);
1324         tcase_add_test(tc, test_syn_delta_abs);
1325         tcase_add_test(tc, test_syn_delta_mt);
1326         tcase_add_test(tc, test_syn_delta_led);
1327         tcase_add_test(tc, test_syn_delta_sw);
1328         suite_add_tcase(s, tc);
1329
1330         tc = tcase_create("skipped syncs");
1331         tcase_add_test(tc, test_skipped_sync);
1332         tcase_add_test(tc, test_incomplete_sync);
1333         tcase_add_test(tc, test_empty_sync);
1334         suite_add_tcase(s, tc);
1335
1336         tc = tcase_create("event values");
1337         tcase_add_test(tc, test_event_values);
1338         tcase_add_test(tc, test_event_values_invalid);
1339         tcase_add_test(tc, test_mt_event_values);
1340         tcase_add_test(tc, test_mt_event_values_invalid);
1341         tcase_add_test(tc, test_ev_rep_values);
1342         suite_add_tcase(s, tc);
1343
1344         tc = tcase_create("event value setters");
1345         tcase_add_test(tc, test_event_value_setters);
1346         tcase_add_test(tc, test_event_value_setters_invalid);
1347         tcase_add_test(tc, test_event_mt_value_setters);
1348         tcase_add_test(tc, test_event_mt_value_setters_invalid);
1349         tcase_add_test(tc, test_event_mt_value_setters_current_slot);
1350         suite_add_tcase(s, tc);
1351
1352         return s;
1353 }
1354