END_TEST
START_TEST(path_device_sysname)
{
struct litest_device *dev = litest_current_device();
struct libinput_event *ev;
struct libinput_device *device;
const char *sysname;
enum libinput_event_type type;
libinput_dispatch(dev->libinput);
ev = libinput_get_event(dev->libinput);
ck_assert_notnull(ev);
type = libinput_event_get_type(ev);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(ev);
ck_assert_notnull(device);
sysname = libinput_device_get_sysname(device);
ck_assert(sysname != NULL && strlen(sysname) > 1);
ck_assert(strchr(sysname, '/') == NULL);
ck_assert_int_eq(strncmp(sysname, "event", 5), 0);
libinput_event_destroy(ev);
}
END_TEST
START_TEST(device_group_ref)
{
struct libinput *li = litest_create_context();
struct litest_device *dev = litest_add_device(li,
LITEST_MOUSE);
struct libinput_device *device = dev->libinput_device;
struct libinput_device_group *group;
group = libinput_device_get_device_group(device);
ck_assert_notnull(group);
libinput_device_group_ref(group);
libinput_device_ref(device);
litest_drain_events(li);
litest_delete_device(dev);
litest_drain_events(li);
/* make sure the device is dead but the group is still around */
ck_assert(libinput_device_unref(device) == NULL);
libinput_device_group_ref(group);
ck_assert_notnull(libinput_device_group_unref(group));
ck_assert(libinput_device_group_unref(group) == NULL);
libinput_unref(li);
}
END_TEST
START_TEST(device_disable)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
enum libinput_config_status status;
struct libinput_event *event;
struct litest_device *tmp;
device = dev->libinput_device;
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* no event from disabled device */
litest_event(dev, EV_REL, REL_X, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_assert_empty_queue(li);
/* create a new device so the resumed fd isn't the same as the
suspended one */
tmp = litest_add_device(li, LITEST_KEYBOARD);
ck_assert_notnull(tmp);
litest_drain_events(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
/* event from renabled device */
litest_event(dev, EV_REL, REL_X, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
litest_delete_device(tmp);
}
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(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(device_get_udev_handle)
{
struct litest_device *dev = litest_current_device();
struct udev_device *udev_device;
udev_device = libinput_device_get_udev_device(dev->libinput_device);
ck_assert_notnull(udev_device);
udev_device_unref(udev_device);
}
END_TEST
START_TEST(path_added_device)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
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);
libinput_event_destroy(event);
}
END_TEST
START_TEST(device_udev_tag_apple)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
struct udev_device *d;
const char *prop;
d = libinput_device_get_udev_device(device);
prop = udev_device_get_property_value(d,
"LIBINPUT_MODEL_WACOM_TOUCHPAD");
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_WACOM)
ck_assert_notnull(prop);
else
ck_assert(prop == NULL);
udev_device_unref(d);
}
END_TEST
START_TEST(device_udev_tag_alps)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
struct udev_device *d;
const char *prop;
d = libinput_device_get_udev_device(device);
prop = udev_device_get_property_value(d,
"LIBINPUT_MODEL_ALPS_TOUCHPAD");
if (strstr(libinput_device_get_name(device), "ALPS"))
ck_assert_notnull(prop);
else
ck_assert(prop == NULL);
udev_device_unref(d);
}
END_TEST
START_TEST(device_group_get)
{
struct litest_device *dev = litest_current_device();
struct libinput_device_group *group;
int userdata = 10;
group = libinput_device_get_device_group(dev->libinput_device);
ck_assert_notnull(group);
libinput_device_group_ref(group);
libinput_device_group_set_user_data(group, &userdata);
ck_assert_ptr_eq(&userdata,
libinput_device_group_get_user_data(group));
libinput_device_group_unref(group);
}
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;
enum libinput_event_type type;
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);
ev = libinput_get_event(li);
ck_assert_notnull(ev);
type = libinput_event_get_type(ev);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
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);
libinput_event_destroy(ev);
ck_assert(saved_seat != NULL);
litest_assert_empty_queue(li);
libinput_suspend(li);
litest_drain_events(li);
libinput_resume(li);
libinput_dispatch(li);
ev = libinput_get_event(li);
ck_assert_notnull(ev);
type = libinput_event_get_type(ev);
ck_assert_int_eq(type, 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);
}
libinput_event_destroy(ev);
ck_assert(found == 1);
libinput_unref(li);
libevdev_uinput_destroy(uinput);
}