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