Lines Matching defs:dev
29 struct libevdev *dev;
34 test_create_abs_device(&uidev, &dev,
38 test_create_device(&uidev, &dev,
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);
49 ck_assert_msg(!libevdev_has_event_type(dev, i), "for event type %d\n", i);
52 libevdev_free(dev);
66 struct libevdev *dev;
70 test_create_abs_device(&uidev, &dev,
74 test_create_device(&uidev, &dev,
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);
82 libevdev_free(dev);
96 struct libevdev *dev;
116 test_create_abs_device(&uidev, &dev,
120 test_create_device(&uidev, &dev,
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");
129 ck_assert_msg(!libevdev_has_event_code(dev, EV_PWR, 0), "for EV_PWR");
131 libevdev_free(dev);
146 struct libevdev *dev;
159 test_create_abs_device(&uidev, &dev,
163 test_create_device(&uidev, &dev,
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);
171 libevdev_free(dev);
181 struct libevdev *dev;
198 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
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);
205 ck_assert_int_eq(libevdev_get_repeat(dev, &rep, &delay), 0);
211 libevdev_free(dev);
219 struct libevdev *dev;
224 test_create_device(&uidev, &dev, -1);
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);
235 libevdev_free(dev);
242 struct libevdev *dev;
254 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
259 ck_assert_int_eq(libevdev_has_property(dev, i), 1);
261 ck_assert_int_eq(libevdev_has_property(dev, i), 0);
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);
268 libevdev_free(dev);
275 struct libevdev *dev;
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);
294 rc = libevdev_set_fd(dev, fd);
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);
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);
308 libevdev_free(dev);
315 struct libevdev *dev;
357 rc = libevdev_new_from_fd(fd, &dev);
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);
367 libevdev_free(dev);
374 struct libevdev *dev;
382 test_create_abs_device(&uidev, &dev, 4, abs,
385 ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
386 ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
389 libevdev_free(dev);
396 struct libevdev *dev;
406 test_create_abs_device(&uidev, &dev, 5, abs,
409 ck_assert_int_eq(libevdev_get_num_slots(dev), nslots);
410 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
413 libevdev_free(dev);
420 struct libevdev *dev;
432 test_create_abs_device(&uidev, &dev, 6, abs,
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);
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));
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);
447 libevdev_free(dev);
454 struct libevdev *dev;
459 dev = libevdev_new();
461 str = libevdev_get_name(dev);
469 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
472 str = libevdev_get_name(dev);
475 str = libevdev_get_phys(dev);
478 str = libevdev_get_uniq(dev);
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);
488 libevdev_free(dev);
495 struct libevdev *dev;
500 dev = libevdev_new();
502 libevdev_set_name(dev, "the name");
503 libevdev_set_phys(dev, "the phys");
504 libevdev_set_uniq(dev, "the uniq");
506 str = libevdev_get_name(dev);
510 str = libevdev_get_phys(dev);
514 str = libevdev_get_uniq(dev);
522 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
525 str = libevdev_get_name(dev);
528 str = libevdev_get_phys(dev);
531 str = libevdev_get_uniq(dev);
535 libevdev_free(dev);
542 struct libevdev *dev;
546 dev = libevdev_new();
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);
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);
562 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
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);
571 libevdev_free(dev);
578 struct libevdev *dev;
609 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
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));
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);
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);
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);
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);
672 libevdev_free(dev);
679 struct libevdev *dev;
690 test_create_abs_device(&uidev, &dev,
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);
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);
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);
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);
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);
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);
730 libevdev_set_abs_minimum(dev, ABS_Z, 10);
731 ck_assert_int_eq(libevdev_has_event_code(dev, EV_ABS, ABS_Z), 0);
734 libevdev_free(dev);
741 struct libevdev *dev, *dev2;
745 test_create_abs_device(&uidev, &dev, 1, &abs,
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));
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));
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));
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));
778 libevdev_free(dev);
785 struct libevdev *dev;
788 test_create_abs_device(&uidev, &dev, 1, &abs,
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);
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);
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);
803 libevdev_free(dev);
810 struct libevdev *dev, *dev2;
817 test_create_abs_device(&uidev, &dev,
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));
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));
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));
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));
853 libevdev_free(dev);
860 struct libevdev *dev;
863 test_create_abs_device(&uidev, &dev, 1, &abs, -1);
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);
875 libevdev_free(dev);
882 struct libevdev *dev, *dev2;
901 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
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);
915 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &abs);
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);
934 libevdev_free(dev);
942 struct libevdev *dev;
961 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
964 rc = libevdev_kernel_set_abs_info(dev, ABS_MAX + 1, &abs);
967 libevdev_free(dev);
975 struct libevdev *dev;
989 dev = libevdev_new();
990 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &a);
992 libevdev_free(dev);
994 test_create_abs_device(&uidev, &dev,
999 libevdev_change_fd(dev, -2);
1000 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &a);
1006 libevdev_free(dev);
1013 struct libevdev *dev;
1016 test_create_device(&uidev, &dev,
1022 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_ON);
1024 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF);
1027 rc = libevdev_kernel_set_led_values(dev,
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));
1037 rc = libevdev_kernel_set_led_values(dev,
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));
1048 rc = libevdev_kernel_set_led_values(dev,
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));
1059 libevdev_free(dev);
1067 struct libevdev *dev;
1070 test_create_device(&uidev, &dev,
1076 rc = libevdev_kernel_set_led_value(dev, LED_MAX + 1, LIBEVDEV_LED_ON);
1079 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF + 1);
1082 rc = libevdev_kernel_set_led_value(dev, LED_SCROLLL, LIBEVDEV_LED_ON);
1085 rc = libevdev_kernel_set_led_values(dev,
1090 rc = libevdev_kernel_set_led_values(dev,
1096 rc = libevdev_kernel_set_led_values(dev,
1101 libevdev_free(dev);
1109 struct libevdev *dev;
1112 test_create_device(&uidev, &dev,
1118 rc = libevdev_kernel_set_led_values(dev,
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));
1150 libevdev_free(dev);