test/test-libevdev-has-event.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 <limits.h>
  28 #include <fcntl.h>
  29
  30 #include "test-common.h"
  31
  32 static int evbits[] = {
  33         EV_SYN, EV_KEY, EV_REL, EV_ABS, EV_MSC,
  34         EV_SW, EV_LED, EV_SND, EV_FF,
  35         /* Intentionally skipping these, they're different
  36          * EV_PWR, EV_FF_STATUS, EV_REP, */
  37         -1,
  38 };
  39
  40 START_TEST(test_has_ev_bit)
  41 {
  42         int *evbit = evbits;
  43
  44         while(*evbit != -1) {
  45                 struct uinput_device* uidev;
  46                 struct libevdev *dev;
  47                 int i;
  48
  49                 if (*evbit == EV_ABS) {
  50                         struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
  51                         test_create_abs_device(&uidev, &dev,
  52                                                1, &abs,
  53                                                -1);
  54                 } else
  55                         test_create_device(&uidev, &dev,
  56                                            *evbit, 0,
  57                                            -1);
  58
  59                 ck_assert_msg(libevdev_has_event_type(dev, EV_SYN), "for event type %d\n", *evbit);
  60                 ck_assert_msg(libevdev_has_event_type(dev, *evbit), "for event type %d\n", *evbit);
  61
  62                 for (i = 0; i <= EV_MAX; i++) {
  63                         if (i == EV_SYN || i == *evbit)
  64                                 continue;
  65
  66                         ck_assert_msg(!libevdev_has_event_type(dev, i), "for event type %d\n", i);
  67                 }
  68
  69                 libevdev_free(dev);
  70                 uinput_device_free(uidev);
  71
  72                 evbit++;
  73         }
  74 }
  75 END_TEST
  76
  77 START_TEST(test_ev_bit_limits)
  78 {
  79         int *evbit = evbits;
  80
  81         while(*evbit != -1) {
  82                 struct uinput_device* uidev;
  83                 struct libevdev *dev;
  84
  85                 if (*evbit == EV_ABS) {
  86                         struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
  87                         test_create_abs_device(&uidev, &dev,
  88                                                1, &abs,
  89                                                -1);
  90                 } else
  91                         test_create_device(&uidev, &dev,
  92                                            *evbit, 0,
  93                                            -1);
  94
  95                 ck_assert_int_eq(libevdev_has_event_type(dev, EV_MAX + 1), 0);
  96                 ck_assert_int_eq(libevdev_has_event_type(dev, INT_MAX), 0);
  97                 ck_assert_int_eq(libevdev_has_event_type(dev, UINT_MAX), 0);
  98
  99                 libevdev_free(dev);
 100                 uinput_device_free(uidev);
 101
 102                 evbit++;
 103         }
 104 }
 105 END_TEST
 106
 107 START_TEST(test_event_codes)
 108 {
 109         int *evbit = evbits;
 110
 111         while(*evbit != -1) {
 112                 struct uinput_device* uidev;
 113                 struct libevdev *dev;
 114                 int code, max;
 115                 if (*evbit == EV_SYN) {
 116                         evbit++;
 117                         continue;
 118                 }
 119
 120                 max = libevdev_event_type_get_max(*evbit);
 121
 122                 for (code = 1; code < max; code += 10) {
 123                         if (*evbit == EV_ABS) {
 124                                 struct input_absinfo abs = { code, 0, 2, 0, 0, 0};
 125                                 test_create_abs_device(&uidev, &dev,
 126                                                        1, &abs,
 127                                                        -1);
 128                         } else
 129                                 test_create_device(&uidev, &dev,
 130                                                    *evbit, code,
 131                                                    -1);
 132
 133                         ck_assert_msg(libevdev_has_event_type(dev, *evbit), "for event type %d\n", *evbit);
 134                         ck_assert_msg(libevdev_has_event_code(dev, *evbit, code), "for type %d code %d", *evbit, code);
 135                         ck_assert_msg(libevdev_has_event_code(dev, EV_SYN, SYN_REPORT), "for EV_SYN");
 136                         /* always false */
 137                         ck_assert_msg(!libevdev_has_event_code(dev, EV_PWR, 0), "for EV_PWR");
 138
 139                         libevdev_free(dev);
 140                         uinput_device_free(uidev);
 141                 }
 142
 143                 evbit++;
 144         }
 145 }
 146 END_TEST
 147
 148 START_TEST(test_event_code_limits)
 149 {
 150         int *evbit = evbits;
 151
 152         while(*evbit != -1) {
 153                 struct uinput_device* uidev;
 154                 struct libevdev *dev;
 155                 int max;
 156
 157                 if (*evbit == EV_SYN) {
 158                         evbit++;
 159                         continue;
 160                 }
 161
 162                 max = libevdev_event_type_get_max(*evbit);
 163                 ck_assert(max != -1);
 164
 165                 if (*evbit == EV_ABS) {
 166                         struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
 167                         test_create_abs_device(&uidev, &dev,
 168                                                1, &abs,
 169                                                -1);
 170                 } else
 171                         test_create_device(&uidev, &dev,
 172                                            *evbit, 1,
 173                                            -1);
 174
 175                 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, max), "for type %d code %d", *evbit, max);
 176                 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, INT_MAX), "for type %d code %d", *evbit, INT_MAX);
 177                 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, UINT_MAX), "for type %d code %d", *evbit, UINT_MAX);
 178
 179                 libevdev_free(dev);
 180                 uinput_device_free(uidev);
 181
 182                 evbit++;
 183         }
 184 }
 185 END_TEST
 186
 187 START_TEST(test_ev_rep)
 188 {
 189         struct libevdev *dev;
 190         struct uinput_device* uidev;
 191         int rc;
 192         int rep, delay;
 193         const int KERNEL_DEFAULT_REP = 250;
 194         const int KERNEL_DEFAULT_DELAY = 33;
 195
 196         /* EV_REP is special, it's always fully set if set at all,
 197            can't test this through uinput though */
 198         uidev = uinput_device_new(TEST_DEVICE_NAME);
 199         ck_assert(uidev != NULL);
 200         rc = uinput_device_set_bit(uidev, EV_REP);
 201         ck_assert_int_eq(rc, 0);
 202
 203         rc = uinput_device_create(uidev);
 204         ck_assert_int_eq(rc, 0);
 205
 206         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
 207         ck_assert_int_eq(rc, 0);
 208
 209         ck_assert_int_eq(libevdev_has_event_type(dev, EV_REP), 1);
 210         ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_DELAY), 1);
 211         ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_PERIOD), 1);
 212
 213         ck_assert_int_eq(libevdev_get_repeat(dev, &rep, &delay), 0);
 214         /* default values as set by the kernel,
 215            see drivers/input/input.c:input_register_device() */
 216         ck_assert_int_eq(rep, KERNEL_DEFAULT_REP);
 217         ck_assert_int_eq(delay, KERNEL_DEFAULT_DELAY);
 218
 219         libevdev_free(dev);
 220         uinput_device_free(uidev);
 221 }
 222 END_TEST
 223
 224 START_TEST(test_ev_rep_values)
 225 {
 226         struct uinput_device* uidev;
 227         struct libevdev *dev;
 228         int delay = 0xab, period = 0xbc;
 229
 230         /* EV_REP is special, it's always fully set if set at all, can't set
 231            it through uinput though. */
 232         test_create_device(&uidev, &dev, -1);
 233
 234         ck_assert_int_eq(libevdev_get_repeat(dev, NULL, NULL), -1);
 235         ck_assert_int_eq(libevdev_get_repeat(dev, &delay, NULL), -1);
 236         ck_assert_int_eq(libevdev_get_repeat(dev, NULL, &period), -1);
 237         ck_assert_int_eq(libevdev_get_repeat(dev, &delay, &period), -1);
 238
 239         ck_assert_int_eq(delay, 0xab);
 240         ck_assert_int_eq(period, 0xbc);
 241
 242         uinput_device_free(uidev);
 243         libevdev_free(dev);
 244 }
 245 END_TEST
 246
 247 START_TEST(test_input_props)
 248 {
 249         struct uinput_device* uidev;
 250         struct libevdev *dev;
 251         int rc, i;
 252         struct input_absinfo abs = {0, 0, 2, 0, 0};
 253
 254         uidev = uinput_device_new(TEST_DEVICE_NAME);
 255         rc = uinput_device_set_abs_bit(uidev, ABS_X, &abs);
 256         ck_assert_int_eq(rc, 0);
 257         uinput_device_set_prop(uidev, INPUT_PROP_DIRECT);
 258         uinput_device_set_prop(uidev, INPUT_PROP_BUTTONPAD);
 259         rc = uinput_device_create(uidev);
 260         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 261
 262         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
 263         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 264
 265
 266         for (i = 0; i < INPUT_PROP_CNT; i++) {
 267                 if (i == INPUT_PROP_DIRECT || i == INPUT_PROP_BUTTONPAD)
 268                         ck_assert_int_eq(libevdev_has_property(dev, i), 1);
 269                 else
 270                         ck_assert_int_eq(libevdev_has_property(dev, i), 0);
 271         }
 272
 273         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_MAX + 1), 0);
 274         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_MAX), 0);
 275
 276         uinput_device_free(uidev);
 277         libevdev_free(dev);
 278 }
 279 END_TEST
 280
 281 START_TEST(test_set_input_props)
 282 {
 283         struct uinput_device* uidev;
 284         struct libevdev *dev;
 285         int rc, fd;
 286         struct input_absinfo abs = {0, 0, 2, 0, 0};
 287
 288         dev = libevdev_new();
 289         ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_MAX + 1), -1);
 290         ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_DIRECT), 0);
 291         ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD), 0);
 292         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_DIRECT), 1);
 293         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_BUTTONPAD), 1);
 294
 295         uidev = uinput_device_new(TEST_DEVICE_NAME);
 296         rc = uinput_device_set_abs_bit(uidev, ABS_X, &abs);
 297         ck_assert_int_eq(rc, 0);
 298         uinput_device_set_prop(uidev, INPUT_PROP_BUTTONPAD);
 299         rc = uinput_device_create(uidev);
 300         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 301
 302         fd = uinput_device_get_fd(uidev);
 303         rc = libevdev_set_fd(dev, fd);
 304         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 305
 306         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_DIRECT), 0);
 307         ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_BUTTONPAD), 1);
 308
 309         uinput_device_free(uidev);
 310         libevdev_free(dev);
 311 }
 312 END_TEST
 313
 314 START_TEST(test_slot_init_value)
 315 {
 316         struct uinput_device *uidev;
 317         struct libevdev *dev;
 318         int rc;
 319         const int nabs = 6;
 320         int i;
 321         int fd;
 322         struct input_absinfo abs[] = { { ABS_X, 0, 1000 },
 323                                        { ABS_Y, 0, 1000 },
 324                                        { ABS_MT_POSITION_X, 0, 1000 },
 325                                        { ABS_MT_POSITION_Y, 0, 1000 },
 326                                        { ABS_MT_TRACKING_ID, -1, 2 },
 327                                        { ABS_MT_SLOT, 0, 1 }};
 328
 329         uidev = uinput_device_new(TEST_DEVICE_NAME);
 330
 331         for (i = 0; i < nabs; i++) {
 332                 rc = uinput_device_set_abs_bit(uidev, abs[i].value, &abs[i]);
 333                 ck_assert_int_eq(rc, 0);
 334         }
 335
 336         rc = uinput_device_create(uidev);
 337         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 338
 339         fd = uinput_device_get_fd(uidev);
 340         rc = fcntl(fd, F_SETFL, O_NONBLOCK);
 341         ck_assert_msg(rc == 0, "fcntl failed: %s", strerror(errno));
 342
 343         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
 344         uinput_device_event(uidev, EV_ABS, ABS_X, 100);
 345         uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
 346         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
 347         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
 348         uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
 349         uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
 350         uinput_device_event(uidev, EV_ABS, ABS_X, 1);
 351         uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
 352         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
 353         uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
 354         uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
 355         uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
 356
 357         rc = libevdev_new_from_fd(fd, &dev);
 358         ck_assert_int_eq(rc, 0);
 359
 360         ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
 361         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
 362         ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
 363         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
 364         ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
 365
 366         uinput_device_free(uidev);
 367         libevdev_free(dev);
 368 }
 369 END_TEST
 370
 371 START_TEST(test_no_slots)
 372 {
 373         struct uinput_device* uidev;
 374         struct libevdev *dev;
 375         struct input_absinfo abs[] = {  { ABS_X, 0, 2 },
 376                                         { ABS_Y, 0, 2 },
 377                                         { ABS_MT_POSITION_X, 0, 2 },
 378                                         { ABS_MT_POSITION_Y, 0, 2 }};
 379
 380         test_create_abs_device(&uidev, &dev, 4, abs,
 381                                -1);
 382
 383         ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
 384         ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
 385
 386         uinput_device_free(uidev);
 387         libevdev_free(dev);
 388 }
 389 END_TEST
 390
 391 START_TEST(test_slot_number)
 392 {
 393         struct uinput_device* uidev;
 394         struct libevdev *dev;
 395         const int nslots = 4;
 396         struct input_absinfo abs[] = {  { ABS_X, 0, 2 },
 397                                         { ABS_Y, 0, 2 },
 398                                         { ABS_MT_POSITION_X, 0, 2 },
 399                                         { ABS_MT_POSITION_Y, 0, 2 },
 400                                         { ABS_MT_SLOT, 0, nslots - 1 }};
 401
 402         test_create_abs_device(&uidev, &dev, 5, abs,
 403                                -1);
 404
 405         ck_assert_int_eq(libevdev_get_num_slots(dev), nslots);
 406         ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
 407
 408         uinput_device_free(uidev);
 409         libevdev_free(dev);
 410 }
 411 END_TEST
 412
 413 START_TEST(test_invalid_mt_device)
 414 {
 415         struct uinput_device* uidev;
 416         struct libevdev *dev;
 417         const int nslots = 4;
 418         int value;
 419         struct input_absinfo abs[] = {  { ABS_X, 0, 2 },
 420                 { ABS_Y, 0, 2 },
 421                 { ABS_MT_POSITION_X, 0, 2 },
 422                 { ABS_MT_POSITION_Y, 0, 2 },
 423                 { ABS_MT_SLOT - 1, 0, 2 },
 424                 { ABS_MT_SLOT, 0, nslots - 1 }};
 425
 426         test_create_abs_device(&uidev, &dev, 6, abs,
 427                                -1);
 428
 429         ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
 430         ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
 431         ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 0), -1);
 432         ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 0);
 433
 434         ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT - 1));
 435         ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT));
 436
 437         ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
 438         ck_assert(libevdev_get_event_value(dev, EV_ABS, ABS_MT_SLOT) == 1);
 439
 440         uinput_device_free(uidev);
 441         libevdev_free(dev);
 442 }
 443 END_TEST
 444
 445 START_TEST(test_device_name)
 446 {
 447         struct uinput_device* uidev;
 448         struct libevdev *dev;
 449         struct input_id ids = {1, 2, 3, 4};
 450         const char *str;
 451         int rc;
 452
 453         dev = libevdev_new();
 454
 455         str = libevdev_get_name(dev);
 456         ck_assert(str != NULL);
 457         ck_assert_int_eq(strlen(str), 0);
 458
 459         rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
 460                                            EV_REL, REL_X,
 461                                            -1);
 462         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 463         rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
 464         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 465
 466         str = libevdev_get_name(dev);
 467         ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
 468
 469         str = libevdev_get_phys(dev);
 470         ck_assert(str == NULL);
 471
 472         str = libevdev_get_uniq(dev);
 473         ck_assert(str == NULL);
 474
 475         ck_assert_int_eq(libevdev_get_id_bustype(dev), ids.bustype);
 476         ck_assert_int_eq(libevdev_get_id_vendor(dev), ids.vendor);
 477         ck_assert_int_eq(libevdev_get_id_product(dev), ids.product);
 478         ck_assert_int_eq(libevdev_get_id_version(dev), ids.version);
 479         ck_assert_int_eq(libevdev_get_driver_version(dev), EV_VERSION);
 480
 481         uinput_device_free(uidev);
 482         libevdev_free(dev);
 483 }
 484 END_TEST
 485
 486 START_TEST(test_device_set_name)
 487 {
 488         struct uinput_device* uidev;
 489         struct libevdev *dev;
 490         struct input_id ids = {1, 2, 3, 4};
 491         const char *str;
 492         int rc;
 493
 494         dev = libevdev_new();
 495
 496         libevdev_set_name(dev, "the name");
 497         libevdev_set_phys(dev, "the phys");
 498         libevdev_set_uniq(dev, "the uniq");
 499
 500         str = libevdev_get_name(dev);
 501         ck_assert(str != NULL);
 502         ck_assert_int_eq(strcmp(str, "the name"), 0);
 503
 504         str = libevdev_get_phys(dev);
 505         ck_assert(str != NULL);
 506         ck_assert_int_eq(strcmp(str, "the phys"), 0);
 507
 508         str = libevdev_get_uniq(dev);
 509         ck_assert(str != NULL);
 510         ck_assert_int_eq(strcmp(str, "the uniq"), 0);
 511
 512         rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
 513                                            EV_REL, REL_X,
 514                                            -1);
 515         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 516         rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
 517         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 518
 519         str = libevdev_get_name(dev);
 520         ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
 521
 522         str = libevdev_get_phys(dev);
 523         ck_assert(str == NULL);
 524
 525         str = libevdev_get_uniq(dev);
 526         ck_assert(str == NULL);
 527
 528         uinput_device_free(uidev);
 529         libevdev_free(dev);
 530 }
 531 END_TEST
 532
 533 START_TEST(test_device_set_ids)
 534 {
 535         struct uinput_device* uidev;
 536         struct libevdev *dev;
 537         struct input_id ids = {1, 2, 3, 4};
 538         int rc;
 539
 540         dev = libevdev_new();
 541
 542         libevdev_set_id_product(dev, 10);
 543         libevdev_set_id_vendor(dev, 20);
 544         libevdev_set_id_bustype(dev, 30);
 545         libevdev_set_id_version(dev, 40);
 546
 547         ck_assert_int_eq(libevdev_get_id_product(dev), 10);
 548         ck_assert_int_eq(libevdev_get_id_vendor(dev), 20);
 549         ck_assert_int_eq(libevdev_get_id_bustype(dev), 30);
 550         ck_assert_int_eq(libevdev_get_id_version(dev), 40);
 551
 552         rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
 553                                            EV_REL, REL_X,
 554                                            -1);
 555         ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
 556         rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
 557         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 558
 559         ck_assert_int_eq(libevdev_get_id_bustype(dev), ids.bustype);
 560         ck_assert_int_eq(libevdev_get_id_vendor(dev), ids.vendor);
 561         ck_assert_int_eq(libevdev_get_id_product(dev), ids.product);
 562         ck_assert_int_eq(libevdev_get_id_version(dev), ids.version);
 563
 564         uinput_device_free(uidev);
 565         libevdev_free(dev);
 566 }
 567 END_TEST
 568
 569 START_TEST(test_device_get_abs_info)
 570 {
 571         struct uinput_device* uidev;
 572         struct libevdev *dev;
 573         struct input_absinfo abs;
 574         const struct input_absinfo *a;
 575         int rc;
 576
 577         uidev = uinput_device_new(TEST_DEVICE_NAME);
 578         ck_assert(uidev != NULL);
 579
 580
 581         abs.minimum = 0;
 582         abs.maximum = 1000;
 583         abs.fuzz = 1;
 584         abs.flat = 2;
 585         abs.resolution = 3;
 586         abs.value = 0;
 587
 588         uinput_device_set_abs_bit(uidev, ABS_X, &abs);
 589         uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_X, &abs);
 590
 591         abs.minimum = -500;
 592         abs.maximum = 500;
 593         abs.fuzz = 10;
 594         abs.flat = 20;
 595         abs.resolution = 30;
 596         abs.value = 0;
 597
 598         uinput_device_set_abs_bit(uidev, ABS_Y, &abs);
 599         uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_Y, &abs);
 600
 601         rc = uinput_device_create(uidev);
 602         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 603
 604         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
 605         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 606
 607         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MAX + 1), 0);
 608         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MAX + 1), 0);
 609         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MAX + 1), 0);
 610         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MAX + 1), 0);
 611         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MAX + 1), 0);
 612         ck_assert(!libevdev_get_abs_info(dev, ABS_MAX + 1));
 613
 614         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
 615         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
 616         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
 617         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
 618         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
 619         a = libevdev_get_abs_info(dev, ABS_X);
 620         ck_assert(a != NULL);
 621         ck_assert_int_eq(a->minimum, 0);
 622         ck_assert_int_eq(a->maximum, 1000);
 623         ck_assert_int_eq(a->fuzz, 1);
 624         ck_assert_int_eq(a->flat, 2);
 625         ck_assert_int_eq(a->resolution, 3);
 626
 627         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_X), 0);
 628         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_X), 1000);
 629         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_X), 1);
 630         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_X), 2);
 631         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_X), 3);
 632         a = libevdev_get_abs_info(dev, ABS_MT_POSITION_X);
 633         ck_assert(a != NULL);
 634         ck_assert_int_eq(a->minimum, 0);
 635         ck_assert_int_eq(a->maximum, 1000);
 636         ck_assert_int_eq(a->fuzz, 1);
 637         ck_assert_int_eq(a->flat, 2);
 638         ck_assert_int_eq(a->resolution, 3);
 639
 640         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_Y), -500);
 641         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_Y), 500);
 642         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_Y), 10);
 643         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_Y), 20);
 644         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_Y), 30);
 645         a = libevdev_get_abs_info(dev, ABS_Y);
 646         ck_assert(a != NULL);
 647         ck_assert_int_eq(a->minimum, -500);
 648         ck_assert_int_eq(a->maximum, 500);
 649         ck_assert_int_eq(a->fuzz, 10);
 650         ck_assert_int_eq(a->flat, 20);
 651         ck_assert_int_eq(a->resolution, 30);
 652
 653         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_Y), -500);
 654         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_Y), 500);
 655         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_Y), 10);
 656         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_Y), 20);
 657         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_Y), 30);
 658         a = libevdev_get_abs_info(dev, ABS_MT_POSITION_Y);
 659         ck_assert(a != NULL);
 660         ck_assert_int_eq(a->minimum, -500);
 661         ck_assert_int_eq(a->maximum, 500);
 662         ck_assert_int_eq(a->fuzz, 10);
 663         ck_assert_int_eq(a->flat, 20);
 664         ck_assert_int_eq(a->resolution, 30);
 665
 666         uinput_device_free(uidev);
 667         libevdev_free(dev);
 668 }
 669 END_TEST
 670
 671 START_TEST(test_device_set_abs)
 672 {
 673         struct uinput_device* uidev;
 674         struct libevdev *dev;
 675         struct input_absinfo abs[2];
 676         struct input_absinfo a;
 677
 678         memset(abs, 0, sizeof(abs));
 679         abs[0].value = ABS_X;
 680         abs[0].maximum = 1000;
 681
 682         abs[1].value = ABS_Y;
 683         abs[1].maximum = 1000;
 684
 685         test_create_abs_device(&uidev, &dev,
 686                                2, abs,
 687                                EV_SYN,
 688                                -1);
 689
 690         libevdev_set_abs_minimum(dev, ABS_X, 1);
 691         libevdev_set_abs_minimum(dev, ABS_Y, 5);
 692         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X),  1);
 693         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_Y),  5);
 694
 695         libevdev_set_abs_maximum(dev, ABS_X, 3000);
 696         libevdev_set_abs_maximum(dev, ABS_Y, 5000);
 697         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X),  3000);
 698         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_Y),  5000);
 699
 700         libevdev_set_abs_fuzz(dev, ABS_X, 3);
 701         libevdev_set_abs_fuzz(dev, ABS_Y, 5);
 702         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X),  3);
 703         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_Y),  5);
 704
 705         libevdev_set_abs_flat(dev, ABS_X, 8);
 706         libevdev_set_abs_flat(dev, ABS_Y, 15);
 707         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X),  8);
 708         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_Y),  15);
 709
 710         libevdev_set_abs_resolution(dev, ABS_X, 80);
 711         libevdev_set_abs_resolution(dev, ABS_Y, 150);
 712         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X),  80);
 713         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_Y),  150);
 714
 715         a.value = 0;
 716         a.minimum = 10;
 717         a.maximum = 100;
 718         a.fuzz = 13;
 719         a.flat = 1;
 720         a.resolution = 16;
 721
 722         libevdev_set_abs_info(dev, ABS_X, &a);
 723         ck_assert_int_eq(memcmp(&a, libevdev_get_abs_info(dev, ABS_X), sizeof(a)), 0);
 724
 725         libevdev_set_abs_minimum(dev, ABS_Z, 10);
 726         ck_assert_int_eq(libevdev_has_event_code(dev, EV_ABS, ABS_Z),  0);
 727
 728         uinput_device_free(uidev);
 729         libevdev_free(dev);
 730 }
 731 END_TEST
 732
 733 START_TEST(test_device_enable_bit)
 734 {
 735         struct uinput_device* uidev;
 736         struct libevdev *dev, *dev2;
 737         struct input_absinfo abs = {ABS_X, 0, 2};
 738         int rc;
 739
 740         test_create_abs_device(&uidev, &dev, 1, &abs,
 741                                -1);
 742
 743         ck_assert(!libevdev_has_event_code(dev, EV_ABS, ABS_Y));
 744         ck_assert(!libevdev_has_event_type(dev, EV_REL));
 745         ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
 746
 747         abs.minimum = 0;
 748         abs.maximum = 100;
 749         abs.fuzz = 1;
 750         abs.flat = 2;
 751         abs.resolution = 3;
 752
 753         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &abs), 0);
 754         ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_Y));
 755
 756         ck_assert_int_eq(libevdev_enable_event_type(dev, EV_REL), 0);
 757         ck_assert(libevdev_has_event_type(dev, EV_REL));
 758         ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
 759
 760         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REL, REL_X, NULL), 0);
 761         ck_assert(libevdev_has_event_code(dev, EV_REL, REL_X));
 762
 763         /* make sure kernel device is unchanged */
 764         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
 765         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
 766         ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_X));
 767         ck_assert(!libevdev_has_event_code(dev2, EV_ABS, ABS_Y));
 768         ck_assert(!libevdev_has_event_type(dev2, EV_REL));
 769         ck_assert(!libevdev_has_event_code(dev2, EV_REL, REL_X));
 770         libevdev_free(dev2);
 771
 772         uinput_device_free(uidev);
 773         libevdev_free(dev);
 774 }
 775 END_TEST
 776
 777 START_TEST(test_device_enable_bit_invalid)
 778 {
 779         struct uinput_device* uidev;
 780         struct libevdev *dev;
 781         struct input_absinfo abs = {ABS_X, 0, 1};
 782
 783         test_create_abs_device(&uidev, &dev, 1, &abs,
 784                                -1);
 785
 786         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_MAX + 1, &abs), -1);
 787         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_MAX + 1, ABS_MAX + 1, &abs), -1);
 788         ck_assert_int_eq(libevdev_enable_event_type(dev, EV_MAX + 1), -1);
 789         /* there's a gap between EV_SW and EV_LED */
 790         ck_assert_int_eq(libevdev_enable_event_type(dev, EV_LED - 1), -1);
 791         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_LED - 1, 0, NULL), -1);
 792
 793         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_Y, NULL), -1);
 794         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REP, REP_DELAY, NULL), -1);
 795         ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REL, REL_X, &abs), -1);
 796
 797         uinput_device_free(uidev);
 798         libevdev_free(dev);
 799 }
 800 END_TEST
 801
 802 START_TEST(test_device_disable_bit)
 803 {
 804         struct uinput_device* uidev;
 805         struct libevdev *dev, *dev2;
 806         int rc;
 807         struct input_absinfo abs[2] = {{ABS_X, 0, 1}, {ABS_Y, 0, 1}};
 808
 809         test_create_abs_device(&uidev, &dev,
 810                                2, abs,
 811                                EV_REL, REL_X,
 812                                EV_REL, REL_Y,
 813                                -1);
 814
 815         ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_X));
 816         ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_Y));
 817         ck_assert(libevdev_has_event_type(dev, EV_REL));
 818         ck_assert(libevdev_has_event_code(dev, EV_REL, REL_X));
 819         ck_assert(libevdev_has_event_code(dev, EV_REL, REL_Y));
 820
 821         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_ABS, ABS_Y), 0);
 822         ck_assert(!libevdev_has_event_code(dev, EV_ABS, ABS_Y));
 823
 824         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_REL, REL_X), 0);
 825         ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
 826         ck_assert(libevdev_has_event_code(dev, EV_REL, REL_Y));
 827         ck_assert(libevdev_has_event_type(dev, EV_REL));
 828
 829         ck_assert_int_eq(libevdev_disable_event_type(dev, EV_REL), 0);
 830         ck_assert(!libevdev_has_event_type(dev, EV_REL));
 831         ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
 832         ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_Y));
 833
 834         /* make sure kernel device is unchanged */
 835         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
 836         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
 837         ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_X));
 838         ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_Y));
 839         ck_assert(libevdev_has_event_type(dev2, EV_REL));
 840         ck_assert(libevdev_has_event_code(dev2, EV_REL, REL_X));
 841         ck_assert(libevdev_has_event_code(dev2, EV_REL, REL_Y));
 842         libevdev_free(dev2);
 843
 844         uinput_device_free(uidev);
 845         libevdev_free(dev);
 846 }
 847 END_TEST
 848
 849 START_TEST(test_device_disable_bit_invalid)
 850 {
 851         struct uinput_device* uidev;
 852         struct libevdev *dev;
 853         struct input_absinfo abs = {ABS_X, 0, 1};
 854
 855         test_create_abs_device(&uidev, &dev, 1, &abs, -1);
 856
 857         /* there's a gap between EV_SW and EV_LED */
 858         ck_assert_int_eq(libevdev_disable_event_type(dev, EV_LED - 1), -1);
 859         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_LED - 1, 0), -1);
 860         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_ABS, ABS_MAX + 1), -1);
 861         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_MAX + 1, ABS_MAX + 1), -1);
 862         ck_assert_int_eq(libevdev_disable_event_type(dev, EV_MAX + 1), -1);
 863         ck_assert_int_eq(libevdev_disable_event_type(dev, EV_SYN), -1);
 864         ck_assert_int_eq(libevdev_disable_event_code(dev, EV_SYN, SYN_REPORT), -1);
 865
 866         uinput_device_free(uidev);
 867         libevdev_free(dev);
 868 }
 869 END_TEST
 870
 871 START_TEST(test_device_kernel_change_axis)
 872 {
 873         struct uinput_device* uidev;
 874         struct libevdev *dev, *dev2;
 875         struct input_absinfo abs;
 876         int rc;
 877
 878         uidev = uinput_device_new(TEST_DEVICE_NAME);
 879         ck_assert(uidev != NULL);
 880
 881         abs.minimum = 0;
 882         abs.maximum = 1000;
 883         abs.fuzz = 1;
 884         abs.flat = 2;
 885         abs.resolution = 3;
 886         abs.value = 0;
 887
 888         uinput_device_set_abs_bit(uidev, ABS_X, &abs);
 889
 890         rc = uinput_device_create(uidev);
 891         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 892
 893         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
 894         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 895
 896         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
 897         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
 898         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
 899         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
 900         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
 901
 902         abs.minimum = 500;
 903         abs.maximum = 5000;
 904         abs.fuzz = 10;
 905         abs.flat = 20;
 906         abs.resolution = 30;
 907         rc = libevdev_kernel_set_abs_info(dev, ABS_X, &abs);
 908         ck_assert_int_eq(rc, 0);
 909
 910         ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 500);
 911         ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 5000);
 912         ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 10);
 913         ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 20);
 914         ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 30);
 915
 916         /* make sure kernel device is changed */
 917         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
 918         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
 919         ck_assert_int_eq(libevdev_get_abs_minimum(dev2, ABS_X), 500);
 920         ck_assert_int_eq(libevdev_get_abs_maximum(dev2, ABS_X), 5000);
 921         ck_assert_int_eq(libevdev_get_abs_fuzz(dev2, ABS_X), 10);
 922         ck_assert_int_eq(libevdev_get_abs_flat(dev2, ABS_X), 20);
 923         ck_assert_int_eq(libevdev_get_abs_resolution(dev2, ABS_X), 30);
 924         libevdev_free(dev2);
 925
 926         libevdev_free(dev);
 927         uinput_device_free(uidev);
 928 }
 929 END_TEST
 930
 931 START_TEST(test_device_kernel_change_axis_invalid)
 932 {
 933         struct uinput_device* uidev;
 934         struct libevdev *dev;
 935         struct input_absinfo abs;
 936         int rc;
 937
 938         uidev = uinput_device_new(TEST_DEVICE_NAME);
 939         ck_assert(uidev != NULL);
 940
 941         abs.minimum = 0;
 942         abs.maximum = 1000;
 943         abs.fuzz = 1;
 944         abs.flat = 2;
 945         abs.resolution = 3; /* FIXME: value is unused, we can't test resolution */
 946         abs.value = 0;
 947
 948         uinput_device_set_abs_bit(uidev, ABS_X, &abs);
 949
 950         rc = uinput_device_create(uidev);
 951         ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
 952
 953         rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
 954         ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
 955
 956         rc = libevdev_kernel_set_abs_info(dev, ABS_MAX + 1, &abs);
 957         ck_assert_int_eq(rc, -EINVAL);
 958
 959         libevdev_free(dev);
 960         uinput_device_free(uidev);
 961 }
 962 END_TEST
 963
 964 START_TEST(test_led_valid)
 965 {
 966         struct uinput_device* uidev;
 967         struct libevdev *dev;
 968         int rc;
 969
 970         test_create_device(&uidev, &dev,
 971                            EV_LED, LED_NUML,
 972                            EV_LED, LED_CAPSL,
 973                            EV_LED, LED_COMPOSE,
 974                            -1);
 975
 976         rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_ON);
 977         ck_assert_int_eq(rc, 0);
 978         rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF);
 979         ck_assert_int_eq(rc, 0);
 980
 981         rc = libevdev_kernel_set_led_values(dev,
 982                                             LED_NUML, LIBEVDEV_LED_OFF,
 983                                             LED_CAPSL, LIBEVDEV_LED_ON,
 984                                             LED_COMPOSE, LIBEVDEV_LED_OFF,
 985                                             -1);
 986         ck_assert_int_eq(rc, 0);
 987         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_NUML));
 988         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
 989         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
 990
 991         rc = libevdev_kernel_set_led_values(dev,
 992                                             LED_NUML, LIBEVDEV_LED_ON,
 993                                             LED_CAPSL, LIBEVDEV_LED_OFF,
 994                                             LED_COMPOSE, LIBEVDEV_LED_ON,
 995                                             -1);
 996         ck_assert_int_eq(rc, 0);
 997         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
 998         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
 999         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1000
