2 * Copyright © 2013 Red Hat, Inc.
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.
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
24 #include <linux/input.h>
30 #include "test-common.h"
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, */
40 START_TEST(test_has_ev_bit)
45 struct uinput_device* uidev;
49 rc = test_create_device(&uidev, &dev,
52 ck_assert_msg(rc == 0, "%s: Failed to create device with: %s",
53 libevdev_get_event_type_name(*evbit),
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);
59 for (i = 0; i <= EV_MAX; i++) {
60 if (i == EV_SYN || i == *evbit)
63 ck_assert_msg(!libevdev_has_event_type(dev, i), "for event type %d\n", i);
67 uinput_device_free(uidev);
74 START_TEST(test_ev_bit_limits)
79 struct uinput_device* uidev;
83 rc = test_create_device(&uidev, &dev,
86 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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);
93 uinput_device_free(uidev);
100 START_TEST(test_event_codes)
104 while(*evbit != -1) {
105 struct uinput_device* uidev;
106 struct libevdev *dev;
109 if (*evbit == EV_SYN) {
114 max = libevdev_get_event_type_max(*evbit);
116 for (code = 1; code < max; code += 10) {
117 rc = test_create_device(&uidev, &dev,
120 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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");
126 ck_assert_msg(!libevdev_has_event_code(dev, EV_PWR, 0), "for EV_PWR");
129 uinput_device_free(uidev);
137 START_TEST(test_event_code_limits)
141 while(*evbit != -1) {
142 struct uinput_device* uidev;
143 struct libevdev *dev;
147 if (*evbit == EV_SYN) {
152 max = libevdev_get_event_type_max(*evbit);
153 ck_assert(max != -1);
155 rc = test_create_device(&uidev, &dev,
158 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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);
165 uinput_device_free(uidev);
172 START_TEST(test_ev_rep)
174 struct uinput_device* uidev;
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,
182 ck_assert_int_eq(rc, -EINVAL);
186 START_TEST(test_ev_rep_values)
188 struct uinput_device* uidev;
189 struct libevdev *dev;
191 int delay = 0xab, period = 0xbc;
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));
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);
203 ck_assert_int_eq(delay, 0xab);
204 ck_assert_int_eq(period, 0xbc);
206 uinput_device_free(uidev);
211 START_TEST(test_input_props)
213 struct uinput_device* uidev;
214 struct libevdev *dev;
217 uidev = uinput_device_new(TEST_DEVICE_NAME);
218 rc = uinput_device_set_event_bits(uidev,
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));
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));
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);
235 ck_assert_int_eq(libevdev_has_property(dev, i), 0);
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);
241 uinput_device_free(uidev);
246 START_TEST(test_set_input_props)
248 struct uinput_device* uidev;
249 struct libevdev *dev;
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);
259 uidev = uinput_device_new(TEST_DEVICE_NAME);
260 rc = uinput_device_set_event_bits(uidev,
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));
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));
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);
275 uinput_device_free(uidev);
280 START_TEST(test_slot_init_value)
282 struct uinput_device *uidev;
283 struct libevdev *dev;
286 struct input_absinfo abs[nabs];
290 uidev = uinput_device_new(TEST_DEVICE_NAME);
291 rc = uinput_device_set_event_bits(uidev,
295 EV_ABS, ABS_MT_TRACKING_ID,
296 EV_ABS, ABS_MT_POSITION_X,
297 EV_ABS, ABS_MT_POSITION_Y,
299 ck_assert_int_eq(rc, 0);
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;
307 abs[2].value = ABS_Y;
308 abs[2].maximum = 1000;
309 abs[3].value = ABS_MT_POSITION_Y;
310 abs[3].maximum = 1000;
312 abs[4].value = ABS_MT_SLOT;
314 abs[5].value = ABS_MT_TRACKING_ID;
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);
323 rc = uinput_device_create(uidev);
324 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
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));
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);
344 rc = libevdev_new_from_fd(fd, &dev);
345 ck_assert_int_eq(rc, 0);
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);
353 uinput_device_free(uidev);
358 START_TEST(test_no_slots)
360 struct uinput_device* uidev;
361 struct libevdev *dev;
363 rc = test_create_device(&uidev, &dev,
366 EV_ABS, ABS_MT_POSITION_X,
367 EV_ABS, ABS_MT_POSITION_Y,
369 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
371 ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
372 ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
374 uinput_device_free(uidev);
379 START_TEST(test_slot_number)
381 struct uinput_device* uidev;
382 struct libevdev *dev;
385 rc = test_create_device(&uidev, &dev,
388 EV_ABS, ABS_MT_POSITION_X,
389 EV_ABS, ABS_MT_POSITION_Y,
392 ck_assert_msg(rc == 0, "Failed to uinput device: %s", strerror(-rc));
394 ck_assert_int_eq(libevdev_get_num_slots(dev), 1);
395 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
397 uinput_device_free(uidev);
403 START_TEST(test_device_name)
405 struct uinput_device* uidev;
406 struct libevdev *dev;
407 struct input_id ids = {1, 2, 3, 4};
411 dev = libevdev_new();
413 str = libevdev_get_name(dev);
414 ck_assert(str != NULL);
415 ck_assert_int_eq(strlen(str), 0);
417 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
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));;
424 str = libevdev_get_name(dev);
425 ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
427 str = libevdev_get_phys(dev);
428 ck_assert(str == NULL);
430 str = libevdev_get_uniq(dev);
431 ck_assert(str == NULL);
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);
439 uinput_device_free(uidev);
444 START_TEST(test_device_set_name)
446 struct uinput_device* uidev;
447 struct libevdev *dev;
448 struct input_id ids = {1, 2, 3, 4};
452 dev = libevdev_new();
454 libevdev_set_name(dev, "the name");
455 libevdev_set_phys(dev, "the phys");
456 libevdev_set_uniq(dev, "the uniq");
458 str = libevdev_get_name(dev);
459 ck_assert(str != NULL);
460 ck_assert_int_eq(strcmp(str, "the name"), 0);
462 str = libevdev_get_phys(dev);
463 ck_assert(str != NULL);
464 ck_assert_int_eq(strcmp(str, "the phys"), 0);
466 str = libevdev_get_uniq(dev);
467 ck_assert(str != NULL);
468 ck_assert_int_eq(strcmp(str, "the uniq"), 0);
470 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
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));;
477 str = libevdev_get_name(dev);
478 ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
480 str = libevdev_get_phys(dev);
481 ck_assert(str == NULL);
483 str = libevdev_get_uniq(dev);
484 ck_assert(str == NULL);
486 uinput_device_free(uidev);
491 START_TEST(test_device_set_ids)
493 struct uinput_device* uidev;
494 struct libevdev *dev;
495 struct input_id ids = {1, 2, 3, 4};
498 dev = libevdev_new();
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);
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);
510 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
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));;
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);
522 uinput_device_free(uidev);
527 START_TEST(test_device_get_abs_info)
529 struct uinput_device* uidev;
530 struct libevdev *dev;
531 struct input_absinfo abs;
532 const struct input_absinfo *a;
535 uidev = uinput_device_new(TEST_DEVICE_NAME);
536 ck_assert(uidev != NULL);
546 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
547 uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_X, &abs);
556 uinput_device_set_abs_bit(uidev, ABS_Y, &abs);
557 uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_Y, &abs);
559 rc = uinput_device_create(uidev);
560 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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));;
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));
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);
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);
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);
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);
624 uinput_device_free(uidev);
629 START_TEST(test_device_set_abs)
631 struct uinput_device* uidev;
632 struct libevdev *dev;
633 struct input_absinfo abs[2];
634 struct input_absinfo a;
637 memset(abs, 0, sizeof(abs));
638 abs[0].value = ABS_X;
639 abs[0].maximum = 1000;
641 abs[1].value = ABS_Y;
642 abs[1].maximum = 1000;
644 rc = test_create_abs_device(&uidev, &dev,
648 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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);
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);
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);
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);
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);
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);
684 libevdev_set_abs_minimum(dev, ABS_Z, 10);
685 ck_assert_int_eq(libevdev_has_event_code(dev, EV_ABS, ABS_Z), 0);
687 uinput_device_free(uidev);
693 START_TEST(test_device_enable_bit)
695 struct uinput_device* uidev;
696 struct libevdev *dev, *dev2;
697 struct input_absinfo abs;
700 rc = test_create_device(&uidev, &dev,
703 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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));
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));
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));
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));
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));
734 uinput_device_free(uidev);
739 START_TEST(test_device_enable_bit_invalid)
741 struct uinput_device* uidev;
742 struct libevdev *dev;
743 struct input_absinfo abs = {0};
746 rc = test_create_device(&uidev, &dev,
749 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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);
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);
759 uinput_device_free(uidev);
764 START_TEST(test_device_disable_bit)
766 struct uinput_device* uidev;
767 struct libevdev *dev, *dev2;
770 rc = test_create_device(&uidev, &dev,
776 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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));
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));
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));
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));
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));
807 uinput_device_free(uidev);
812 START_TEST(test_device_disable_bit_invalid)
814 struct uinput_device* uidev;
815 struct libevdev *dev;
818 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, DEFAULT_IDS,
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));
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);
831 uinput_device_free(uidev);
836 START_TEST(test_device_kernel_change_axis)
838 struct uinput_device* uidev;
839 struct libevdev *dev, *dev2;
840 struct input_absinfo abs;
843 uidev = uinput_device_new(TEST_DEVICE_NAME);
844 ck_assert(uidev != NULL);
853 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
855 rc = uinput_device_create(uidev);
856 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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));;
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);
872 rc = libevdev_kernel_set_abs_value(dev, ABS_X, &abs);
873 ck_assert_int_eq(rc, 0);
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);
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);
892 uinput_device_free(uidev);
896 START_TEST(test_device_kernel_change_axis_invalid)
898 struct uinput_device* uidev;
899 struct libevdev *dev;
900 struct input_absinfo abs;
903 uidev = uinput_device_new(TEST_DEVICE_NAME);
904 ck_assert(uidev != NULL);
910 /* abs.resolution = 3; FIXME: can't test resolution */
913 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
915 rc = uinput_device_create(uidev);
916 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
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));;
921 rc = libevdev_kernel_set_abs_value(dev, ABS_MAX + 1, &abs);
922 ck_assert_int_eq(rc, -EINVAL);
925 uinput_device_free(uidev);
930 libevdev_has_event_test(void)
932 Suite *s = suite_create("libevdev_has_event tests");
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);
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);
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);
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);
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);
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);
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);