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_disable_touchpad)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
enum libinput_config_status status;
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);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10, 0);
litest_touch_up(dev, 0);
litest_assert_empty_queue(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);
}
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(device_disable_release_keys)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
struct libinput_event *event;
struct libinput_event_keyboard *kbdevent;
enum libinput_config_status status;
device = dev->libinput_device;
litest_button_click(dev, KEY_A, true);
litest_drain_events(li);
litest_assert_empty_queue(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_KEYBOARD_KEY);
kbdevent = libinput_event_get_keyboard_event(event);
ck_assert_int_eq(libinput_event_keyboard_get_key(kbdevent),
KEY_A);
ck_assert_int_eq(libinput_event_keyboard_get_key_state(kbdevent),
LIBINPUT_KEY_STATE_RELEASED);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
}
END_TEST
START_TEST(path_added_seat)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
struct libinput_device *device;
struct libinput_seat *seat;
const char *seat_name;
enum libinput_event_type type;
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert(event != NULL);
type = libinput_event_get_type(event);
ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
seat = libinput_device_get_seat(device);
ck_assert(seat != NULL);
seat_name = libinput_seat_get_logical_name(seat);
ck_assert_str_eq(seat_name, "default");
libinput_event_destroy(event);
}
END_TEST
START_TEST(device_disable_release_buttons)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
struct libinput_event *event;
struct libinput_event_pointer *ptrevent;
enum libinput_config_status status;
device = dev->libinput_device;
litest_button_click(dev, BTN_LEFT, true);
litest_drain_events(li);
litest_assert_empty_queue(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
ptrevent = libinput_event_get_pointer_event(event);
ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_LEFT);
ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
}
END_TEST
START_TEST(trackpoint_middlebutton_noscroll)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_event *event;
/* Disable middle button scrolling */
libinput_device_config_scroll_set_method(dev->libinput_device,
LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
litest_drain_events(li);
/* A long middle button click + motion should get reported normally now */
litest_button_scroll(dev, BTN_MIDDLE, 0, 10);
litest_assert_button_event(li, BTN_MIDDLE, 1);
event = libinput_get_event(li);
ck_assert(event != NULL);
ck_assert_int_eq(libinput_event_get_type(event), LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
litest_assert_button_event(li, BTN_MIDDLE, 0);
litest_assert_empty_queue(li);
/* Restore default scroll behavior */
libinput_device_config_scroll_set_method(dev->libinput_device,
libinput_device_config_scroll_get_default_method(
dev->libinput_device));
}
END_TEST
START_TEST(device_sendevents_config_touchpad_superset)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device;
enum libinput_config_status status;
uint32_t modes;
/* The wacom devices in the test suite are external */
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_WACOM ||
libevdev_get_id_bustype(dev->evdev) == BUS_BLUETOOTH)
return;
device = dev->libinput_device;
modes = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED |
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
status = libinput_device_config_send_events_set_mode(device,
modes);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* DISABLED supersedes the rest, expect the rest to be dropped */
modes = libinput_device_config_send_events_get_mode(device);
ck_assert_int_eq(modes, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
}
END_TEST
START_TEST(trackpoint_scroll)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
litest_drain_events(li);
litest_button_scroll(dev, BTN_MIDDLE, 1, 6);
litest_assert_scroll(li, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL, 6);
litest_button_scroll(dev, BTN_MIDDLE, 1, -7);
litest_assert_scroll(li, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL, -7);
litest_button_scroll(dev, BTN_MIDDLE, 8, 1);
litest_assert_scroll(li, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL, 8);
litest_button_scroll(dev, BTN_MIDDLE, -9, 1);
litest_assert_scroll(li, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL, -9);
/* scroll smaller than the threshold should not generate events */
litest_button_scroll(dev, BTN_MIDDLE, 1, 1);
/* long middle press without movement should not generate events */
litest_button_scroll(dev, BTN_MIDDLE, 0, 0);
litest_assert_empty_queue(li);
}
END_TEST
START_TEST(trackpoint_palmdetect_require_min_events)
{
struct litest_device *trackpoint = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = trackpoint->libinput;
touchpad = litest_add_device(li, LITEST_SYNAPTICS_I2C);
litest_drain_events(li);
/* A single event does not trigger palm detection */
litest_event(trackpoint, EV_REL, REL_X, 1);
litest_event(trackpoint, EV_REL, REL_Y, 1);
litest_event(trackpoint, EV_SYN, SYN_REPORT, 0);
libinput_dispatch(li);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 30, 30);
litest_touch_move_to(touchpad, 0, 30, 30, 80, 80, 10, 1);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_delete_device(touchpad);
}
END_TEST
START_TEST(trackpoint_palmdetect_resume_touch)
{
struct litest_device *trackpoint = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = trackpoint->libinput;
int i;
touchpad = litest_add_device(li, LITEST_SYNAPTICS_I2C);
litest_drain_events(li);
for (i = 0; i < 10; i++) {
litest_event(trackpoint, EV_REL, REL_X, 1);
litest_event(trackpoint, EV_REL, REL_Y, 1);
litest_event(trackpoint, EV_SYN, SYN_REPORT, 0);
libinput_dispatch(li);
}
litest_drain_events(li);
litest_touch_down(touchpad, 0, 30, 30);
litest_touch_move_to(touchpad, 0, 30, 30, 80, 80, 10, 1);
litest_assert_empty_queue(li);
litest_timeout_trackpoint();
libinput_dispatch(li);
/* touch started after last tp event, expect resume */
litest_touch_move_to(touchpad, 0, 80, 80, 30, 30, 10, 1);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_delete_device(touchpad);
}
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;
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) {
break;
}
libinput_event_destroy(event);
}
ck_assert(event != NULL);
device = libinput_event_get_device(event);
ck_assert(device != NULL);
libinput_event_destroy(event);
}
END_TEST
START_TEST(device_disable_events_pending)
{
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;
int i;
device = dev->libinput_device;
litest_drain_events(li);
/* put a couple of events in the queue, enough to
feed the ptraccel trackers */
for (i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_X, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
libinput_dispatch(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* expect above events */
litest_wait_for_event(li);
while ((event = libinput_get_event(li)) != NULL) {
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
}
}
END_TEST
START_TEST(device_disable_topsoftbutton)
{
struct litest_device *dev = litest_current_device();
struct litest_device *trackpoint;
struct libinput *li = dev->libinput;
struct libinput_device *device;
enum libinput_config_status status;
struct libinput_event *event;
struct libinput_event_pointer *ptrevent;
device = dev->libinput_device;
trackpoint = litest_add_device(li, LITEST_TRACKPOINT);
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_touch_down(dev, 0, 90, 10);
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
litest_touch_up(dev, 0);
litest_wait_for_event(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
ck_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_RIGHT);
ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
ck_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_RIGHT);
ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
litest_delete_device(trackpoint);
}
END_TEST
START_TEST(device_wheel_only)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
ck_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_POINTER));
}
END_TEST
START_TEST(device_context)
{
struct litest_device *dev = litest_current_device();
struct libinput_seat *seat;
ck_assert(dev->libinput == libinput_device_get_context(dev->libinput_device));
seat = libinput_device_get_seat(dev->libinput_device);
ck_assert(dev->libinput == libinput_seat_get_context(seat));
}
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(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_udev_assign_seat)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
int rc;
litest_set_log_handler_bug(li);
rc = libinput_udev_assign_seat(li, "foo");
ck_assert_int_eq(rc, -1);
litest_restore_log_handler(li);
}
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
START_TEST(device_sendevents_config_invalid)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device;
enum libinput_config_status status;
device = dev->libinput_device;
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED | (1 << 4));
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
START_TEST(trackpoint_topsoftbuttons_left_handed_both)
{
struct litest_device *touchpad = litest_current_device();
struct litest_device *trackpoint;
struct libinput *li = touchpad->libinput;
enum libinput_config_status status;
struct libinput_event *event;
struct libinput_device *device;
trackpoint = litest_add_device(li, LITEST_TRACKPOINT);
litest_drain_events(li);
/* touchpad left-handed, trackpoint left-handed */
status = libinput_device_config_left_handed_set(
touchpad->libinput_device, 1);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_left_handed_set(
trackpoint->libinput_device, 1);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
libinput_dispatch(li);
litest_button_click(touchpad, BTN_LEFT, true);
libinput_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
device = libinput_event_get_device(event);
ck_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_button_click(touchpad, BTN_LEFT, false);
libinput_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
device = libinput_event_get_device(event);
ck_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_delete_device(trackpoint);
}
END_TEST
START_TEST(device_disable_release_tap)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
enum libinput_config_status status;
device = dev->libinput_device;
libinput_device_config_tap_set_enabled(device,
LIBINPUT_CONFIG_TAP_ENABLED);
litest_drain_events(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
libinput_dispatch(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* tap happened before suspending, so we still expect the event */
litest_timeout_tap();
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_assert_empty_queue(li);
/* resume, make sure we don't get anything */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
START_TEST(device_sendevents_config_default)
{
struct litest_device *dev = litest_current_device();
struct libinput_device *device;
uint32_t mode;
device = dev->libinput_device;
mode = libinput_device_config_send_events_get_mode(device);
ck_assert_int_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
mode = libinput_device_config_send_events_get_default_mode(device);
ck_assert_int_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
}
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(device_disable_release_softbutton)
{
struct litest_device *dev = litest_current_device();
struct libinput *li = dev->libinput;
struct libinput_device *device;
enum libinput_config_status status;
device = dev->libinput_device;
litest_drain_events(li);
litest_touch_down(dev, 0, 90, 90);
litest_button_click(dev, BTN_LEFT, true);
/* make sure softbutton works */
litest_assert_button_event(li,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
/* disable */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_button_event(li,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_assert_empty_queue(li);
litest_button_click(dev, BTN_LEFT, false);
litest_touch_up(dev, 0);
litest_assert_empty_queue(li);
/* resume, make sure we don't get anything */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
START_TEST(device_ids)
{
struct litest_device *dev = litest_current_device();
const char *name;
unsigned int pid, vid;
name = libevdev_get_name(dev->evdev);
pid = libevdev_get_id_product(dev->evdev);
vid = libevdev_get_id_vendor(dev->evdev);
ck_assert_str_eq(name,
libinput_device_get_name(dev->libinput_device));
ck_assert_int_eq(pid,
libinput_device_get_id_product(dev->libinput_device));
ck_assert_int_eq(vid,
libinput_device_get_id_vendor(dev->libinput_device));
}
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);
}