END_TEST
START_TEST(path_create_destroy)
{
struct libinput *li;
struct libinput_device *device;
struct libevdev_uinput *uinput;
int rc;
void *userdata = &rc;
uinput = litest_create_uinput_device("test device", NULL,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
EV_REL, REL_X,
EV_REL, REL_Y,
-1);
li = libinput_path_create_context(&simple_interface, userdata);
ck_assert(li != NULL);
ck_assert(libinput_get_user_data(li) == userdata);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
ck_assert(device != NULL);
ck_assert_int_eq(open_func_count, 1);
libevdev_uinput_destroy(uinput);
libinput_unref(li);
ck_assert_int_eq(close_func_count, 1);
open_func_count = 0;
close_func_count = 0;
}
END_TEST
START_TEST(abs_mt_device_no_absx)
{
struct libevdev_uinput *uinput;
struct libinput *li;
struct libinput_device *device;
uinput = litest_create_uinput_device("test device", NULL,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
EV_ABS, ABS_X,
EV_ABS, ABS_Y,
EV_ABS, ABS_MT_SLOT,
EV_ABS, ABS_MT_POSITION_Y,
-1);
li = litest_create_context();
litest_disable_log_handler(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_restore_log_handler(li);
ck_assert(device == NULL);
libinput_unref(li);
libevdev_uinput_destroy(uinput);
}
END_TEST
START_TEST(path_double_remove_device)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
int remove_event = 0;
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
ck_assert(device != NULL);
litest_drain_events(li);
libinput_path_remove_device(device);
libinput_path_remove_device(device);
libinput_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
if (type == LIBINPUT_EVENT_DEVICE_REMOVED)
remove_event++;
libinput_event_destroy(event);
}
ck_assert_int_eq(remove_event, 1);
}
END_TEST
START_TEST(test_uinput_events)
{
struct libevdev *dev;
struct libevdev_uinput *uidev;
int fd, fd2;
int rc;
const char *devnode;
int i;
const int nevents = 5;
struct input_event events[] = { {{0, 0}, EV_REL, REL_X, 1},
{{0, 0}, EV_REL, REL_Y, -1},
{{0, 0}, EV_SYN, SYN_REPORT, 0},
{{0, 0}, EV_KEY, BTN_LEFT, 1},
{{0, 0}, EV_SYN, SYN_REPORT, 0}};
struct input_event events_read[nevents];
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_type(dev, EV_KEY);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd2 = open(devnode, O_RDONLY);
for (i = 0; i < nevents; i++)
libevdev_uinput_write_event(uidev, events[i].type, events[i].code, events[i].value);
rc = read(fd2, events_read, sizeof(events_read));
ck_assert_int_eq(rc, sizeof(events_read));
for (i = 0; i < nevents; i++) {
ck_assert_int_eq(events[i].type, events_read[i].type);
ck_assert_int_eq(events[i].code, events_read[i].code);
ck_assert_int_eq(events[i].value, events_read[i].value);
}
libevdev_free(dev);
libevdev_uinput_destroy(uidev);
close(fd);
close(fd2);
}
END_TEST
START_TEST(keyboard_ignore_no_pressed_release)
{
struct litest_device *dev;
struct libinput *unused_libinput;
struct libinput *libinput;
struct libinput_event *event;
struct libinput_event_keyboard *kevent;
int events[] = {
EV_KEY, KEY_A,
-1, -1,
};
enum libinput_key_state *state;
enum libinput_key_state expected_states[] = {
LIBINPUT_KEY_STATE_PRESSED,
LIBINPUT_KEY_STATE_RELEASED,
};
/* We can't send pressed -> released -> pressed events using uinput
* as such non-symmetric events are dropped. Work-around this by first
* adding the test device to the tested context after having sent an
* initial pressed event. */
unused_libinput = litest_create_context();
dev = litest_add_device_with_overrides(unused_libinput,
LITEST_KEYBOARD,
"Generic keyboard",
NULL, NULL, events);
litest_keyboard_key(dev, KEY_A, true);
litest_drain_events(unused_libinput);
libinput = litest_create_context();
libinput_path_add_device(libinput,
libevdev_uinput_get_devnode(dev->uinput));
litest_drain_events(libinput);
litest_keyboard_key(dev, KEY_A, false);
litest_keyboard_key(dev, KEY_A, true);
litest_keyboard_key(dev, KEY_A, false);
libinput_dispatch(libinput);
ARRAY_FOR_EACH(expected_states, state) {
event = libinput_get_event(libinput);
ck_assert_notnull(event);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_KEYBOARD_KEY);
kevent = libinput_event_get_keyboard_event(event);
ck_assert_int_eq(libinput_event_keyboard_get_key(kevent),
KEY_A);
ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
*state);
libinput_event_destroy(event);
libinput_dispatch(libinput);
}
END_TEST
START_TEST(test_uinput_create_device_from_fd)
{
struct libevdev *dev, *dev2;
struct libevdev_uinput *uidev;
int fd, fd2;
unsigned int type, code;
int rc;
const char *devnode;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
ck_assert_int_eq(libevdev_uinput_get_fd(uidev), fd);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd2 = open(devnode, O_RDONLY);
ck_assert_int_gt(fd2, -1);
rc = libevdev_new_from_fd(fd2, &dev2);
ck_assert_int_eq(rc, 0);
for (type = 0; type < EV_CNT; type++) {
int max = libevdev_event_type_get_max(type);
if (max == -1)
continue;
for (code = 0; code < max; code++) {
ck_assert_int_eq(libevdev_has_event_code(dev, type, code),
libevdev_has_event_code(dev2, type, code));
}
}
libevdev_free(dev);
libevdev_free(dev2);
libevdev_uinput_destroy(uidev);
close(fd);
close(fd2);
}
END_TEST
START_TEST(path_add_device)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
const char *sysname1 = NULL, *sysname2 = NULL;
libinput_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
if (type == LIBINPUT_EVENT_DEVICE_ADDED) {
ck_assert(sysname1 == NULL);
device = libinput_event_get_device(event);
ck_assert(device != NULL);
sysname1 = libinput_device_get_sysname(device);
}
libinput_event_destroy(event);
}
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
ck_assert(device != NULL);
libinput_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
if (type == LIBINPUT_EVENT_DEVICE_ADDED) {
ck_assert(sysname2 == NULL);
device = libinput_event_get_device(event);
ck_assert(device != NULL);
sysname2 = libinput_device_get_sysname(device);
}
libinput_event_destroy(event);
}
ck_assert_str_eq(sysname1, sysname2);
libinput_event_destroy(event);
}
END_TEST
static void
assert_device_ignored(struct libinput *li, struct input_absinfo *absinfo)
{
struct libevdev_uinput *uinput;
struct libinput_device *device;
uinput = litest_create_uinput_abs_device("test device", NULL,
absinfo,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
-1);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_assert_ptr_null(device);
libevdev_uinput_destroy(uinput);
}
END_TEST
START_TEST(path_force_destroy)
{
struct litest_device *dev = litest_current_device();
struct libinput *li;
struct libinput_device *device;
li = libinput_path_create_context(&simple_interface, NULL);
ck_assert_notnull(li);
libinput_ref(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
ck_assert_notnull(device);
while (libinput_unref(li) != NULL)
;
}
END_TEST
START_TEST(path_add_device)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
char *sysname1 = NULL, *sysname2 = NULL;
enum libinput_event_type type;
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
ck_assert_notnull(device);
sysname1 = strdup(libinput_device_get_sysname(device));
libinput_event_destroy(event);
litest_assert_empty_queue(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
ck_assert(device != NULL);
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
ck_assert_notnull(device);
sysname2 = strdup(libinput_device_get_sysname(device));
libinput_event_destroy(event);
ck_assert_str_eq(sysname1, sysname2);
free(sysname1);
free(sysname2);
}
END_TEST
START_TEST(test_uinput_properties)
{
struct libevdev *dev, *dev2;
struct libevdev_uinput *uidev;
int fd;
int rc;
const char *devnode;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_type(dev, EV_KEY);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, NULL);
libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD);
libevdev_enable_property(dev, INPUT_PROP_MAX);
rc = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd = open(devnode, O_RDONLY);
ck_assert_int_gt(fd, -1);
rc = libevdev_new_from_fd(fd, &dev2);
ck_assert_int_eq(rc, 0);
ck_assert(libevdev_has_property(dev2, INPUT_PROP_BUTTONPAD));
ck_assert(libevdev_has_property(dev2, INPUT_PROP_MAX));
libevdev_free(dev);
libevdev_free(dev2);
libevdev_uinput_destroy(uidev);
close(fd);
}
END_TEST
START_TEST(path_seat_recycle)
{
struct libinput *li;
struct libevdev_uinput *uinput;
int rc;
void *userdata = &rc;
struct libinput_event *ev;
struct libinput_device *device;
struct libinput_seat *saved_seat = NULL;
struct libinput_seat *seat;
int data = 0;
int found = 0;
void *user_data;
uinput = litest_create_uinput_device("test device", NULL,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
EV_REL, REL_X,
EV_REL, REL_Y,
-1);
li = libinput_path_create_context(&simple_interface, userdata);
ck_assert(li != NULL);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
ck_assert(device != NULL);
libinput_dispatch(li);
while ((ev = libinput_get_event(li))) {
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
if (saved_seat)
break;
device = libinput_event_get_device(ev);
ck_assert(device != NULL);
saved_seat = libinput_device_get_seat(device);
libinput_seat_set_user_data(saved_seat, &data);
libinput_seat_ref(saved_seat);
break;
default:
break;
}
libinput_event_destroy(ev);
}
ck_assert(saved_seat != NULL);
libinput_suspend(li);
litest_drain_events(li);
libinput_resume(li);
libinput_dispatch(li);
while ((ev = libinput_get_event(li))) {
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
device = libinput_event_get_device(ev);
ck_assert(device != NULL);
seat = libinput_device_get_seat(device);
user_data = libinput_seat_get_user_data(seat);
if (user_data == &data) {
found = 1;
ck_assert(seat == saved_seat);
}
break;
default:
break;
}
libinput_event_destroy(ev);
}
ck_assert(found == 1);
libinput_unref(li);
libevdev_uinput_destroy(uinput);
}
END_TEST
START_TEST(path_add_device_suspend_resume_remove_device)
{
struct libinput *li;
struct libinput_device *device;
struct libinput_event *event;
struct libevdev_uinput *uinput1, *uinput2;
int rc;
int nevents;
void *userdata = &rc;
uinput1 = litest_create_uinput_device("test device", NULL,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
EV_REL, REL_X,
EV_REL, REL_Y,
-1);
uinput2 = litest_create_uinput_device("test device 2", NULL,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_RIGHT,
EV_REL, REL_X,
EV_REL, REL_Y,
-1);
li = libinput_path_create_context(&simple_interface, userdata);
ck_assert(li != NULL);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput1));
ck_assert(device != NULL);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput2));
libinput_device_ref(device);
libinput_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
libinput_event_destroy(event);
nevents++;
}
ck_assert_int_eq(nevents, 2);
libinput_suspend(li);
libinput_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_REMOVED);
libinput_event_destroy(event);
nevents++;
}
ck_assert_int_eq(nevents, 2);
/* now drop and remove one of the devices */
libevdev_uinput_destroy(uinput2);
libinput_path_remove_device(device);
libinput_device_unref(device);
rc = libinput_resume(li);
ck_assert_int_eq(rc, 0);
libinput_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
libinput_event_destroy(event);
nevents++;
}
ck_assert_int_eq(nevents, 1);
libevdev_uinput_destroy(uinput1);
libinput_unref(li);
open_func_count = 0;
close_func_count = 0;
}
