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_reenable_device_removed)
{
struct libinput *li;
struct litest_device *litest_device;
struct libinput_device *device;
enum libinput_config_status status;
li = litest_create_context();
litest_device = litest_add_device(li, LITEST_MOUSE);
device = litest_device->libinput_device;
libinput_device_ref(device);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_delete_device(litest_device);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* can't really check for much here, this really just exercises the
code path. */
litest_assert_empty_queue(li);
libinput_device_unref(device);
libinput_unref(li);
}
/*
* _clutter_input_device_evdev_new:
* @manager: the device manager
* @seat: the seat the device will belong to
* @libinput_device: the libinput device
*
* Create a new ClutterInputDevice given a libinput device and associate
* it with the provided seat.
*/
ClutterInputDevice *
_clutter_input_device_evdev_new (ClutterDeviceManager *manager,
ClutterSeatEvdev *seat,
struct libinput_device *libinput_device)
{
ClutterInputDeviceEvdev *device;
ClutterInputDeviceType type;
ClutterDeviceManagerEvdev *manager_evdev;
gchar *vendor, *product;
gint device_id, n_rings = 0, n_strips = 0, n_groups = 1;
gchar *node_path;
gdouble width, height;
type = _clutter_input_device_evdev_determine_type (libinput_device);
vendor = g_strdup_printf ("%.4x", libinput_device_get_id_vendor (libinput_device));
product = g_strdup_printf ("%.4x", libinput_device_get_id_product (libinput_device));
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
device_id = _clutter_device_manager_evdev_acquire_device_id (manager_evdev);
node_path = g_strdup_printf ("/dev/input/%s", libinput_device_get_sysname (libinput_device));
if (libinput_device_has_capability (libinput_device,
LIBINPUT_DEVICE_CAP_TABLET_PAD))
{
n_rings = libinput_device_tablet_pad_get_num_rings (libinput_device);
n_strips = libinput_device_tablet_pad_get_num_strips (libinput_device);
n_groups = libinput_device_tablet_pad_get_num_mode_groups (libinput_device);
}
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
"id", device_id,
"name", libinput_device_get_name (libinput_device),
"device-manager", manager,
"device-type", type,
"device-mode", CLUTTER_INPUT_MODE_SLAVE,
"enabled", TRUE,
"vendor-id", vendor,
"product-id", product,
"n-rings", n_rings,
"n-strips", n_strips,
"n-mode-groups", n_groups,
"device-node", node_path,
NULL);
device->seat = seat;
device->libinput_device = libinput_device;
libinput_device_set_user_data (libinput_device, device);
libinput_device_ref (libinput_device);
g_free (vendor);
g_free (product);
g_free (node_path);
if (libinput_device_get_size (libinput_device, &width, &height) == 0)
device->device_aspect_ratio = width / height;
return CLUTTER_INPUT_DEVICE (device);
}
END_TEST
START_TEST(device_reenable_syspath_changed)
{
struct libinput *li;
struct litest_device *litest_device;
struct libinput_device *device1, *device2;
enum libinput_config_status status;
struct libinput_event *event;
li = litest_create_context();
litest_device = litest_add_device(li, LITEST_MOUSE);
device1 = litest_device->libinput_device;
libinput_device_ref(device1);
status = libinput_device_config_send_events_set_mode(device1,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_delete_device(litest_device);
litest_drain_events(li);
litest_device = litest_add_device(li, LITEST_MOUSE);
device2 = litest_device->libinput_device;
/* Note: if the sysname isn't the same, some other device got added
* or removed while this test was running. This is unlikely and
* would result in a false positive, so let's fail the test here */
ck_assert_str_eq(libinput_device_get_sysname(device1),
libinput_device_get_sysname(device2));
status = libinput_device_config_send_events_set_mode(device1,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* can't really check for much here, other than that if we pump
events through libinput, none of them should be from the first
device */
litest_event(litest_device, EV_REL, REL_X, 1);
litest_event(litest_device, EV_REL, REL_Y, 1);
litest_event(litest_device, EV_SYN, SYN_REPORT, 0);
libinput_dispatch(li);
while ((event = libinput_get_event(li))) {
ck_assert(libinput_event_get_device(event) != device1);
libinput_event_destroy(event);
}
litest_delete_device(litest_device);
libinput_device_unref(device1);
libinput_unref(li);
}
/*
* _clutter_input_device_evdev_new:
* @manager: the device manager
* @seat: the seat the device will belong to
* @libinput_device: the libinput device
*
* Create a new ClutterInputDevice given a libinput device and associate
* it with the provided seat.
*/
ClutterInputDevice *
_clutter_input_device_evdev_new (ClutterDeviceManager *manager,
ClutterSeatEvdev *seat,
struct libinput_device *libinput_device)
{
ClutterInputDeviceEvdev *device;
ClutterInputDeviceType type;
ClutterDeviceManagerEvdev *manager_evdev;
gchar *vendor, *product;
gint device_id;
type = _clutter_input_device_evdev_determine_type (libinput_device);
vendor = g_strdup_printf ("%.4x", libinput_device_get_id_vendor (libinput_device));
product = g_strdup_printf ("%.4x", libinput_device_get_id_product (libinput_device));
manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (manager);
device_id = _clutter_device_manager_evdev_acquire_device_id (manager_evdev);
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_EVDEV,
"id", device_id,
"name", libinput_device_get_sysname (libinput_device),
"device-manager", manager,
"device-type", type,
"device-mode", CLUTTER_INPUT_MODE_SLAVE,
"enabled", TRUE,
"vendor-id", vendor,
"product-id", product,
NULL);
device->seat = seat;
device->libinput_device = libinput_device;
libinput_device_set_user_data (libinput_device, device);
libinput_device_ref (libinput_device);
g_free (vendor);
g_free (product);
return CLUTTER_INPUT_DEVICE (device);
}
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;
}
END_TEST
START_TEST(path_seat_change)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
struct libinput_seat *seat1, *seat2;
const char *seat1_name;
const char *seat2_name = "new seat";
int rc;
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
libinput_device_ref(device);
seat1 = libinput_device_get_seat(device);
libinput_seat_ref(seat1);
seat1_name = libinput_seat_get_logical_name(seat1);
libinput_event_destroy(event);
litest_drain_events(li);
rc = libinput_device_set_seat_logical_name(device,
seat2_name);
ck_assert_int_eq(rc, 0);
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert(event != NULL);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_REMOVED);
ck_assert(libinput_event_get_device(event) == device);
libinput_event_destroy(event);
event = libinput_get_event(li);
ck_assert(event != NULL);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_ADDED);
ck_assert(libinput_event_get_device(event) != device);
libinput_device_unref(device);
device = libinput_event_get_device(event);
seat2 = libinput_device_get_seat(device);
ck_assert_str_ne(libinput_seat_get_logical_name(seat2),
seat1_name);
ck_assert_str_eq(libinput_seat_get_logical_name(seat2),
seat2_name);
libinput_event_destroy(event);
libinput_seat_unref(seat1);
/* litest: swap the new device in, so cleanup works */
libinput_device_unref(dev->libinput_device);
libinput_device_ref(device);
dev->libinput_device = device;
}