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