return current_device;
}
+int
+_litest_dispatch(struct libinput *li,
+ const char *func,
+ int line)
+{
+ static int dispatch_counter = 0;
+
+ ++dispatch_counter;
+
+ _litest_checkpoint(func, line,
+ "┌──────────────────── dispatch %3d ────────────────────┐",
+ dispatch_counter);
+ int rc = libinput_dispatch(li);
+ enum libinput_event_type type = libinput_next_event_type(li);
+
+
+ const char *evtype = type == LIBINPUT_EVENT_NONE ? "NONE" : litest_event_type_str(type);
+ _litest_checkpoint(func, line,
+ "└──────────────────── /dispatch %3d ────────────────────┘ pending %s",
+ dispatch_counter,
+ evtype);
+ return rc;
+}
+
static void
grab_device(struct litest_device *device, bool mode)
{
}
}
-static const char *
+const char *
litest_event_type_str(enum libinput_event_type type)
{
const char *str = NULL;
void
litest_delete_device(struct litest_device *d);
+const char *
+litest_event_type_str(enum libinput_event_type type);
+
+int
+_litest_dispatch(struct libinput *li, const char *func, int line);
+
+#define litest_dispatch(li_) \
+ _litest_dispatch(li_, __func__, __LINE__)
+
void
litest_event(struct litest_device *t,
unsigned int type,
litest_event(dev, EV_REL, REL_X, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
ck_assert_int_eq(libinput_event_get_type(event),
litest_tablet_proximity_in(dev, 60, 60, axes);
for (int i = 60; i < 70; i++) {
litest_tablet_motion(dev, i, i, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_tablet_proximity_out(dev);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* after disabling sendevents we require a touch up */
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_touch_event(event, LIBINPUT_EVENT_TOUCH_CANCEL);
libinput_event_destroy(event);
litest_event(dev, EV_REL, REL_X, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
litest_event(litest_device, EV_REL, REL_Y, 1);
litest_event(litest_device, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
ck_assert(libinput_event_get_device(event) != device1);
libinput_event_destroy(event);
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
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_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_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);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_assert_button_event(li,
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_dispatch(li);
litest_assert_empty_queue(li);
}
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
libevdev_uinput_write_event(uinput, EV_REL, REL_Y, -1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_restore_log_handler(li);
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
libevdev_uinput_write_event(uinput, EV_REL, REL_Y, -1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_destroy_context(li);
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
libevdev_uinput_write_event(uinput, EV_REL, REL_Y, -1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_restore_log_handler(li);
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
libevdev_uinput_write_event(uinput, EV_REL, REL_Y, -1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_destroy_context(li);
litest_event(dev, EV_REL, REL_HWHEEL, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* both high and low scroll end events must be sent */
for (i = 0; i < 2; i++) {
* press */
if (libevdev_has_property(lidev->evdev, INPUT_PROP_BUTTONPAD)) {
litest_touch_down(dev, 0, 20, 90);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_event(dev, EV_KEY, code, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) !=
litest_touch_down(dev, 0, 40, 40);
litest_touch_down(dev, 1, 50, 40);
litest_touch_down(dev, 2, 60, 40);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
litest_touch_move_three_touches(dev, 40, 40, 50, 40, 60, 40, dir_x,
dir_y, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE) {
litest_assert_gesture_event(li,
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
litest_touch_down(dev, 1, 50, 40);
litest_touch_down(dev, 2, 60, 40);
litest_touch_down(dev, 3, 70, 40);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
70 + dir_x,
40 + dir_y);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE) {
litest_assert_gesture_event(li,
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
litest_touch_up(dev, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
50 - dir_x,
50 - dir_y);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
if (hold == HOLD_GESTURE_REQUIRE) {
ck_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
litest_touch_down(dev, 2, 51 - dir_x, 51 - dir_y);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
51 - dir_x,
51 - dir_y);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
if (hold == HOLD_GESTURE_REQUIRE) {
ck_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
litest_touch_down(dev, 2, 51 - dir_x, 51 - dir_y);
litest_touch_down(dev, 3, 52 - dir_x, 52 - dir_y);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
52 - dir_x,
52 - dir_y);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
if (hold == HOLD_GESTURE_REQUIRE) {
ck_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
litest_touch_up(dev, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
litest_touch_down(dev, 0, 50 + dir_x, 50 + dir_y);
litest_touch_down(dev, 1, 50 - dir_x, 50 - dir_y);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
50 - dir_x,
50 - dir_y);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
if (hold == HOLD_GESTURE_REQUIRE) {
ck_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
litest_touch_down(dev, 1, 30, 20);
/* third finger in btnarea */
litest_touch_down(dev, 2, 50, 99);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE)
litest_timeout_gesture_hold();
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (hold == HOLD_GESTURE_REQUIRE) {
litest_assert_gesture_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_hold();
if (libinput_device_has_capability(dev->libinput_device,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
if (libinput_device_has_capability(dev->libinput_device,
LIBINPUT_DEVICE_CAP_GESTURE)) {
litest_assert_gesture_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_hold();
litest_touch_up(dev, last_finger);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev, 40, 40, 50, 40, dir_x, dir_y, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 20, 60, 10, 80, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_gesture_event(event, LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN, 3);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev, 40, 40, 50, 40, dir_x, dir_y, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
litest_touch_down(dev, 0, 40, 40);
litest_touch_down(dev, 1, 50, 40);
litest_touch_down(dev, 2, 60, 40);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_three_touches(dev, 40, 40, 50, 40, 60, 40, 0, 30,
30);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 1, 30, 20, 30, 70, 10);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_touch_down(dev, 0, 40, 20);
litest_touch_down(dev, 1, 50, 20);
litest_touch_down(dev, 2, 60, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_three_touches(dev,
40, 20,
50, 20,
60, 20,
30, 40,
10);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_gesture_event(event,
/* First tap, a hold gesture must be generated */
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_quick_hold();
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_gesture_event(li,
LIBINPUT_EVENT_GESTURE_HOLD_BEGIN,
/* Double tap, don't generate an extra hold gesture */
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_quick_hold();
litest_assert_button_event(li, BTN_LEFT,
litest_touch_down(dev, 0, 40, 30);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_quick_hold();
switch (nfingers) {
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
/* "Quick" hold gestures are only generated when using 1 or 2 fingers */
if (nfingers == 1 || nfingers == 2) {
/* Tap and drag, don't generate an extra hold gesture */
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_drain_events(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 50, 50, 51, 51, 1);
litest_touch_move_to(dev, 0, 51, 51, 50, 50, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_quick_hold();
1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_gesture_event(li,
LIBINPUT_EVENT_GESTURE_HOLD_END,
litest_drain_events(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_quick_hold();
litest_assert_gesture_event(li,
litest_touch_move_to(dev, 0, 50, 50, 51, 51, 1);
litest_touch_move_to(dev, 0, 51, 51, 50, 50, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_gesture_event(li,
LIBINPUT_EVENT_GESTURE_HOLD_END,
for (i = 0; i < num_devices; ++i)
litest_keyboard_key(devices[i], KEY_A, true);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
kev = litest_is_keyboard_event(ev,
KEY_A,
ck_assert_int_eq(expected_key_button_count, seat_key_count);
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert_int_eq(seat_key_count, num_devices);
for (i = 0; i < num_devices; ++i)
litest_keyboard_key(devices[i], KEY_A, false);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
kev = libinput_event_get_keyboard_event(ev);
ck_assert_notnull(kev);
ck_assert_int_eq(expected_key_button_count, seat_key_count);
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert_int_eq(seat_key_count, 0);
litest_keyboard_key(dev, KEY_A, true);
litest_keyboard_key(dev, KEY_A, false);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
ARRAY_FOR_EACH(expected_states, state) {
event = libinput_get_event(libinput);
ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
*state);
libinput_event_destroy(event);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
litest_assert_empty_queue(libinput);
litest_event(dev, EV_KEY, key, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
event = libinput_get_event(libinput);
litest_is_keyboard_event(event,
litest_drain_events(dev->libinput);
litest_keyboard_key(dev, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
kev = litest_is_keyboard_event(event,
litest_keyboard_key(dev, code, true);
litest_keyboard_key(dev, code, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_keyboard_event(event,
litest_event(dev, EV_KEY, KEY_LEFTSHIFT, 1);
litest_event(dev, EV_KEY, KEY_A, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_key_event(li,
KEY_LEFTSHIFT,
litest_event(dev, EV_KEY, KEY_LEFTSHIFT, 0);
litest_event(dev, EV_KEY, KEY_A, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_key_event(li,
KEY_LEFTSHIFT,
litest_event(dev, EV_KEY, KEY_A, 1);
litest_event(dev, EV_KEY, KEY_LEFTSHIFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_key_event(li, KEY_A, LIBINPUT_KEY_STATE_PRESSED);
litest_assert_key_event(li,
litest_event(dev, EV_KEY, KEY_A, 0);
litest_event(dev, EV_KEY, KEY_LEFTSHIFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_key_event(li, KEY_A, LIBINPUT_KEY_STATE_RELEASED);
litest_assert_key_event(li,
KEY_LEFTSHIFT,
LIBINPUT_KEY_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
abs->maximum * 2 + i);
litest_event(dev, EV_ABS, axis, abs->maximum * 2);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
/* Expect only one message per 5 min */
litest_restore_log_handler(li); /* use the default litest handler */
libinput_path_add_device(li, libevdev_uinput_get_devnode(uinput));
- libinput_dispatch(li);
+ litest_dispatch(li);
libinput_suspend(li);
libinput_resume(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
litest_event(dev, EV_ABS, ABS_Y, 30);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
litest_event(dev, EV_KEY, KEY_A, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
struct libinput_event *event;
int touch = 0;
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 10);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
int gestures = 0;
int i;
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 70, 30);
litest_touch_down(dev, 1, 30, 70);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture_hold();
for (i = 0; i < 8; i++) {
litest_touch_move(dev, 0, 70 - i * 5, 30 + i * 5);
litest_touch_move(dev, 1, 30 + i * 5, 70 - i * 5);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
while ((event = libinput_get_event(li))) {
litest_button_click(dev, BTN_STYLUS, true);
litest_button_click(dev, BTN_STYLUS, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
litest_pad_ring_start(dev, 10);
litest_pad_ring_end(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
litest_switch_action(dev,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_OFF);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
libinput_path_remove_device(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* Device is removed, but fd is still open. Queue an event, add a
* by libinput */
libevdev_uinput_write_event(uinput, EV_REL, REL_Y, 1);
libevdev_uinput_write_event(uinput, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
libinput_path_add_device(li, path);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_ADDED);
user_data->private = &warning_triggered;
libinput_log_set_handler(li, timer_offset_warning);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* triggered for touch down and touch up */
ck_assert_int_eq(warning_triggered, 2);
litest_event(dev, EV_REL, REL_X, -1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
msleep(21);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
ck_assert_int_ge(warning_triggered, 1);
touchpad = litest_add_device(li, LITEST_SYNAPTICS_TOUCHPAD);
litest_enable_tap(touchpad->libinput_device);
- libinput_dispatch(li);
+ litest_dispatch(li);
keyboard = litest_add_device(li, LITEST_KEYBOARD);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* make sure tapping works */
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
/* make sure dwt-tap is ignored */
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
/* Ignore 'timer offset negative' warnings */
- send a key event
- expire dwt
- send a tap
- and then call libinput_dispatch(). libinput should notice that
+ and then call litest_dispatch(). libinput should notice that
the tap event came in after the timeout and thus acknowledge the
tap.
*/
litest_timeout_dwt_long();
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_restore_log_handler(li);
litest_assert_key_event(li, KEY_A, LIBINPUT_KEY_STATE_PRESSED);
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
break;
}
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(ev),
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
count++;
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
count++;
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_button_event(li,
i,
litest_button_click(dev, code, 1);
litest_button_click(dev, code, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
switch (code) {
case BTN_STYLUS:
*/
for (val = 0; val < 100.0; val += 1) {
litest_pad_ring_change(dev, val);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
if (!ev)
litest_drain_events(li);
litest_pad_ring_end(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
pev = litest_is_pad_ring_event(ev,
if (code == REL_WHEEL)
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, direction * 120);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
struct libinput_event *ev = libinput_get_event(li);
struct libinput_event_tablet_pad *pev = litest_is_pad_dial_event(ev, 0);
if (accumulated % 120 == 0)
litest_event(dev, EV_REL, REL_WHEEL, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
struct libinput_event *ev = libinput_get_event(li);
struct libinput_event_tablet_pad *pev = litest_is_pad_dial_event(ev, 0);
* value. */
for (val = 0; val < 100; val += 9.5) {
litest_pad_strip_change(dev, val);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
pev = litest_is_pad_strip_event(ev,
}
litest_pad_strip_change(dev, 100);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
pev = litest_is_pad_strip_event(ev,
litest_drain_events(li);
litest_pad_strip_end(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
pev = litest_is_pad_strip_event(ev,
for (val = 0; val < 100; val += 10) {
litest_pad_ring_change(dev, val);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
pev = litest_is_pad_ring_event(ev,
key = KEY_BUTTONCONFIG;
pad_key_down(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_PRESSED);
pad_key_up(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_RELEASED);
key = KEY_ONSCREEN_KEYBOARD;
pad_key_down(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_PRESSED);
pad_key_up(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_RELEASED);
key = KEY_CONTROLPANEL;
pad_key_down(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_PRESSED);
pad_key_up(dev, key);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_pad_key_event(li, key, LIBINPUT_KEY_STATE_RELEASED);
}
END_TEST
const char *seat_name;
enum libinput_event_type type;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
const char *seat2_name = "new seat";
int rc;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
seat2_name);
ck_assert_int_eq(rc, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
struct libinput_device *device;
enum libinput_event_type type;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
char *sysname1 = NULL, *sysname2 = NULL;
enum libinput_event_type type;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
libevdev_uinput_get_devnode(dev->uinput));
ck_assert_notnull(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_restore_log_handler(li);
ck_assert(device == NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
const char *sysname;
enum libinput_event_type type;
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
ev = libinput_get_event(dev->libinput);
ck_assert_notnull(ev);
litest_drain_events(li);
libinput_path_remove_device(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
libinput_path_remove_device(device);
libinput_path_remove_device(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
ck_assert_notnull(device);
libinput_path_add_device(li, libevdev_uinput_get_devnode(uinput2));
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
ck_assert_int_eq(nevents, 2);
libinput_suspend(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
ck_assert_int_eq(nevents, 2);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
libevdev_uinput_get_devnode(uinput2));
ck_assert_notnull(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
ck_assert_int_eq(nevents, 2);
libinput_suspend(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
rc = libinput_resume(li);
ck_assert_int_eq(rc, -1);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
libevdev_uinput_get_devnode(uinput2));
libinput_device_ref(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
ck_assert_int_eq(nevents, 2);
libinput_suspend(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
rc = libinput_resume(li);
ck_assert_int_eq(rc, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
nevents = 0;
while ((event = libinput_get_event(li))) {
libevdev_uinput_destroy(uinput);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
libevdev_uinput_get_devnode(uinput));
ck_assert_notnull(device);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ck_assert_notnull(ev);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ck_assert_notnull(ev);
type = libinput_event_get_type(ev);
litest_event(dev, EV_REL, REL_Y, dy);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_REL, REL_Y, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
litest_drain_events(dev->libinput);
litest_event(dev, EV_REL, REL_X, 0);
litest_event(dev, EV_REL, REL_Y, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_empty_queue(li);
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_REL, REL_Y, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
libinput_event_destroy(libinput_get_event(li));
litest_assert_empty_queue(li);
litest_event(dev, EV_REL, REL_X, 0);
litest_event(dev, EV_REL, REL_Y, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
}
litest_assert_empty_queue(li);
litest_event(dev, EV_REL, REL_X, dx);
litest_event(dev, EV_REL, REL_Y, dy);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
enum libinput_event_type type = LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE;
litest_touch_down(dev, 0, x, y);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_assert_notnull(event);
litest_event(dev, EV_REL, REL_Y, dy);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
litest_event(dev, EV_REL, which, event_amount);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, which, amount * 120);
}
abort();
}
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, which, v120_amount);
}
litest_event(dev, EV_REL, lores_code, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, lores_code, direction * 120);
litest_event(dev, EV_REL, lores_code, -1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, lores_code, direction * -120);
litest_event(dev, EV_REL, lores_code, 2);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, lores_code, direction * 240);
litest_assert_empty_queue(li);
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 15);
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 15);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* The accumulated scroll is 30, add 30 to trigger scroll */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 30);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -60);
/* Once the threshold is reached, small scroll deltas are reported */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 5);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -5);
/* When the scroll timeout is triggered, ignore small deltas again */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -15);
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -15);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_event(dev, EV_REL, REL_HWHEEL_HI_RES, 15);
litest_event(dev, EV_REL, REL_HWHEEL_HI_RES, 15);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 120);
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 30);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -150);
/* Scroll below the threshold in the oposite direction should be ignored */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -30);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* But should be triggered if the scroll continues in the same direction */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, -120);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, 150);
/* Scroll above the threshold in the same dir should be triggered */
litest_event(dev, EV_REL, REL_WHEEL_HI_RES, 80);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
test_high_and_low_wheel_events_value(dev, REL_WHEEL_HI_RES, -80);
}
END_TEST
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_REL, REL_WHEEL, -60);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Hi-res scroll event first */
event = libinput_get_event(li);
litest_event(dev, EV_REL, REL_WHEEL, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
pev = litest_is_axis_event(event,
LIBINPUT_EVENT_POINTER_SCROLL_WHEEL,
BTN_LEFT,
true);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
if (libinput_event_get_type(ev) !=
LIBINPUT_EVENT_POINTER_BUTTON) {
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
continue;
}
ck_assert_int_eq(expected_seat_button_count, seat_button_count);
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert_int_eq(seat_button_count, num_devices);
BTN_LEFT,
false);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
if (libinput_event_get_type(ev) !=
LIBINPUT_EVENT_POINTER_BUTTON) {
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
continue;
}
ck_assert_int_eq(expected_seat_button_count, seat_button_count);
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert_int_eq(seat_button_count, 0);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Change while button is down, expect correct release event */
status = libinput_device_config_left_handed_set(d, 1);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
litest_assert_empty_queue(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click_debounced(device, li, BTN_LEFT, false);
litest_assert_button_event(li, BTN_LEFT,
litest_button_click(dev, BTN_LEFT, 1);
litest_button_click(dev, BTN_RIGHT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_Y, -1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, 0);
litest_button_click(dev, BTN_RIGHT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* delete the device while the timer is still active */
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_destroy_context(li);
}
litest_assert_empty_queue(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (int i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click_debounced(dev, li, BTN_LEFT, true);
litest_button_click_debounced(dev, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
/* but on the next button press we scroll lock */
litest_button_click_debounced(dev, li, BTN_LEFT, true);
litest_button_click_debounced(dev, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (int i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_X, 1);
/* but on the next button press we scroll lock */
litest_button_click_debounced(dev, li, BTN_LEFT, true);
litest_button_click_debounced(dev, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (int i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_X, 1);
litest_button_click_debounced(dev, li, BTN_LEFT, false);
litest_assert_empty_queue(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* other button passes on normally */
litest_button_click_debounced(dev, li, BTN_RIGHT, true);
abort();
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_middlebutton();
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* motion events are the same for all of them */
for (int i = 0; i < 10; i++) {
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
switch (buttonorder) {
case LLRR:
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
switch (buttonorder) {
case LLRR:
}
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
do {
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* middle emulation discards */
litest_assert_empty_queue(li);
litest_timeout_middlebutton();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* scroll discards */
litest_assert_empty_queue(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (i = 0; i < 10; i++) {
litest_event(dev, EV_REL, REL_Y, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
ev = libinput_get_event(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_axis_end_sequence(li,
LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_RIGHT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_RIGHT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_RIGHT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_event(dev, EV_KEY, BTN_RIGHT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
* each single event. */
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(15);
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(15);
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(15);
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(15);
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
{
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
/* gets filtered now */
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
for (int i = 0; i < 3; i++) {
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Not all devices can disable middle button emulation, time out on
* middle button here to make sure the initial button press event
* was flushed.
*/
litest_timeout_middlebutton();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
/* Not all devices can disable middle button emulation, time out on
* middle button here to make sure the initial button press event
* was flushed.
*/
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_middlebutton();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
* each single event. */
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(5);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(5);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(5);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
/* gets filtered now */
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
/* Don't trigger spurious debouncing on otherbutton events */
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_RIGHT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
/* Expect release to be immediate */
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* spurious debouncing is on but the release should get flushed by
* the other button */
litest_event(dev, EV_KEY, BTN_RIGHT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_RIGHT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* delete the device while the timer is still active */
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_destroy_context(li);
}
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* delete the device the timer is still active */
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_debounce();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_destroy_context(li);
}
litest_grab_device(dev);
litest_switch_action(dev, sw, LIBINPUT_SWITCH_STATE_ON);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (libinput_device_switch_has_switch(dev->libinput_device, sw) > 0) {
event = libinput_get_event(li);
}
litest_switch_action(dev, sw, LIBINPUT_SWITCH_STATE_OFF);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (libinput_device_switch_has_switch(dev->libinput_device, sw) > 0) {
event = libinput_get_event(li);
litest_grab_device(dev);
litest_switch_action(dev, sw, LIBINPUT_SWITCH_STATE_ON);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_switch_event(event, sw, LIBINPUT_SWITCH_STATE_ON);
/* This will be filtered by the kernel, so this test is a bit
* useless */
litest_switch_action(dev, sw, LIBINPUT_SWITCH_STATE_ON);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_ungrab_device(dev);
li = litest_create_context();
libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
event = libinput_get_event(li);
}
litest_switch_action(dev, sw, LIBINPUT_SWITCH_STATE_OFF);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_switch_event(event, sw, LIBINPUT_SWITCH_STATE_OFF);
libinput_event_destroy(event);
li = litest_create_context();
libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li)) != NULL) {
ck_assert_int_ne(libinput_event_get_type(event),
litest_ungrab_device(sw);
litest_touch_down(touchpad, 0, 99, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_edgescroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_move_to(touchpad, 0, 99, 20, 99, 80, 60);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_move_to(touchpad, 0, 99, 80, 99, 20, 60);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_delete_device(touchpad);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 99, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_edgescroll();
litest_touch_move_to(touchpad, 0, 99, 20, 99, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
litest_grab_device(sw);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_ungrab_device(sw);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_axis_end_sequence(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_event(keyboard, EV_SYN, SYN_REPORT, 0);
litest_event(keyboard, EV_KEY, KEY_A, 0);
litest_event(keyboard, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_switch_event(event,
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 70, 10);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
abort();
}
- libinput_dispatch(li);
+ litest_dispatch(li);
keyboard = litest_add_device(li, LITEST_KEYBOARD);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_grab_device(sw);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_drain_events(li);
litest_delete_device(sw);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_destroy_context(li);
}
keyboard1 = litest_add_device(li,
LITEST_KEYBOARD_BLADE_STEALTH_VIDEOSWITCH);
- libinput_dispatch(li);
+ litest_dispatch(li);
keyboard2 = litest_add_device(li, LITEST_KEYBOARD_BLADE_STEALTH);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_grab_device(sw);
litest_switch_action(sw,
litest_keyboard_key(sw, KEY_VOLUMEUP, true);
litest_keyboard_key(sw, KEY_VOLUMEUP, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Check that we're routing key events from a lid device too */
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
LIBINPUT_SWITCH_STATE_ON);
litest_drain_events(li);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
litest_switch_action(sw,
LIBINPUT_SWITCH_TABLET_MODE,
LIBINPUT_SWITCH_STATE_OFF);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_switch_event(event,
LIBINPUT_SWITCH_TABLET_MODE,
LIBINPUT_SWITCH_STATE_OFF);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_DEVICE_ADDED);
litest_switch_action(sw,
LIBINPUT_SWITCH_TABLET_MODE,
LIBINPUT_SWITCH_STATE_ON);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_switch_event(event,
LIBINPUT_SWITCH_TABLET_MODE,
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
litest_keyboard_key(keyboard, KEY_B, true); /* KEY_B down but not up */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_key_event(li, KEY_A, LIBINPUT_KEY_STATE_PRESSED);
litest_assert_key_event(li, KEY_A, LIBINPUT_KEY_STATE_RELEASED);
litest_drain_events(li);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
enum libinput_event_type type;
LIBINPUT_SWITCH_STATE_OFF);
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_DEVICE_ADDED);
litest_keyboard_key(keyboard, KEY_A, true);
litest_grab_device(sw);
litest_event(sw, EV_SW, SW_DOCK, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(sw, EV_SW, SW_DOCK, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_ungrab_device(sw);
litest_assert_empty_queue(li);
litest_drain_events(li);
litest_button_click(dev, button, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_empty_queue(li);
litest_button_click(dev, button, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_button_click(dev, button, true);
litest_button_click(dev2, button, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_button_click(dev2, button, false);
litest_button_click(dev, button, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
libevdev_enable_event_code(evdev, EV_KEY, code, NULL);
litest_event(dev, EV_KEY, code, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_drain_events(li);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (code = BTN_LEFT; code <= BTN_TASK; code++) {
if (!libevdev_has_event_code(evdev, EV_KEY, code))
litest_axis_set_value(axes, ABS_PRESSURE, 30);
litest_tablet_tip_down(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_axis_set_value(axes, ABS_PRESSURE, 0);
litest_tablet_tip_up(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_axis_set_value(axes, ABS_PRESSURE, 30);
litest_tablet_tip_down(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_axis_set_value(axes, ABS_PRESSURE, 0);
litest_tablet_tip_up(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_tablet_tip_down(dev, 10, 10, axes);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_tablet_proximity_out(dev);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
libinput_event_destroy(event);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_event(dev, EV_KEY, BTN_STYLUS, 1);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_STYLUS, 1);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_axis_set_value(axes, ABS_PRESSURE, 20);
litest_tablet_tip_down(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_axis_set_value(axes, ABS_PRESSURE, 20);
litest_tablet_tip_down(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_axis_set_value(axes, ABS_PRESSURE, 0);
litest_tablet_tip_up(dev, 40, 40, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_drain_events(li);
litest_tablet_motion(dev, 20, 20, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 30, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 40, 80, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_button_click(dev, button, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_button_click(dev, button, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_button_click(dev, button, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
libinput_event_destroy(event);
litest_button_click(dev, button, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
}
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) ==
ck_assert(have_tool_update);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) ==
litest_tablet_proximity_in(dev, 10, 10, axes);
litest_event(dev, EV_KEY, button, 1);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_tablet_proximity_out(dev);
litest_event(dev, EV_KEY, button, 0);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
button,
litest_event(dev, EV_KEY, *button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 20, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* Make sure that the axes are still present on proximity out */
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events_of_type(li, LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_axis_set_value(axes, ABS_DISTANCE, 20);
litest_tablet_motion(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_axis_set_value(axes, ABS_DISTANCE, 90);
litest_tablet_motion(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_event(dev, EV_KEY, BTN_TOOL_MOUSE, 1);
litest_unfilter_event(dev, EV_KEY, BTN_TOOL_PEN);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_axis_set_value(axes, ABS_DISTANCE, 90);
litest_tablet_motion(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_axis_set_value(axes, ABS_DISTANCE, 20);
litest_tablet_motion(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_event(dev, EV_KEY, BTN_STYLUS, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_push_event_frame(dev);
litest_filter_event(dev, EV_KEY, BTN_TOOL_PEN);
litest_event(dev, EV_KEY, BTN_STYLUS, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
BTN_STYLUS,
litest_axis_set_value(axes, ABS_DISTANCE, 90);
litest_tablet_motion(dev, 15, 15, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* expect fake button release */
litest_assert_tablet_button_event(li,
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_push_event_frame(dev);
litest_filter_event(dev, EV_KEY, BTN_TOOL_PEN);
litest_axis_set_value(axes, ABS_DISTANCE, 20);
litest_tablet_motion(dev, 15, 15, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
BTN_STYLUS,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_drain_events(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* The forced prox out */
litest_assert_tablet_proximity_event(li,
litest_drain_events(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* No forced proxout yet */
litest_assert_empty_queue(li);
litest_drain_events(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* The forced prox out */
litest_assert_tablet_proximity_event(li,
litest_event(dev, EV_KEY, BTN_STYLUS, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* No forced proxout yet */
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_STYLUS, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* The forced prox out */
litest_assert_tablet_proximity_event(li,
litest_drain_events(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_tablet_proximity_out(dev);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
/* timeout-based forced prox out */
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_assert_empty_queue(li);
/* now send the real prox out (we're already in proximity out) and
* that should disable the proxout quirk */
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* same again, but this time we expect no timeout-based prox out */
litest_drain_events(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_tablet_proximity_out(dev);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_drain_events(li);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 5, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
double reported_x, reported_y;
litest_tablet_motion(dev, test_x, test_y, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
tablet_event = libinput_event_get_tablet_tool_event(event);
* proximity events so that it updates it's internal tablet state, and
* then try setting it to left-handed mode. */
litest_tablet_proximity_in(dev, 0, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
libinput_device_config_left_handed_set(dev->libinput_device, 1);
event = libinput_get_event(li);
litest_axis_set_value(axes, ABS_DISTANCE, 5);
litest_tablet_motion(dev, 100, 0, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
* mode, so the axes should be inverted once we bring it back into
* proximity */
litest_tablet_proximity_in(dev, 0, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_axis_set_value(axes, ABS_DISTANCE, 5);
litest_tablet_motion(dev, 100, 0, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_event(dev, EV_ABS, ABS_TILT_X, x);
litest_event(dev, EV_ABS, ABS_TILT_Y, y);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_ABS, ABS_Z, a);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
for (test_x = 0, test_y = 100; test_x < 100; test_x += 10, test_y -= 10)
litest_tablet_motion(dev, test_x, test_y, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_tablet_motion(dev, test_x, test_y, axes);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
ck_assert_int_eq(libinput_next_event_type(li),
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_event(dev, EV_ABS, ABS_X, 0 + 5 * i);
litest_event(dev, EV_ABS, ABS_Y, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_drain_events(li);
litest_event(dev, EV_ABS, ABS_X, 0);
litest_event(dev, EV_ABS, ABS_Y, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_ABS, ABS_X, 1000);
litest_event(dev, EV_ABS, ABS_Y, 0 + 5 * i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_drain_events(li);
litest_event(dev, EV_ABS, ABS_X, 1000);
litest_event(dev, EV_ABS, ABS_Y, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 2000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_MSC, MSC_SERIAL, -1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) ==
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY) {
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, button, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (button = BTN_0; button < BTN_MOUSE; button++)
litest_event(dev, EV_KEY, button, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_event(dev[i], EV_MSC, MSC_SERIAL, 100);
litest_pop_event_frame(dev[i]);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool[i] = libinput_event_tablet_tool_get_tool(tev);
litest_tablet_proximity_in(dev[i], 10, 10, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool[i] = libinput_event_tablet_tool_get_tool(tev);
litest_event(dev, EV_MSC, MSC_SERIAL, 0);
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_ABS, ABS_Y, 2000);
litest_event(dev, EV_MSC, MSC_SERIAL, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_drain_events(li);
litest_event(dev, EV_ABS, ABS_Y, 2000);
litest_event(dev, EV_MSC, MSC_SERIAL, 1234566);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_ABS, ABS_Y, 2000);
litest_event(dev, EV_MSC, MSC_SERIAL, 1234566);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
event = libinput_get_event(li);
litest_event(dev, EV_MSC, MSC_SERIAL, 0);
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(bamboo, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(bamboo, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_event(intuos, EV_KEY, BTN_TOOL_PEN, 1);
litest_event(intuos, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_tablet_set_tool_type(dev, tt->code);
litest_tablet_proximity_in(dev, x, y, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
litest_assert_empty_queue(li);
litest_tablet_motion(dev, 10, 20, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events_of_type(li, LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_tablet_motion(dev, 30, 40, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_button_click(dev, BTN_STYLUS, false);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_RUBBER, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
libinput_event_destroy(event);
litest_tablet_motion(dev, 20, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_RUBBER, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_RUBBER, 1);
litest_tablet_motion(dev, 30, 40, axes);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
libinput_event_destroy(event);
litest_tablet_motion(dev, 40, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_RUBBER, 0);
litest_tablet_proximity_out(dev);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
/* pen prox in */
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_proximity_event(event,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
/* pen motion */
litest_tablet_motion(dev, 20, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* pen forced prox out */
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* actual prox out for tablets that don't do forced prox out */
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_proximity_event(event,
/* eraser prox in without axes */
litest_event(dev, EV_KEY, BTN_TOOL_RUBBER, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_proximity_event(event,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
/* eraser motion */
litest_tablet_motion(dev, 30, 40, axes);
litest_tablet_motion(dev, 40, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_event(dev, EV_ABS, ABS_MISC, 0x200); /* 3-button stylus tool_id */
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
ARRAY_FOR_EACH(stylus_buttons, code) {
litest_event(dev, EV_KEY, *code, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, *code, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
*code,
litest_event(dev, EV_KEY, BTN_TOOL_MOUSE, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_ABS, ABS_MISC, 0x806); /* 5-button mouse tool_id */
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, code, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, code, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
code,
litest_event(dev, EV_ABS, ABS_MISC, 0x806); /* 5-button mouse tool_id */
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
for (i = 0; i < 3; i++) {
litest_event(dev, EV_REL, REL_WHEEL, -1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
abs = libevdev_get_abs_info(dev->evdev, ABS_Y);
litest_event(dev, EV_ABS, ABS_Y, absinfo_range(abs)/i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_event(dev, EV_KEY, BTN_TOOL_AIRBRUSH, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
double expected = absinfo_normalize_value(abs, v) * 2 - 1;
litest_event(dev, EV_ABS, ABS_WHEEL, v);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_event(dev, EV_ABS, ABS_MISC, 0x804); /* Art Pen */
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_event(dev, EV_ABS, ABS_Z, a);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 5, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
* the tip threshold */
litest_axis_set_value(axes, ABS_PRESSURE, 1.1);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* We have pressure and we're above the tip threshold now */
litest_axis_set_value(axes, ABS_PRESSURE, 5.5);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 100, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
libinput_event_destroy(event);
litest_tablet_motion(dev, 80, 80, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
libinput_event_destroy(event);
litest_tablet_motion(dev, 80, 80, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
ck_assert_double_lt(y, 100.0);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_proximity_in(dev, 50, 50, axes);
litest_tablet_proximity_out(dev);
litest_drain_events(li);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
* us ~10% pressure */
for (int i = 0; i < 2; i++) {
litest_tablet_proximity_in(dev, 5, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, 0.20);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_TIP, 0.20);
* the litest motion helper here to avoid false positives caused by
* BTN_TOUCH */
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
libinput_event_destroy(event);
* the tip up event again */
litest_axis_set_value(axes, ABS_PRESSURE, 20.1);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* we can't actually get a real 0.0 because that would trigger a tip
up. but it's close enough to zero. */
litest_axis_set_value(axes, ABS_PRESSURE, 21);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS, 0.015);
litest_axis_set_value(axes, ABS_PRESSURE, 100);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS, 1.0);
/* Tablet motion at offset should trigger tip up. Use
* BTN_TOUCH */
litest_axis_set_value(axes, ABS_PRESSURE, 20);
litest_tablet_motion(dev, 71, 71, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
libinput_event_destroy(event);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 5, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, 0.0);
litest_drain_events(li);
/* trigger the pressure threshold */
litest_axis_set_value(axes, ABS_PRESSURE, 15);
litest_tablet_tip_down(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* offset 10 + lower threshold of ~1% of original range,
* value 15 is 5% over original range but with the above taken into
*/
litest_axis_set_value(axes, ABS_PRESSURE, 5);
litest_tablet_motion(dev, 75, 75, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_TIP, 0.0);
litest_drain_events(li);
* offset */
litest_axis_set_value(axes, ABS_PRESSURE, 10);
litest_tablet_motion(dev, 75, 75, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_TIP, 0.05);
litest_drain_events(li);
}
litest_axis_set_value(axes, ABS_DISTANCE, 0);
litest_axis_set_value(axes, ABS_PRESSURE, 31);
litest_tablet_tip_down(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
litest_axis_set_value(axes, ABS_PRESSURE, 30);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* offset 20 + lower threshold of 1% of original range,
* value 30 is 5% over original range but with the above taken into
litest_axis_set_value(axes, ABS_PRESSURE, 20);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_TIP, 0.0);
}
litest_tablet_proximity_in(dev, 5, 50, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_axis_set_value(axes, ABS_DISTANCE, 0);
/* Default pressure threshold is 1% of range */
litest_axis_set_value(axes, ABS_PRESSURE, 1.1);
litest_tablet_motion(dev, 5, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS, 0.0);
/* skip over pressure-based tip down */
litest_drain_events(li);
litest_tablet_motion(dev, 5, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS, 1.0);
}
END_TEST
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (pressure = 10; pressure <= 100; pressure += 10) {
litest_axis_set_value(axes, ABS_PRESSURE, pressure);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* config doesn't take effect until we're out of prox */
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
plus the 1% minimum offset, so our output pressure is actually ~15% */
litest_axis_set_value(axes, ABS_PRESSURE, 50);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
p = libinput_event_tablet_tool_get_pressure(tev);
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* config doesn't take effect until we're out of prox */
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
litest_tablet_proximity_out(dev);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_axis_set_value(axes, ABS_PRESSURE, 10);
litest_tablet_proximity_in(dev, 70, 70, axes);
plus the 1% minimum offset so our output pressure is actually ~15% */
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
for (int pos = 71; pos < 80; pos++) {
litest_tablet_motion(dev, pos, pos, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* config doesn't take effect until we're out of prox */
for (int i = 71; i < 80; i++) {
litest_tablet_motion(dev, i, i, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
for (double pressure = 0.0, i = 71; pressure <= 100; pressure += 5, i += 0.2) {
litest_axis_set_value(axes, ABS_PRESSURE, pressure);
litest_tablet_motion(dev, i, i, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
if (libinput_event_get_type(event) == LIBINPUT_EVENT_TABLET_TOOL_AXIS)
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
for (int i = 0; i < 2; i++) {
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
}
libinput_log_set_handler(li, pressure_threshold_warning);
litest_tablet_proximity_in(dev, 5, 100, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, 0.60);
ck_assert_int_eq(warning_triggered, 1);
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_tablet_tip_down(dev, 5, 100, axes);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, 0.20);
}
* pressure offset */
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_axis_set_value(axes, ABS_DISTANCE, 0);
litest_axis_set_value(axes, ABS_PRESSURE, 21);
litest_axis_set_value(axes, ABS_PRESSURE, 20);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS, 0.20);
}
litest_tablet_proximity_in(dev, 5, 100, axes);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (distance = 0; distance <= 100; distance += 10) {
litest_axis_set_value(axes, ABS_DISTANCE, distance);
litest_tablet_motion(dev, 70, 70, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_tablet_motion(dev, 10, 10, axes);
litest_drain_events(li);
litest_tablet_motion(dev, 10, 11, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_tablet_motion(dev, 10, 11, axes);
litest_drain_events(li);
litest_tablet_motion(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_event(dev, EV_ABS, ABS_TILT_Y, axis_value);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_tablet_motion(dev, 20, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 5, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_motion(dev, 5, 20, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_motion(dev, 5, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_axis_set_value(axes, ABS_PRESSURE, 30);
litest_tablet_tip_down(dev, 30, 20, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
/* normal motion */
litest_tablet_motion(dev, 40, 30, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_axis_set_value(axes, ABS_DISTANCE, 10);
litest_axis_set_value(axes, ABS_PRESSURE, 0);
litest_tablet_tip_up(dev, 50, 40, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
litest_drain_events(li);
litest_tablet_motion(dev, 20, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_motion(dev, 5, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_motion(dev, 5, 20, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_motion(dev, 5, 5, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_timeout_touch_arbitration();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* finger still down */
litest_touch_move_to(finger, 0, 80, 80, 30, 30, 10);
litest_assert_empty_queue(li);
litest_timeout_touch_arbitration();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* lift finger, expect expect events */
litest_touch_down(finger, 0, 30, 30);
litest_touch_move_to(finger, 0, 30, 30, 80, 80, 10);
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (is_touchpad)
litest_assert_only_typed_events(li,
/* left of rect */
litest_touch_sequence(finger, 0, x - 10, y + 2, x - 10, y + 20, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
/* above rect */
litest_touch_sequence(finger, 0, x + 2, y - 65, x + 20, y - 40, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
/* right of rect */
litest_touch_sequence(finger, 0, x + 80, y + 2, x + 20, y + 10, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
#if 0
/* below rect */
litest_touch_sequence(finger, 0, x + 2, y + 80, x + 20, y + 20, 30);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
#endif
litest_touch_down(finger, 0, 70, 70);
litest_drain_events(li);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Delete the device immediately after the tablet goes out of prox.
* This merely tests that the arbitration timer gets cleaned up */
litest_touch_move_to(finger, 1, 30, 30, 80, 80, 3);
litest_assert_empty_queue(li);
litest_touch_up(finger, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(finger, 0, 30, 30);
litest_touch_move_to(finger, 0, 30, 30, 80, 80, 3);
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (is_touchpad)
litest_assert_only_typed_events(li,
litest_assert_only_typed_events(li, LIBINPUT_EVENT_DEVICE_REMOVED);
litest_timeout_touch_arbitration();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 30, 30);
litest_touch_move_to(dev, 0, 30, 30, 80, 80, 10);
litest_touch_down(dev, 0, 30, 30);
litest_touch_move_to(dev, 0, 30, 30, 80, 80, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (is_touchpad)
litest_assert_only_typed_events(li,
litest_drain_events(li);
litest_delete_device(finger);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_DEVICE_REMOVED);
litest_assert_empty_queue(li);
if (is_touchpad)
litest_disable_hold_gestures(dev->libinput_device);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_tablet_proximity_in(tablet, 10, 10, axes);
litest_tablet_motion(tablet, 10, 10, axes);
litest_tablet_motion(tablet, 20, 40, axes);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_DEVICE_REMOVED);
litest_timeout_touch_arbitration();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Touch is still down, don't enable */
litest_touch_move_to(dev, 0, 80, 80, 30, 30, 10);
litest_touch_down(dev, 0, 30, 30);
litest_touch_move_to(dev, 0, 30, 30, 80, 80, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (is_touchpad)
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
*/
litest_touch_move_to(finger, 0, 30, 30, 80, 80, 10);
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
*/
litest_touch_down(finger, 0, 30, 30);
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
for (int i = 5; i < 25; i += 5) {
litest_tablet_motion(tablet, x + i, y - i, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
event = libinput_get_event(li);
x = 60;
y = 60;
litest_tablet_proximity_in(tablet, x, y, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
verify_left_handed_tablet_motion(tablet, li, x, y, left_handed);
litest_tablet_proximity_out(tablet);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
litest_drain_events(li);
}
/* touch down/up must be handled by caller */
litest_touch_move_to(finger, 0, x + 1, y - 1, x + 20, y - 20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_drain_events(li);
verify_left_handed_touch_motion(finger, li, x, y, left_handed);
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
#endif
libinput_device_config_left_handed_set(tablet_dev, tablet_from);
libinput_device_config_left_handed_set(touch_dev, touch_from);
- libinput_dispatch(li);
+ litest_dispatch(li);
tablet_enabled = libinput_device_config_left_handed_get(tablet_dev);
touch_enabled = libinput_device_config_left_handed_get(touch_dev);
ck_assert_int_eq(tablet_enabled, tablet_from);
libinput_device_config_left_handed_set(tablet_dev, tablet_to);
libinput_device_config_left_handed_set(touch_dev, touch_to);
- libinput_dispatch(li);
+ litest_dispatch(li);
tablet_enabled = libinput_device_config_left_handed_get(tablet_dev);
touch_enabled = libinput_device_config_left_handed_get(touch_dev);
ck_assert_int_eq(tablet_enabled, tablet_to);
tx = 60;
ty = 60;
litest_tablet_proximity_in(tablet, tx, ty, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
libinput_device_config_left_handed_set(tablet->libinput_device,
}
litest_touch_up(finger, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* this will fail once we have location-based touch arbitration on
* touchpads */
litest_assert_only_typed_events(li, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
#endif
litest_tablet_proximity_out(tablet);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
litest_drain_events(li);
x = 10;
y = 30;
litest_touch_down(finger, 0, x, y);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
libinput_device_config_left_handed_set(tablet->libinput_device,
litest_event(dev, EV_ABS, ABS_X, 20000 + 10 * i);
litest_event(dev, EV_ABS, ABS_Y, 20000 - 10 * i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* Wait past the timeout to expect a proximity out */
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* New events should fake a proximity in again */
litest_event(dev, EV_ABS, ABS_X, 20000);
litest_event(dev, EV_ABS, ABS_Y, 20000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (i = 0; i < 10; i++) {
litest_event(dev, EV_ABS, ABS_X, 20000 + 10 * i);
litest_event(dev, EV_ABS, ABS_Y, 20000 - 10 * i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* New events, just to ensure cleanup paths are correct */
litest_event(dev, EV_ABS, ABS_X, 20000);
litest_event(dev, EV_ABS, ABS_Y, 20000);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_event(dev, EV_ABS, ABS_X, 20000 + 10 * i);
litest_event(dev, EV_ABS, ABS_Y, 20000 - 10 * i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(5);
}
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_event(dev, EV_ABS, ABS_X, 20000 + 10 * i);
litest_event(dev, EV_ABS, ABS_Y, 20000 - 10 * i);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* Wait past the timeout to expect a proximity out */
if (with_timeout) {
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
}
/* Send a real prox out, expect quirk to be disabled */
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
if (with_timeout) {
/* we got the proximity event above already */
}
litest_tablet_proximity_in(dev, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
for (i = 0; i < 10; i++) {
litest_tablet_motion(dev, 50 + i, 50 + i, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tablet_proxout();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_TOOL_PEN, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li,
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* Move in a straight line, collect the resulting points */
litest_assert(npoints <= ARRAY_LENGTH(coordinates));
litest_tablet_motion(dev, x, y, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
litest_tablet_proximity_out(dev);
litest_tablet_proximity_in(dev, 10, 10, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* Move in a wobbly line, collect every second point */
/* point off position */
litest_tablet_motion(dev, x - 2, y + 1, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
libinput_event_destroy(event);
/* same position as before */
litest_tablet_motion(dev, x, y, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_proximity_in(dev, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
litest_drain_events(li);
litest_tablet_proximity_in(dev, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
litest_assert_empty_queue(li);
litest_tablet_proximity_out(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
devnode = libevdev_uinput_get_devnode(dev->uinput);
li = litest_create_context();
libinput_path_add_device(li, devnode);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_DEVICE_ADDED);
event = libinput_get_event(li);
libinput_suspend(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
struct libinput_event_tablet_tool *t;
litest_tablet_motion(dev, x + 1, y + 1, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_axis_set_value(axes, ABS_MT_ORIENTATION, 50 + i);
litest_tablet_motion(dev, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_axis_set_value(axes, ABS_MT_ORIENTATION, 50 - i);
litest_tablet_motion(dev, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
litest_drain_events(li);
litest_tablet_proximity_in(dev, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
litest_drain_events(li);
litest_button_click(dev, BTN_0, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
ck_assert_int_eq(libinput_event_tablet_tool_get_button(t), BTN_0);
libinput_event_destroy(event);
litest_button_click(dev, BTN_0, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
devnode = libevdev_uinput_get_devnode(dev->uinput);
li = litest_create_context();
libinput_path_add_device(li, devnode);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_DEVICE_ADDED);
event = libinput_get_event(li);
litest_assert_empty_queue(li);
litest_button_click(dev, BTN_0, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* but buttons after this should be sent */
litest_button_click(dev, BTN_0, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li, BTN_0, LIBINPUT_BUTTON_STATE_PRESSED);
litest_button_click(dev, BTN_0, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li, BTN_0, LIBINPUT_BUTTON_STATE_RELEASED);
litest_destroy_context(li);
litest_drain_events(li);
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_button_event(li,
BTN_0,
/* touches below the totem, cancelled once the totem is down */
litest_touch_down(touch, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_down_frame(li);
litest_touch_move_to(touch, 0, 50, 50, 50, 70, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
while (libinput_next_event_type(li)) {
litest_assert_touch_motion_frame(li);
}
litest_tablet_proximity_in(totem, 50, 70, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_tablet_proximity_event(li, LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_assert_tablet_tip_event(li, LIBINPUT_TABLET_TOOL_TIP_DOWN);
litest_drain_events(li);
litest_tablet_proximity_in(totem, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
litest_drain_events(li);
litest_tablet_proximity_in(totem, 50, 50, NULL);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
litest_touch_down(touch, 0, 81, 51);
litest_touch_move_to(touch, 0, 81, 50, 90, 80, 10);
litest_touch_up(touch, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
}
litest_touch_down(touch, 0, 81, 51);
litest_touch_move_to(touch, 0, 81, 50, 50, 50, 10);
litest_touch_up(touch, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_sequence(li);
litest_drain_events(dev->libinput);
litest_touch_down(dev, 0, 10, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) == LIBINPUT_EVENT_TOUCH_FRAME)
ck_assert_int_eq(have_frame_event, 1);
litest_touch_down(dev, 1, 10, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((event = libinput_get_event(li))) {
if (libinput_event_get_type(event) == LIBINPUT_EVENT_TOUCH_FRAME)
litest_drain_events(li);
litest_touch_down(dev, 0, 10, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_down_frame(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
}
litest_touch_down(dev, 0, 100, 100);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
if (libinput_event_get_type(ev) != LIBINPUT_EVENT_TOUCH_DOWN) {
struct libinput_event *ev;
struct libinput_event_touch *tev;
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, type);
slot = libinput_event_touch_get_slot(tev);
for (slot = 0; slot < num_tps; ++slot)
litest_touch_up(dev, slot);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
type = libinput_event_get_type(ev);
break;
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert_notnull(ev);
ck_assert_int_gt(slot_count, 0);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
do {
type = libinput_event_get_type(ev);
ck_assert_int_ne(type, LIBINPUT_EVENT_TOUCH_DOWN);
slot_count--;
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
} while ((ev = libinput_get_event(libinput)));
ck_assert_int_eq(slot_count, 0);
litest_touch_down(dev, 0, 0, 0);
litest_touch_up(dev, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
litest_restore_log_handler(libinput);
while ((ev = libinput_get_event(libinput))) {
}
libinput_event_destroy(ev);
- libinput_dispatch(libinput);
+ litest_dispatch(libinput);
}
ck_assert(got_down);
litest_touch_down(dev, 0, 100, 100);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
litest_touch_down(dev, 0, 80, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
litest_touch_down(dev, 0, 100, 100);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
struct libinput_device *d;
struct libinput_event *event;
struct libinput_device *device;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
device = libinput_event_get_device(event);
litest_drain_events(li);
litest_touch_down(dev, 0, 5, 95);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
libinput_event_destroy(ev);
litest_touch_move_to(dev, 0, 10, 90, 90, 10, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
if (libinput_event_get_type(ev) ==
}
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_UP);
libinput_event_destroy(ev);
litest_touch_down(dev, 0, 5, 95);
litest_touch_down(dev, 1, 95, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_down_frame(li);
ev = libinput_get_event(li);
for (pos = 10; pos < 100; pos += 10) {
litest_touch_move(dev, 0, pos, 100 - pos);
litest_touch_move(dev, 1, 100 - pos, pos);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
tev = libinput_event_get_touch_event(ev);
}
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
}
END_TEST
litest_touch_down(dev, 0, 70, 60);
litest_touch_up(dev, 0);
- libinput_dispatch(libinput1);
- libinput_dispatch(libinput2);
+ litest_dispatch(libinput1);
+ litest_dispatch(libinput2);
while (libinput_next_event_type(libinput1)) {
ev1 = libinput_get_event(libinput1);
litest_drain_events(dev->libinput);
litest_touch_down(dev, 0, 10, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
tev = litest_is_touch_event(event, LIBINPUT_EVENT_TOUCH_DOWN);
litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, y);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_touch_event(event, LIBINPUT_EVENT_TOUCH_DOWN);
litest_event(dev, EV_ABS, ABS_MT_POSITION_X, x);
litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, y);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
}
/* Touch is still down when device is removed, expect a release */
litest_delete_device(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_CANCEL);
litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 5000);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Expect the mm to be correct regardless */
ev = libinput_get_event(li);
litest_event(dev, EV_ABS, ABS_MT_POSITION_Y, 1000);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Expect the mm to be correct regardless */
ev = libinput_get_event(li);
litest_drain_events(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 70, 70, axes, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_cancel(li);
litest_touch_move_to(dev, 0, 70, 70, 50, 40, 10);
litest_drain_events(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 70, 70, axes, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_cancel(li);
litest_touch_move_to(dev, 0, 70, 70, 50, 40, 10);
litest_drain_events(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 70, 70, axes, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_cancel(li);
litest_touch_move_to(dev, 1, 50, 50, 70, 70, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_motion_frame(li);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
litest_touch_move_to(dev, 0, 70, 70, 50, 40, 10);
litest_drain_events(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 70, 70, axes, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_cancel(li);
litest_touch_move_to(dev, 1, 50, 50, 70, 70, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_motion_frame(li);
litest_axis_set_value(axes, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER);
litest_assert_empty_queue(li);
litest_touch_move_to(dev, 1, 70, 70, 50, 40, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_motion_frame(li);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
litest_touch_move_to(dev, 0, 70, 70, 50, 40, 10);
litest_drain_events(li);
litest_touch_move_to(dev, 1, 50, 50, 70, 70, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_motion_frame(li);
/* ABS_MT_TOOL_TYPE never reset to finger, so a new touch
litest_assert_empty_queue(li);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_touch_up_frame(li);
}
END_TEST
litest_drain_events(li);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 2);
litest_touch_up(dev, 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_down(dev, 0, 90, 15);
litest_touch_down(dev, 1, 10, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, 0, 95, 95);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
break;
}
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
}
END_TEST
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
- libinput_dispatch(li);
+ litest_dispatch(li);
ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
/* now put a second finger down */
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
/* move out of the area, then wait for softbutton timer */
litest_touch_move_to(dev, 0, 20, 90, 50, 50, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_softbuttons();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* move down left, expect motion */
litest_touch_move_to(dev, 0, 50, 50, 20, 90, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
while (event) {
nevents++;
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
}
litest_touch_down(dev, 1, 20, 20);
litest_touch_move_to(dev, 1, 20, 20, 80, 20, 25);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
while (event) {
}
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
}
litest_touch_up(dev, 1);
litest_touch_down(dev, 1, 20, 20);
litest_touch_move_to(dev, 1, 20, 20, 20, 80, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
while (event) {
ck_assert(y > 0);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
}
litest_drain_events(li);
litest_hover_start(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_hover_move_to(dev, 0, 50, 50, 90, 90, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 90, 90, 91, 91, 1);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
litest_drain_events(li);
litest_touch_down(dev, 0, 80, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_softbuttons();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_drain_events(li);
litest_touch_down(dev, 0, 80, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_softbuttons();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_softbuttons();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_down(dev, 0, 30, 95);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* actual config is delayed, but status is immediate */
status = libinput_device_config_middle_emulation_set_enabled(device,
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_assert_button_event(li,
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
button,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_timeout_tapndrag();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
event = libinput_get_event(li);
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
event = libinput_get_event(li);
LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_button_event(li,
button,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 30, 50, 10);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
event = libinput_get_event(li);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_button_event(li,
button,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
event = libinput_get_event(li);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
event = libinput_get_event(li);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
event = libinput_get_event(li);
LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_button_event(li,
button,
litest_touch_down(dev, 0, 40, 30);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(100);
switch (nfingers) {
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(100);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
litest_assert_button_event(li, button,
LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
event = libinput_get_event(li);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps < range; ntaps++) {
event = libinput_get_event(li);
litest_touch_down(dev, 0, 70, 50);
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
* immediately, not after a timeout that the helper functions may
* trigger.
*/
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_is_button_event(event,
litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 80, 80, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_down(dev, 0, 50, 50);
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li, button,
litest_assert_empty_queue(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_button_event(li, button,
break;
}
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li, button,
litest_assert_empty_queue(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tapndrag();
litest_assert_empty_queue(li);
break;
}
litest_touch_down(dev, 0, 30, 70);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 1, 80, 70);
litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
}
/* Two fingers down + move to trigger scrolling */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev, 50, 50, 70, 50, 0, 20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 0);
/* Two fingers down + move to trigger scrolling */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev, 50, 50, 70, 50, 0, 20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
litest_touch_down(dev, 0, 30, 70);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 1, 80, 90);
litest_touch_move_to(dev, 0, 30, 70, 30, 30, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
}
/* 1fg down triggers the drag */
litest_touch_down(dev, 0, 30, 70);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* 2fg is allowed now without cancelling the drag */
litest_touch_down(dev, 1, 80, 90);
litest_touch_move_to(dev, 0, 30, 70, 30, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
/* Putting down a third finger should end the drag */
litest_touch_down(dev, 2, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_touch_down(dev, 0, 30, 50);
litest_touch_down(dev, 1, 50, 50);
litest_touch_down(dev, 2, 80, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_three_touches(dev,
30, 50,
50, 50,
80, 50,
0, 20,
10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, 0, 30, 50);
litest_touch_down(dev, 1, 50, 50);
litest_touch_down(dev, 2, 80, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_three_touches(dev,
30, 50,
50, 50,
80, 50,
0, 20,
10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ptrev = litest_is_button_event(ev,
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ptrev = litest_is_button_event(ev,
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
litest_touch_down(dev, 1, 70, 70);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_touch_down(dev, 1, 70, 70);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_event(dev, EV_KEY, BTN_TOUCH, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
-> no event
*/
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
litest_timeout_tap();
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
litest_drain_events(dev->libinput);
litest_touch_down(dev, 1, 70, 50);
*/
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
litest_touch_move_to(dev, 1, 70, 50, 90, 90, 10);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(dev->libinput);
+ litest_dispatch(dev->libinput);
while ((event = libinput_get_event(li))) {
ck_assert_int_ne(libinput_event_get_type(event),
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
litest_touch_up(dev, (i + 1) % 3);
litest_touch_up(dev, (i + 0) % 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ptrev = litest_is_button_event(ev,
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (i = 0; i < 2; i++) {
ev = libinput_get_event(li);
litest_event(dev, EV_KEY, BTN_TOUCH, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_button_event(li, BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_RELEASED);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
/* drop below the pressure threshold in the same frame as starting a
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_push_event_frame(dev);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 50, 50, 50, 70, 10);
litest_touch_move_to(dev, 1, 70, 50, 50, 70, 10);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_push_event_frame(dev);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
/* Pointer jump should be ignored */
litest_touch_move_to(dev, 0, 50, 50, 20, 20, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* touch 2 and TRIPLETAP down */
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* touch 2 up, coordinate jump + ends slot 1, TRIPLETAP stays */
litest_event(dev, EV_ABS, ABS_Y, 3800);
litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* slot 2 reactivated
litest_event(dev, EV_ABS, ABS_Y, 3200);
litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_restore_log_handler(li);
/* now end all three */
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_drain_events(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* third finger tap without the other two fingers moving */
litest_touch_down(dev, 2, 60, 40);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_up(dev, (i + 1) % 4);
litest_touch_up(dev, (i + 0) % 4);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_TOUCH, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
}
/* move finger 1 */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 70, 30, 70, 60, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* lift finger 1, put it back */
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 40, 30);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* lift fingers up */
switch(nfingers) {
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_no_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
}
litest_touch_up(dev, (i + 1) % 5);
litest_touch_up(dev, (i + 0) % 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_TOUCH, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 70);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_set_tap_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LMR);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 90, 90, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
break;
}
msleep(10); /* to force a time difference */
- libinput_dispatch(li);
+ litest_dispatch(li);
switch (nfingers) {
case 3:
litest_touch_up(dev, 2);
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
ev = libinput_get_event(li);
ptrev = litest_is_button_event(ev,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
event = libinput_get_event(li);
litest_touch_down_extended(dev, 0, 50, 50, axes);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
/* Finger down is palm after tap timeout */
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_move_to_extended(dev, 0, 60, 60, 60, 60, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
switch (nfingers2) {
case 3:
litest_touch_up(dev, 1);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, this, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, other, 60, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, other, 60, 50, 65, 50, 10);
litest_assert_only_typed_events(li,
litest_touch_up(dev, this);
litest_touch_up(dev, other);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_drain_events(li);
litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, this);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, this, 70, 70);
litest_touch_up(dev, this);
litest_touch_up(dev, other);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_drain_events(li);
litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, this);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, (this + 1) % 3);
litest_touch_up(dev, (this + 2) % 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, (this + 2) % 3, 70, 50);
litest_drain_events(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, this);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, this, 50, 50);
litest_touch_up(dev, this);
litest_touch_up(dev, (this + 1) % 3);
litest_touch_up(dev, (this + 2) % 3);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_drain_events(li);
litest_touch_move_to_extended(dev, this, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, this);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, (this + 1) % 4);
litest_touch_up(dev, (this + 2) % 4);
litest_touch_up(dev, 0);
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
button,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
litest_assert_button_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
litest_assert_button_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* keep palm finger down */
for (ntaps = 0; ntaps <= range; ntaps++) {
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= 2 * range + 1; ntaps++) {
litest_assert_button_event(li,
break;
}
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
}
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* keep palm finger down */
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (ntaps = 0; ntaps <= range; ntaps++) {
litest_assert_button_event(li,
litest_drain_events(li);
litest_touch_down_extended(dev, 0, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, true);
litest_button_click(dev, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_LEFT,
litest_drain_events(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_keyboard_key(keyboard, KEY_B, false);
litest_drain_events(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Changes to palm after dwt timeout */
litest_touch_move_to_extended(dev, 0, 50, 50, 50, 50, axes, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_down(dev, 1, 55, 55);
litest_touch_down(dev, 2, 99, 55); /* edge palm */
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 2); /* release the palm */
litest_assert_empty_queue(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li, BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_button_event(li, BTN_RIGHT,
litest_touch_move_to(dev, 0, 50, 50, 80, 50, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
while (event) {
/* Avoid a small scroll being seen as a tap */
if (want_sleep) {
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
START_TEST(touchpad_2fg_scroll)
/* start diagonally */
ydelta = 15 * ratio;
litest_touch_move_two_touches(dev, 45, 30, 55, 30, 15, ydelta, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
litest_drain_events(li);
/* both high-resolution and low-resolution events are generated */
expected_nevents *= 2;
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
do {
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
/* Move roughly straight horizontally for >100ms to set axis lock */
litest_touch_move_two_touches(dev, 20, 20, 25, 20, 55, 10, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
litest_drain_events(li);
msleep(200);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Move roughly vertically for >100ms to switch axis lock. This will
* contain some horizontal movement while the lock changes; don't
* check for single-axis yet
*/
litest_touch_move_two_touches(dev, 75, 30, 80, 30, 2, 20, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
litest_drain_events(li);
/* Move some more, roughly vertically, and check new axis lock */
litest_touch_move_two_touches(dev, 77, 50, 82, 50, 1, 40, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
/* Move in a clear diagonal direction to ensure the lock releases */
litest_touch_move_two_touches(dev, 78, 90, 83, 90, -60, -60, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
}
END_TEST
litest_touch_move_two_touches(dev, 49, 50, 51, 50, 0, y_move, 100);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_touch_down(dev, 0, 20, 20);
litest_touch_down(dev, 1, 30, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev,
20, 20,
30, 20,
litest_touch_down(dev, 1, 51, 50);
litest_touch_move_two_touches(dev, 49, 50, 51, 50, 0, 20, 5);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_finger_switch();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
litest_touch_move_to(dev, 0, 49, 70, 49, 50, 10);
litest_touch_down(dev, 1, 51, 50);
litest_touch_move_two_touches(dev, 49, 50, 51, 50, 0, 20, 5);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_finger_switch();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
/* move with second finger */
litest_touch_down(dev, 0, 30, 95);
litest_touch_down(dev, 1, 50, 95);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* First finger moves out of the area first but it's a scroll
* motion, should not trigger POINTER_MOTION */
for (int i = 0; i < 5; i++) {
litest_touch_move(dev, 0, 30, 95 - i);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
for (int i = 0; i < 20; i++) {
litest_touch_move(dev, 0, 30, 90 - i);
litest_touch_move(dev, 1, 50, 95 - i);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_touch_move_to(dev, 0, 99, 20, 99, 80, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_touch_move_to(dev, 0, 99, 80, 99, 20, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_touch_move_to(dev, 0, 99, 20, 99, 80, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_touch_move_to(dev, 0, 99, 80, 99, 20, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_touch_move_to(dev, 0, 20, 99, 70, 99, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
litest_touch_move_to(dev, 0, 70, 99, 20, 99, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
litest_touch_move_to(dev, 0, 20, 99, 70, 99, 15);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
litest_touch_move_to(dev, 0, 70, 99, 20, 99, 15);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
/* move 0.5mm, enough to load up the motion history, but less than
* the scroll threshold of 2mm */
litest_touch_down(dev, 0, 99, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_hysteresis();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 99, 20, 99, 20 + mm/2, 8);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_timeout_edgescroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* now move slowly up to the 2mm scroll threshold. we expect events */
litest_touch_move_to(dev, 0, 99, 20 + mm/2, 99, 20 + mm * 2, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
/* moving down outside edge once scrolling had started -> scroll */
litest_touch_move_to(dev, 0, 20, 70, 40, 99, 12);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_touch_move_to(dev, 0, 20, 20, 99, 20, 22);
litest_touch_move_to(dev, 0, 99, 20, 99, 80, 22);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 49, 50);
litest_touch_down(dev, 1, 51, 50);
litest_touch_move_two_touches(dev, 49, 50, 51, 50, 20, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_axis_end_sequence(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_axis_end_sequence(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_touch_move_to(dev, 0, 99, 50, 0, 70, 25);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_move_to(dev, 0, 50, 1, 50, 60, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_drain_events(li);
litest_touch_move_to(dev, 0, 99, 50, 99, 90, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_drain_events(li);
litest_touch_move_to(dev, 0, 0, 2, 50, 50, 15);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_touch_down(dev, 0, 50, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 95, 5);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 5, 5);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 5, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 95, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
* the palm detection edge zone -> expect palm detection */
litest_touch_down(dev, 0, 99, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 1, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
* not in the palm detection edge zone -> expect taps */
litest_touch_down(dev, 0, 10, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li,
litest_touch_down(dev, 0, 90, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li,
* inside the palm detection edge zone*/
litest_touch_down(dev, 0, 95, 5);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 5, 5);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 5, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 95, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, MT_TOOL_PALM);
litest_touch_down(dev, 0, 50, 50);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 50, 50, 50, 80, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER);
litest_touch_up(dev, 0);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
litest_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, MT_TOOL_PALM);
litest_touch_down(dev, 0, 50, 50);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 50, 80);
litest_touch_move_extended(dev, 0, 51, 99, axes);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_empty_queue(li);
/* make sure normal tap still works */
litest_touch_down(dev, 0, 50, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
}
/* event in state HOLD is thumb */
litest_touch_down(dev, 0, 50, 99);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_extended(dev, 0, 51, 99, axes);
litest_touch_up(dev, 0);
litest_assert_empty_queue(li);
/* make sure normal tap still works */
litest_touch_down(dev, 0, 50, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
}
/* event in state HOLD is thumb */
litest_touch_down(dev, 0, 50, 99);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_extended(dev, 0, 51, 99, axes);
litest_assert_empty_queue(li);
litest_assert_empty_queue(li);
/* timeout -> into HOLD, no event on release */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 1);
litest_assert_empty_queue(li);
/* make sure normal tap still works */
litest_touch_down(dev, 0, 50, 99);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
}
litest_touch_down(dev, 0, 50, 99);
litest_touch_move(dev, 0, 51, 99);
litest_touch_move_extended(dev, 0, 55, 99, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* thumb is resting, check if tapping still works */
litest_touch_down(dev, 1, 50, 50);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_button_event(li,
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 70, 80, 90, 10);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 80, 90, 50, 20, axes, 10);
litest_touch_up(dev, 0);
litest_touch_down(dev, 0, 99, 50);
litest_touch_move_to_extended(dev, 0, 99, 50, 20, 50, axes, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
litest_assert_empty_queue(li);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* after dwt timeout, pressure blocks events */
litest_touch_move_to(dev, 0, 50, 50, 80, 99, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
}
END_TEST
litest_touch_down(dev, 0, 50, 50);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Tapping is unaffected by left-handed setting */
litest_assert_button_event(li,
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Tapping is unaffected by left-handed setting */
litest_assert_button_event(li,
litest_drain_events(li);
litest_button_click(dev, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* left-handed takes effect now */
litest_button_click(dev, BTN_RIGHT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_middlebutton();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 0);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_touch_down(dev, 0, 10, 90);
litest_button_click(dev, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_touch_down(dev, 0, 90, 90);
litest_button_click(dev, BTN_LEFT, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 0);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 80);
litest_touch_move_to(dev, 0, 20, 80, 80, 20, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_event(dev, EV_ABS, ABS_PRESSURE, 50);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (i = 0; i < 10; i++) {
x -= 200;
y += 200;
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
ck_assert_int_ne(libinput_next_event_type(li),
LIBINPUT_EVENT_NONE);
ck_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
/* go back to hover */
litest_event(dev, EV_ABS, ABS_PRESSURE, 50);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (j = 0; j < 5; j++) {
x += 200;
litest_event(dev, EV_SYN, SYN_REPORT, 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_move_to(dev, 0, 50, 50, 70, 70, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
}
litest_event(dev, EV_ABS, ABS_PRESSURE, 50);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* now move the finger */
for (i = 0; i < 10; i++) {
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_KEY, BTN_TOUCH, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
END_TEST
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
}
/* touch the finger on the sensor */
litest_touch_move_to(dev, 0, 70, 70, 50, 50, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
/* touch the finger */
litest_touch_move_to(dev, 0, 70, 70, 50, 50, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
litest_hover_start(dev, 0, 50, 50);
litest_hover_end(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
struct libinput *li = device->libinput;
struct libinput_event *e;
- libinput_dispatch(li);
+ litest_dispatch(li);
e = libinput_get_event(li);
litest_is_button_event(e, button, state);
litest_drain_events(li);
litest_button_click(touchpad, BTN_2, true); /* middle */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_buttonscroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(trackpoint, EV_REL, REL_Y, -2);
litest_event(trackpoint, EV_SYN, SYN_REPORT, 0);
litest_event(trackpoint, EV_REL, REL_Y, -2);
litest_touch_down(touchpad, 1, 60, 70);
litest_touch_move_two_touches(touchpad, 40, 70, 60, 70, 0, -40, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event(li);
/* Make sure we get scroll events but _not_ the scroll release */
litest_touch_up(touchpad, 0);
litest_touch_up(touchpad, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_touch_down(dev, 0, x, y);
litest_touch_move_to(dev, 0, x, y, 70, 70, 10);
litest_touch_up(dev, 0);
- libinput_dispatch(libinput1);
- libinput_dispatch(libinput2);
+ litest_dispatch(libinput1);
+ litest_dispatch(libinput2);
litest_wait_for_event(libinput1);
litest_wait_for_event(libinput2);
break;
litest_touch_move(dev, i, 20 + 10 * i + x, 30);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
for (int i = 0; i < finger_count; i++) {
} else {
litest_event(dev, EV_KEY, map[finger_count], 0);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_empty_queue(li);
litest_disable_hold_gestures(dev->libinput_device);
litest_touch_down(dev, 0, 10, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Force a SYN_DROPPED */
for (int i = 0; i < 500; i++)
litest_touch_down(dev, 0, 50, 50);
litest_touch_down(dev, 1, 70, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_drain_events(li);
litest_touch_up(dev, 0);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* after timeout - motion events*/
litest_touch_down(touchpad, 0, 50, 50);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* after timeout - motion events*/
litest_touch_down(touchpad, 0, 50, 50);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
/* finger down after last key event, but
litest_assert_empty_queue(li);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* same touch after timeout - motion events*/
litest_touch_move_to(touchpad, 0, 70, 50, 50, 50, 10);
/* touch still down - no events */
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(touchpad, 0, 70, 50, 30, 50, 5);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
/* touch still down - no events */
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(touchpad, 0, 30, 50, 50, 50, 5);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
/* expire timeout */
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Touch starting after re-issuing the dwt timeout */
litest_touch_down(touchpad, 0, 50, 50);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
for (i = 0; i < 5; i++) {
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_assert_empty_queue(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
for (i = 0; i < 5; i++) {
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_assert_empty_queue(li);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
ARRAY_FOR_EACH(modifiers, key) {
litest_keyboard_key(keyboard, *key, true);
litest_keyboard_key(keyboard, *key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
litest_keyboard_key(keyboard, *key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
}
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5);
litest_touch_up(touchpad, 0);
litest_keyboard_key(keyboard, KEY_B, true);
litest_keyboard_key(keyboard, KEY_B, false);
litest_keyboard_key(keyboard, *key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
litest_keyboard_key(keyboard, *key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_touch_down(touchpad, 0, 50, 50);
litest_assert_empty_queue(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_delete_device(keyboard);
ARRAY_FOR_EACH(modifiers, key) {
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* this can't really be tested directly. The above key
* should enable dwt, the next key continues and extends the
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
litest_keyboard_key(keyboard, *key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_assert_empty_queue(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
}
litest_delete_device(keyboard);
litest_keyboard_key(keyboard, key, true);
litest_keyboard_key(keyboard, key, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_up(touchpad, 0);
litest_drain_events(li);
litest_keyboard_key(keyboard, KEY_A, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(1); /* make sure touch starts after key press */
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(touchpad, 0, 70, 50, 50, 50, 5);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_down(touchpad, 0, 50, 50);
litest_button_click(touchpad, BTN_LEFT, true);
litest_button_click(touchpad, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_touch_down(touchpad, 0, 99, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_edgescroll();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* edge scroll timeout is 300ms atm, make sure we don't accidentally
exit the DWT timeout */
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_touch_move_to(touchpad, 0, 99, 20, 99, 80, 60);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_touch_move_to(touchpad, 0, 99, 80, 99, 20, 60);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_delete_device(keyboard);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 99, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_edgescroll();
litest_touch_move_to(touchpad, 0, 99, 20, 99, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_axis_events(li, LIBINPUT_EVENT_POINTER_SCROLL_FINGER);
litest_keyboard_key(keyboard, KEY_A, true);
litest_assert_empty_queue(li);
litest_timeout_dwt_long();
- libinput_dispatch(li);
+ litest_dispatch(li);
disable_dwt(touchpad);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
disable_dwt(touchpad);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* touch down during timeout -> still discarded */
litest_touch_down(touchpad, 0, 50, 50);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
disable_dwt(touchpad);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_keyboard_key(keyboard, KEY_A, false);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
/* touch down during timeout, wait, should generate events */
litest_touch_down(touchpad, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_dwt_long();
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
disable_dwt(touchpad);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* touch down during timeout, wait, should generate events */
litest_touch_down(touchpad, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_dwt_long();
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
enable_dwt(touchpad);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_KEYBOARD_KEY);
litest_touch_down(touchpad, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
enable_dwt(touchpad);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_delete_device(apple_keyboard);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
litest_touch_up(touchpad, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
litest_delete_device(keyboard);
touchpad = litest_add_device(li, LITEST_SYNAPTICS_RMI4);
ck_assert(has_disable_while_typing(touchpad));
- libinput_dispatch(li);
+ litest_dispatch(li);
/* remove the touchpad before the keyboard.
* this test can fail in valgrind only */
* despite slot 0 exceeding the speed threshold earlier */
litest_touch_down(dev, 1, 50, 50);
litest_touch_down(dev, 2, 55, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
for (int i = 0, y = 50; i < 10; i++, y++) {
litest_touch_move_to(dev, 1, 50, y, 50, y + 1, 1);
litest_touch_move_to(dev, 2, 55, y, 55, y + 1, 1);
}
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 1);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
litest_drain_events(li);
litest_touch_down(dev, 0, 50, 99); /* thumb */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 1, 60, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_LEFT,
litest_drain_events(li);
litest_touch_down(dev, 1, 60, 99); /* thumb */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 0, 50, 50);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_LEFT,
litest_drain_events(li);
litest_touch_down(dev, 0, 90, 99); /* thumb */
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click(dev, BTN_LEFT, true);
/* button areas work as usual with a thumb */
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_RIGHT,
* detection.
*/
msleep(200);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 1, 70, 99);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev, 50, 99, 70, 99, 0, -20, 10);
litest_touch_up(dev, 0);
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* touch 2 down */
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* touch 3 down, coordinate jump + ends slot 1 */
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* slot 2 reactivated */
litest_event(dev, EV_ABS, ABS_Y, 4000);
litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(2);
/* now a click should trigger middle click */
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event(li);
event = libinput_get_event(li);
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 1);
litest_event(dev, EV_KEY, BTN_TOUCH, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
/* touch 2 and TRIPLETAP down */
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
/* touch 2 up, coordinate jump + ends slot 1, TRIPLETAP stays */
litest_event(dev, EV_ABS, ABS_Y, 4000);
litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
/* slot 2 reactivated */
litest_event(dev, EV_ABS, ABS_Y, 4000);
litest_event(dev, EV_ABS, ABS_PRESSURE, 78);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
msleep(10);
litest_restore_log_handler(li);
/* now a click should trigger middle click */
litest_event(dev, EV_KEY, BTN_LEFT, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event(li);
event = libinput_get_event(li);
second = 1 - first;
litest_touch_down(dev, 0, start[0][0], start[0][1]);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(dev, 1, start[1][0], start[1][1]);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_two_touches(dev,
start[first][0],
start[second][0] + 30,
start[second][1] + 30.1);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* If a gesture was detected, we need to go past the gesture
* timeout to trigger events. So let's move a bit first to
* make sure it looks continuous, then wait, then move again
start[first][0] + 30,
start[first][1] + 30,
50, 21, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_gesture();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* drain a potential scroll stop */
litest_drain_events(li);
litest_touch_move_to(dev, second, 50, 21, 50, 11, 20);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
do {
struct libinput_event_pointer *ptrev;
litest_touch_move_to(dev, 0, 50, 50, 80, 50, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
litest_touch_up(dev, 0);
/* expect lots of little events, no big jump */
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
do {
struct libinput_event_pointer *ptrev;
litest_touch_up(dev, 0);
/* expect lots of little events, no big jump */
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
do {
struct libinput_event_pointer *ptrev;
litest_touch_down(dev, 0, 30, 50);
litest_touch_down_extended(dev, 1, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 30, 50, 80, 80, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
litest_touch_move_to_extended(dev, 1, 50, 50, 80, 80, axes, 10);
litest_drain_events(li);
litest_touch_down_extended(dev, 0, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_TOOL_FINGER, 0);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 50, 50, 80, 80, axes, 10);
litest_assert_empty_queue(li);
}
litest_drain_events(li);
litest_touch_down_extended(dev, 0, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_assert_empty_queue(li);
}
/* tap but too light */
litest_touch_down_extended(dev, 0, 40, 50, axes);
litest_touch_down_extended(dev, 1, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_assert_empty_queue(li);
/* double-tap with one finger too light */
litest_touch_down(dev, 0, 40, 50);
litest_touch_down_extended(dev, 1, 50, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
libinput_event_destroy(event);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
/* Two light touches down, doesn't count */
litest_touch_down_extended(dev, 0, 40, 50, axes);
litest_touch_down_extended(dev, 1, 45, 50, axes);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* Tripletap but since no finger is logically down, it doesn't count */
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* make one finger real */
litest_touch_move(dev, 0, 40, 50);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_button_event(li,
BTN_MIDDLE,
litest_touch_move_extended(dev, 0, 40, 31, axes);
litest_touch_move_extended(dev, 1, 60, 31, axes);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_scroll(li,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
litest_touch_move_extended(dev, 0, 40, 40, axes);
litest_touch_move_extended(dev, 1, 60, 40, axes);
litest_pop_event_frame(dev);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
}
END_TEST
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 70, 80, 90, 10);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 80, 90, 50, 20, axes, 10);
litest_touch_up(dev, 0);
litest_assert_only_typed_events(li,
litest_touch_down(dev, 0, 50, 50);
litest_touch_move_to(dev, 0, 50, 70, 80, 90, 10);
litest_drain_events(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to_extended(dev, 0, 80, 90, 50, 20, axes, 10);
litest_touch_up(dev, 0);
litest_assert_empty_queue(li);
litest_touch_down(dev, 0, 99, 50);
litest_touch_move_to_extended(dev, 0, 99, 50, 20, 50, axes, 20);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
litest_assert_empty_queue(li);
litest_timeout_dwt_short();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_assert_empty_queue(li);
/* after dwt timeout, pressure blocks events */
litest_touch_move_to(dev, 0, 20, 20, 85, 80, 20);
litest_touch_down(dev, 1, 20, 80);
litest_touch_move_two_touches(dev, 85, 80, 20, 80, -20, -20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_drain_events(li);
litest_touch_down(dev, 1, 79, 80);
litest_touch_move_two_touches(dev, 80, 80, 79, 80, -20, -20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
litest_drain_events(li);
litest_touch_down(dev, 1, 59, 80);
litest_touch_move_two_touches(dev, 60, 80, 59, 80, -20, -20, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 1);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_pop_event_frame(dev);
litest_touch_move_two_touches(dev, 59, 70, 65, 70, 0, 30, 10);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 2);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
litest_touch_down(dev, 0, 50, 50);
litest_touch_move(dev, 0, 50.1, 50.1);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_push_event_frame(dev);
litest_touch_up(dev, 0);
litest_pop_event_frame(dev);
litest_disable_log_handler(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_restore_log_handler(li);
litest_assert_empty_queue(li);
litest_timeout_tap();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_move_to(dev, 0, 50.2, 50.2, 50, 70, 10);
litest_touch_up(dev, 0);
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
litest_event(dev, EV_REL, REL_Y, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
litest_event(dev, EV_REL, REL_Y, 1);
litest_event(dev, EV_REL, REL_X, 1);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click_debounced(touchpad, li, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_RIGHT,
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click_debounced(touchpad, li, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_LEFT,
ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_button_click_debounced(touchpad, li, BTN_LEFT, true);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event,
BTN_RIGHT,
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_dispatch(li);
}
litest_drain_events(li);
litest_assert_empty_queue(li);
litest_timeout_trackpoint();
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_touch_down(touchpad, 0, 30, 30);
litest_touch_move_to(touchpad, 0, 30, 30, 80, 80, 10);
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_dispatch(li);
}
litest_drain_events(li);
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_dispatch(li);
}
litest_drain_events(li);
litest_assert_empty_queue(li);
litest_timeout_trackpoint();
- libinput_dispatch(li);
+ litest_dispatch(li);
/* touch started after last tp event, expect resume */
litest_touch_move_to(touchpad, 0, 80, 80, 30, 30, 10);
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_dispatch(li);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 30, 30);
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_dispatch(li);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 30, 30);
ck_assert_int_ge(fd, 0);
/* expect at least one event */
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
fd = libinput_get_fd(li);
ck_assert_int_ge(fd, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert(event == NULL);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Drop any events from other devices */
litest_drain_events(li);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
/* Drop any events from other devices */
litest_drain_events(li);
seat2_name);
ck_assert_int_eq(rc, 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_int_eq(libinput_event_get_type(event),
ck_assert_int_ge(fd, 0);
/* expect at least one event */
- ck_assert_int_ge(libinput_dispatch(li), 0);
+ ck_assert_int_ge(litest_dispatch(li), 0);
event = libinput_get_event(li);
ck_assert_notnull(event);
ck_assert_int_ge(fd, 0);
/* expect at least one event */
- ck_assert_int_ge(libinput_dispatch(li), 0);
+ ck_assert_int_ge(litest_dispatch(li), 0);
event = libinput_get_event(li);
ck_assert_notnull(event);
ck_assert_int_ge(fd, 0);
/* Check that at least one device was discovered after creation. */
- ck_assert_int_ge(libinput_dispatch(li), 0);
+ ck_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
ck_assert_int_gt(num_devices, 0);
/* Check that after a suspend, no devices are left. */
libinput_suspend(li);
- ck_assert_int_ge(libinput_dispatch(li), 0);
+ ck_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
ck_assert_int_eq(num_devices, 0);
/* Check that after a resume, at least one device is discovered. */
libinput_resume(li);
- ck_assert_int_ge(libinput_dispatch(li), 0);
+ ck_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
ck_assert_int_gt(num_devices, 0);
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
if (libinput_event_get_type(ev) !=
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
libinput_resume(li);
- libinput_dispatch(li);
+ litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
li = libinput_udev_create_context(&simple_interface, NULL, udev);
ck_assert_notnull(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_DEVICE_ADDED);
event = libinput_get_event(li);
litest_restore_log_handler(li);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
ck_assert_notnull(event);
ck_assert_str_ne(devname, name);
}
libinput_event_destroy(event);
- libinput_dispatch(li);
+ litest_dispatch(li);
event = libinput_get_event(li);
}
projects / platform / upstream / libinput.git / commitdiff