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