1001         /* make sure we ignore unset leds */
1002         rc = libevdev_kernel_set_led_values(dev,
1003                                             LED_NUML, LIBEVDEV_LED_ON,
1004                                             LED_CAPSL, LIBEVDEV_LED_OFF,
1005                                             LED_SCROLLL, LIBEVDEV_LED_OFF,
1006                                             LED_COMPOSE, LIBEVDEV_LED_ON,
1007                                             -1);
1008         ck_assert_int_eq(rc, 0);
1009         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1010         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1011         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1012
1013         libevdev_free(dev);
1014         uinput_device_free(uidev);
1015 }
1016 END_TEST
1017
1018 START_TEST(test_led_invalid)
1019 {
1020         struct uinput_device* uidev;
1021         struct libevdev *dev;
1022         int rc;
1023
1024         test_create_device(&uidev, &dev,
1025                            EV_LED, LED_NUML,
1026                            EV_LED, LED_CAPSL,
1027                            EV_LED, LED_COMPOSE,
1028                            -1);
1029
1030         rc = libevdev_kernel_set_led_value(dev, LED_MAX + 1, LIBEVDEV_LED_ON);
1031         ck_assert_int_eq(rc, -EINVAL);
1032
1033         rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF + 1);
1034         ck_assert_int_eq(rc, -EINVAL);
1035
1036         rc = libevdev_kernel_set_led_value(dev, LED_SCROLLL, LIBEVDEV_LED_ON);
1037         ck_assert_int_eq(rc, 0);
1038
1039         rc = libevdev_kernel_set_led_values(dev,
1040                                             LED_NUML, LIBEVDEV_LED_OFF + 1,
1041                                             -1);
1042         ck_assert_int_eq(rc, -EINVAL);
1043
1044         rc = libevdev_kernel_set_led_values(dev,
1045                                             LED_MAX + 1, LIBEVDEV_LED_ON,
1046                                             LED_NUML, LIBEVDEV_LED_OFF + 1,
1047                                             -1);
1048         ck_assert_int_eq(rc, -EINVAL);
1049
1050         rc = libevdev_kernel_set_led_values(dev,
1051                                             LED_SCROLLL, LIBEVDEV_LED_OFF,
1052                                             -1);
1053         ck_assert_int_eq(rc, 0);
1054
1055         libevdev_free(dev);
1056         uinput_device_free(uidev);
1057 }
1058 END_TEST
1059
1060 START_TEST(test_led_same)
1061 {
1062         struct uinput_device* uidev;
1063         struct libevdev *dev;
1064         int rc;
1065
1066         test_create_device(&uidev, &dev,
1067                            EV_LED, LED_NUML,
1068                            EV_LED, LED_CAPSL,
1069                            EV_LED, LED_COMPOSE,
1070                            -1);
1071
1072         rc = libevdev_kernel_set_led_values(dev,
1073                                             LED_NUML, LIBEVDEV_LED_OFF,
1074                                             LED_NUML, LIBEVDEV_LED_ON,
1075                                             LED_NUML, LIBEVDEV_LED_OFF,
1076                                             LED_NUML, LIBEVDEV_LED_ON,
1077                                             LED_NUML, LIBEVDEV_LED_OFF,
1078                                             LED_NUML, LIBEVDEV_LED_ON,
1079                                             LED_NUML, LIBEVDEV_LED_OFF,
1080                                             LED_NUML, LIBEVDEV_LED_ON,
1081                                             LED_NUML, LIBEVDEV_LED_OFF,
1082                                             LED_NUML, LIBEVDEV_LED_ON,
1083                                             LED_NUML, LIBEVDEV_LED_OFF,
1084                                             LED_NUML, LIBEVDEV_LED_ON,
1085                                             LED_NUML, LIBEVDEV_LED_OFF,
1086                                             LED_NUML, LIBEVDEV_LED_ON,
1087                                             LED_NUML, LIBEVDEV_LED_OFF,
1088                                             LED_NUML, LIBEVDEV_LED_ON,
1089                                             LED_NUML, LIBEVDEV_LED_OFF,
1090                                             LED_NUML, LIBEVDEV_LED_ON,
1091                                             LED_NUML, LIBEVDEV_LED_OFF,
1092                                             LED_NUML, LIBEVDEV_LED_ON,
1093                                             LED_NUML, LIBEVDEV_LED_OFF,
1094                                             LED_NUML, LIBEVDEV_LED_ON,
1095                                             LED_NUML, LIBEVDEV_LED_OFF,
1096                                             LED_NUML, LIBEVDEV_LED_ON,
1097                                             /* more than LED_CNT */
1098                                             -1);
1099         ck_assert_int_eq(rc, 0);
1100         ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1101         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1102         ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1103
1104         libevdev_free(dev);
1105         uinput_device_free(uidev);
1106 }
1107 END_TEST
1108
1109 Suite *
1110 libevdev_has_event_test(void)
1111 {
1112         Suite *s = suite_create("libevdev_has_event tests");
1113
1114         TCase *tc = tcase_create("event type");
1115         tcase_add_test(tc, test_ev_bit_limits);
1116         tcase_add_test(tc, test_has_ev_bit);
1117         suite_add_tcase(s, tc);
1118
1119         tc = tcase_create("event codes");
1120         tcase_add_test(tc, test_event_codes);
1121         tcase_add_test(tc, test_event_code_limits);
1122         suite_add_tcase(s, tc);
1123
1124         tc = tcase_create("ev_rep");
1125         tcase_add_test(tc, test_ev_rep);
1126         tcase_add_test(tc, test_ev_rep_values);
1127         suite_add_tcase(s, tc);
1128
1129         tc = tcase_create("input properties");
1130         tcase_add_test(tc, test_input_props);
1131         tcase_add_test(tc, test_set_input_props);
1132         suite_add_tcase(s, tc);
1133
1134         tc = tcase_create("multitouch info");
1135         tcase_add_test(tc, test_no_slots);
1136         tcase_add_test(tc, test_slot_number);
1137         tcase_add_test(tc, test_slot_init_value);
1138         tcase_add_test(tc, test_invalid_mt_device);
1139         suite_add_tcase(s, tc);
1140
1141         tc = tcase_create("device info");
1142         tcase_add_test(tc, test_device_name);
1143         tcase_add_test(tc, test_device_set_name);
1144         tcase_add_test(tc, test_device_set_ids);
1145         tcase_add_test(tc, test_device_get_abs_info);
1146         suite_add_tcase(s, tc);
1147
1148         tc = tcase_create("device bit manipulation");
1149         tcase_add_test(tc, test_device_set_abs);
1150         tcase_add_test(tc, test_device_enable_bit);
1151         tcase_add_test(tc, test_device_enable_bit_invalid);
1152         tcase_add_test(tc, test_device_disable_bit);
1153         tcase_add_test(tc, test_device_disable_bit_invalid);
1154         tcase_add_test(tc, test_device_kernel_change_axis);
1155         tcase_add_test(tc, test_device_kernel_change_axis_invalid);
1156         suite_add_tcase(s, tc);
1157
1158         tc = tcase_create("led manipulation");
1159         tcase_add_test(tc, test_led_valid);
1160         tcase_add_test(tc, test_led_invalid);
1161         tcase_add_test(tc, test_led_same);
1162         suite_add_tcase(s, tc);
1163
1164         return s;
1165 }
1166