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