Part-of: <https://gitlab.freedesktop.org/libinput/libinput/-/merge_requests/1059>
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED | bit(4));
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
modes);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* DISABLED supersedes the rest, expect the rest to be dropped */
modes = libinput_device_config_send_events_get_mode(device);
- litest_assert_int_eq(modes, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
+ litest_assert_enum_eq(modes, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
}
END_TEST
device = dev->libinput_device;
mode = libinput_device_config_send_events_get_mode(device);
- litest_assert_int_eq(mode,
+ litest_assert_enum_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
mode = libinput_device_config_send_events_get_default_mode(device);
- litest_assert_int_eq(mode,
+ litest_assert_enum_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
/* event from re-enabled device */
litest_dispatch(li);
event = libinput_get_event(li);
litest_assert_notnull(event);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* after disabling sendevents we require a touch up */
litest_dispatch(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* expect above events */
litest_wait_for_event(li);
while ((event = libinput_get_event(li)) != NULL) {
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
}
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
}
libinput_device_ref(device1);
status = libinput_device_config_send_events_set_mode(device1,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device1,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* can't really check for much here, other than that if we pump
events through libinput, none of them should be from the first
libinput_device_ref(device);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* can't really check for much here, this really just exercises the
code path. */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
ptrevent = libinput_event_get_pointer_event(event);
litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
(unsigned int)BTN_LEFT);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_KEYBOARD_KEY);
kbdevent = libinput_event_get_keyboard_event(event);
litest_assert_int_eq(libinput_event_keyboard_get_key(kbdevent),
(unsigned int)KEY_A);
- litest_assert_int_eq(libinput_event_keyboard_get_key_state(kbdevent),
+ litest_assert_enum_eq(libinput_event_keyboard_get_key_state(kbdevent),
LIBINPUT_KEY_STATE_RELEASED);
libinput_event_destroy(event);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* tap happened before suspending, so we still expect the event */
litest_timeout_tap();
/* resume, make sure we don't get anything */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_dispatch(li);
litest_assert_empty_queue(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_dispatch(li);
litest_touch_up(dev, 0);
/* disable */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_button_event(li,
BTN_RIGHT,
/* resume, make sure we don't get anything */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_dispatch(li);
litest_assert_empty_queue(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_touch_down(dev, 0, 90, 10);
litest_wait_for_event(li);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
litest_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
(unsigned int)BTN_RIGHT);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
litest_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
(unsigned int)BTN_RIGHT);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
0);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
}
END_TEST
litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_ENABLED);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_ENABLED);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, -1),
+ litest_assert_enum_eq(libinput_device_config_gesture_set_hold_enabled(device, -1),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, 2),
+ litest_assert_enum_eq(libinput_device_config_gesture_set_hold_enabled(device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_ENABLED);
- litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
+ litest_assert_enum_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
}
END_TEST
litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
0);
- litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
- litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_ENABLED),
+ litest_assert_enum_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_ENABLED),
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
+ litest_assert_enum_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
litest_assert_notnull(kev);
litest_assert_int_eq(libinput_event_keyboard_get_key(kev),
(unsigned int)KEY_A);
- litest_assert_int_eq(libinput_event_keyboard_get_key_state(kev),
+ litest_assert_enum_eq(libinput_event_keyboard_get_key_state(kev),
LIBINPUT_KEY_STATE_RELEASED);
--expected_key_button_count;
litest_assert_event_type(event, LIBINPUT_EVENT_KEYBOARD_KEY);
kevent = libinput_event_get_keyboard_event(event);
- litest_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
- LIBINPUT_KEY_STATE_RELEASED);
+ litest_assert_enum_eq(libinput_event_keyboard_get_key_state(kevent),
+ LIBINPUT_KEY_STATE_RELEASED);
key = libinput_event_keyboard_get_key(kevent);
valid_code = 0;
enum libinput_config_status status;
method = libinput_device_config_scroll_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
method = libinput_device_config_scroll_get_default_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_2FG);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_EDGE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
li = libinput_path_create_context(&simple_interface, NULL);
pri = libinput_log_get_priority(li);
- litest_assert_int_eq(pri, LIBINPUT_LOG_PRIORITY_ERROR);
+ litest_assert_enum_eq(pri, LIBINPUT_LOG_PRIORITY_ERROR);
libinput_unref(li);
}
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_left_handed_get(device),
1);
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
#if HAVE_LIBWACOM
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
ev1 = libinput_get_event(libinput1);
ev2 = libinput_get_event(libinput2);
- litest_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_enum_eq(libinput_event_get_type(ev1),
LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE);
- litest_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_enum_eq(libinput_event_get_type(ev1),
libinput_event_get_type(ev2));
p1 = libinput_event_get_pointer_event(ev1);
litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_BUTTON);
pevent = libinput_event_get_pointer_event(event);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(pevent),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(pevent),
LIBINPUT_BUTTON_STATE_RELEASED);
button = libinput_event_pointer_get_button(pevent);
enum libinput_config_status status;
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 1);
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
litest_assert_notnull(tev);
litest_assert_int_eq(libinput_event_pointer_get_button(tev),
(unsigned int)BTN_LEFT);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
++expected_seat_button_count;
litest_assert_notnull(tev);
litest_assert_int_eq(libinput_event_pointer_get_button(tev),
(unsigned int)BTN_LEFT);
- litest_assert_int_eq(libinput_event_pointer_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_pointer_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
--expected_seat_button_count;
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
enum libinput_config_status status;
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
/* Change while button is down, expect correct release event */
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_button_click_debounced(dev, li, BTN_LEFT, 0);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* No left-handed until all buttons were down */
litest_button_click_debounced(dev, li, BTN_RIGHT, 1);
enum libinput_config_status status;
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_button(device, BTN_LEFT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button(device, BTN_MIDDLE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button(device, button);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button_lock(device,
LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
START_TEST(pointer_scroll_button_lock)
enum libinput_config_scroll_button_lock_state state;
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
state = libinput_device_config_scroll_get_default_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
}
END_TEST
enum libinput_config_scroll_button_lock_state state;
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
state = libinput_device_config_scroll_get_default_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
status = libinput_device_config_scroll_set_button_lock(dev->libinput_device,
LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
status = libinput_device_config_scroll_set_button_lock(dev->libinput_device,
LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
status = libinput_device_config_scroll_set_button_lock(dev->libinput_device,
LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED + 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
uint32_t button;
method = libinput_device_config_scroll_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
method = libinput_device_config_scroll_get_default_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
button = libinput_device_config_scroll_get_button(device);
litest_assert_int_eq(button, (unsigned int)BTN_SIDE);
for (speed = -2.0; speed < -1.0; speed += 0.2) {
status = libinput_device_config_accel_set_speed(device,
speed);
- litest_assert_int_eq(status,
+ litest_assert_enum_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
for (speed = -1.0; speed <= 1.0; speed += 0.2) {
status = libinput_device_config_accel_set_speed(device,
speed);
- litest_assert_int_eq(status,
+ litest_assert_enum_eq(status,
LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
speed);
for (speed = 1.2; speed <= 2.0; speed += 0.2) {
status = libinput_device_config_accel_set_speed(device,
speed);
- litest_assert_int_eq(status,
+ litest_assert_enum_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
1.0);
status = libinput_device_config_accel_set_speed(device,
NAN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_speed(device,
INFINITY);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
status = libinput_device_config_accel_set_speed(device,
speed);
if (speed >= -1.0 && speed <= 1.0)
- litest_assert_int_eq(status,
+ litest_assert_enum_eq(status,
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
else
- litest_assert_int_eq(status,
+ litest_assert_enum_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
litest_assert(libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
profiles = libinput_device_config_accel_get_profiles(device);
litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
profile = libinput_device_config_accel_get_default_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
}
END_TEST
};
ARRAY_FOR_EACH(profiles, profile) {
- litest_assert_int_eq(libinput_device_config_accel_set_speed(device, 1.0),
+ litest_assert_enum_eq(libinput_device_config_accel_set_speed(device, 1.0),
LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device), 1.0);
struct libinput_config_accel *config =
libinput_config_accel_create(LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- litest_assert_int_eq(libinput_device_config_accel_apply(device, config),
+ litest_assert_enum_eq(libinput_device_config_accel_apply(device, config),
LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
default_speed);
litest_assert_int_eq(status, t->expected_status);
status = libinput_device_config_accel_apply(device, config_custom_changed);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
status = libinput_device_config_accel_apply(device, config_custom_default);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
}
}
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(!libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
state = libinput_device_config_middle_emulation_get_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
}
END_TEST
state = libinput_device_config_middle_emulation_get_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
}
END_TEST
available = libinput_device_config_middle_emulation_is_available(device);
litest_assert(!available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
libinput_event_destroy(event);
while ((event = libinput_get_event(li))) {
- litest_assert_int_ne(libinput_event_get_type(event),
- LIBINPUT_EVENT_SWITCH_TOGGLE);
+ litest_assert_enum_ne(libinput_event_get_type(event),
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(event);
}
litest_dispatch(li);
while ((event = libinput_get_event(li)) != NULL) {
- litest_assert_int_ne(libinput_event_get_type(event),
- LIBINPUT_EVENT_SWITCH_TOGGLE);
+ litest_assert_enum_ne(libinput_event_get_type(event),
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(event);
}
/* don't expect a switch waiting for us, this is run for an
* unreliable device */
while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE) {
- litest_assert_int_ne(libinput_next_event_type(li),
- LIBINPUT_EVENT_SWITCH_TOGGLE);
+ litest_assert_enum_ne(libinput_next_event_type(li),
+ LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(libinput_get_event(li));
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 1U);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 2U);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 1U);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 0U);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
(unsigned int)BTN_STYLUS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
(unsigned int)BTN_STYLUS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
(unsigned int)BTN_STYLUS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
(unsigned int)BTN_STYLUS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
have_tool_update = true;
tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool), type);
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool), type);
}
libinput_event_destroy(event);
}
double tx, ty;
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
};
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
return;
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
libinput_event_destroy(event);
litest_dispatch(li);
- litest_assert_int_eq(libinput_next_event_type(li),
+ litest_assert_enum_eq(libinput_next_event_type(li),
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* we expect all events up to the button event to go from
libinput_event_destroy(event);
}
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev), tool);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_assert_ptr_ne(libinput_event_tablet_tool_get_tool(tev), tool);
libinput_tablet_tool_unref(tool);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
litest_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
tool);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
litest_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
tool);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
litest_assert_notnull(tool);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_MOUSE);
libinput_event_destroy(event);
tool = libinput_event_tablet_tool_get_tool(tev);
litest_assert_notnull(tool);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH);
litest_assert(libinput_tablet_tool_has_slider(tool));
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
litest_assert_notnull(tool);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_PEN);
litest_assert(libinput_tablet_tool_has_rotation(tool));
status = libinput_device_config_calibration_set_matrix(d,
calibration);
if (has_calibration)
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
else
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
calibration[4] = 0.5;
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_minimum(tool), 0.0);
litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_maximum(tool), 1.0);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.0),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.0),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.2, 0.5),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.2, 0.5),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, -0.1, 1.0),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, -0.1, 1.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.0),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 1.0, 1.0),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 1.0, 1.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.1),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.1),
LIBINPUT_CONFIG_STATUS_INVALID);
/* The last successful one */
old_pressure = p;
litest_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 1.0),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 1.0),
LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_event_destroy(event);
old_pressure = p;
litest_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.6),
- LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.6),
+ LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_event_destroy(event);
/* config doesn't take effect until we're out of prox */
old_pressure = p;
litest_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 0.6),
+ litest_assert_enum_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 0.6),
LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_event_destroy(event);
litest_assert(libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profiles = libinput_device_config_accel_get_profiles(device);
- litest_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE, 0);
- litest_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT, 0);
+ litest_assert_enum_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE, 0);
+ litest_assert_enum_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT, 0);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
profile = libinput_device_config_accel_get_profile(device);
- litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_enum_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
}
END_TEST
status = libinput_device_config_calibration_set_matrix(
dev->libinput_device,
calibration);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 10, 10, axes);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 30, 30);
litest_touch_move_to(dev, 0, 30, 30, 80, 80, 10);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(t);
- litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_enum_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_TOTEM);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(t),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(t),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(t),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
x = libinput_event_tablet_tool_get_x(t);
y = libinput_event_tablet_tool_get_y(t);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
x = libinput_event_tablet_tool_get_x(t);
y = libinput_event_tablet_tool_get_y(t);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(t),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
libinput_event_destroy(event);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(t),
(unsigned int)BTN_0);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(t),
LIBINPUT_BUTTON_STATE_PRESSED);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(t),
(unsigned int)BTN_0);
- litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_button_state(t),
LIBINPUT_BUTTON_STATE_RELEASED);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_proximity_state(t),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_enum_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
litest_dispatch(libinput);
do {
type = libinput_event_get_type(ev);
- litest_assert_int_ne(type, LIBINPUT_EVENT_TOUCH_DOWN);
+ litest_assert_enum_ne(type, LIBINPUT_EVENT_TOUCH_DOWN);
if (type == LIBINPUT_EVENT_TOUCH_UP)
slot_count--;
/* Twice so we have every to-fro combination */
for (int i = 0; i < 2; i++) {
status = libinput_device_config_calibration_set_matrix(dev->libinput_device, identity);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_device_config_calibration_get_matrix(dev->libinput_device, matrix);
litest_assert_int_eq(memcmp(matrix, identity, sizeof(matrix)), 0);
status = libinput_device_config_calibration_set_matrix(dev->libinput_device, nonidentity);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_device_config_calibration_get_matrix(dev->libinput_device, matrix);
litest_assert_int_eq(memcmp(matrix, nonidentity, sizeof(matrix)), 0);
}
litest_assert_int_eq(rc, 0);
status = libinput_device_config_left_handed_set(d, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_default_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
enum libinput_config_clickfinger_button_map map;
map = libinput_device_config_click_get_clickfinger_button_map(device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
map = libinput_device_config_click_get_default_clickfinger_button_map(device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
}
END_TEST
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_click_get_clickfinger_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_click_get_clickfinger_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR);
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM - 1;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR + 1;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
method = libinput_device_config_click_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
method = libinput_device_config_click_get_default_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
litest_assert_int_eq(methods, 0U);
method = libinput_device_config_click_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
method = libinput_device_config_click_get_default_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_method(device);
- litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_enum_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
/* actual config is delayed, but status is immediate */
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
enabled = libinput_device_config_middle_emulation_get_enabled(device);
litest_assert(enabled);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
enabled = libinput_device_config_middle_emulation_get_enabled(device);
litest_assert(!enabled);
}
struct litest_device *dev = litest_current_device();
litest_assert_int_eq(libinput_device_config_tap_get_finger_count(dev->libinput_device), 0);
- litest_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
+ litest_assert_enum_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
LIBINPUT_CONFIG_TAP_ENABLED),
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
+ litest_assert_enum_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
LIBINPUT_CONFIG_TAP_DISABLED),
LIBINPUT_CONFIG_STATUS_SUCCESS);
}
/* this test is only run on specific devices */
- litest_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_DISABLED);
}
END_TEST
/* this test is only run on specific devices */
- litest_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_ENABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_ENABLED);
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
+ litest_assert_enum_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, -1),
+ litest_assert_enum_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, -1),
LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_tap_button_map map;
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
}
END_TEST
enum libinput_config_status status;
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
status = libinput_device_config_tap_set_button_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LMR);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_button_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LRM);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
map = LIBINPUT_CONFIG_TAP_MAP_LRM;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = LIBINPUT_CONFIG_TAP_MAP_LMR;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
map = LIBINPUT_CONFIG_TAP_MAP_LRM;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
map = LIBINPUT_CONFIG_TAP_MAP_LMR;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
status = libinput_device_config_tap_set_button_map(device, map);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_tap_button_map map;
map = libinput_device_config_tap_get_button_map(device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
}
END_TEST
litest_set_tap_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LMR);
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
+ litest_assert_enum_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
litest_touch_up(dev, 0);
litest_touch_up(dev, 1);
/* this test is only run on specific devices */
- litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
}
END_TEST
/* this test is only run on specific devices */
- litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_ENABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_ENABLED);
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- litest_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
+ litest_assert_enum_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
- litest_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, -1),
+ litest_assert_enum_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, -1),
LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
struct litest_device *dev = litest_current_device();
enum libinput_config_status status;
- litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
status = libinput_device_config_tap_set_drag_enabled(dev->libinput_device,
LIBINPUT_CONFIG_DRAG_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_enabled(dev->libinput_device,
LIBINPUT_CONFIG_DRAG_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
litest_disable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
litest_enable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
/* same thing with tapping disabled */
litest_enable_tap(dev->libinput_device);
litest_disable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
litest_enable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
}
END_TEST
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* ENABLED is a legacy spelling for ENABLED_TIMEOUT */
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- litest_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
+ litest_assert_enum_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
event = libinput_get_event(li);
while (event) {
- litest_assert_int_ne(libinput_event_get_type(event),
- LIBINPUT_EVENT_POINTER_MOTION);
+ litest_assert_enum_ne(libinput_event_get_type(event),
+ LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
event = libinput_get_event(li);
}
enum libinput_config_status status;
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 1);
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_EDGE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_2FG);
if (should_have_2fg)
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
else
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
- litest_assert_int_eq(litest_event_pointer_get_axis_source(ptrev),
- LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
+ litest_assert_enum_eq(litest_event_pointer_get_axis_source(ptrev),
+ LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
libinput_event_destroy(event);
}
}
return;
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click(dev, BTN_LEFT, 1);
litest_assert_int_eq(libinput_device_config_left_handed_is_available(d), 0);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
litest_assert_int_eq(libinput_device_config_left_handed_get(d), 0);
}
END_TEST
return;
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_touch_down(dev, 0, 10, 90);
return;
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_touch_down(dev, 0, 10, 90);
litest_disable_hold_gestures(dev->libinput_device);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_disable_hold_gestures(dev->libinput_device);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_button_click(dev, BTN_LEFT, 0);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_button_click(dev, BTN_RIGHT, 0);
litest_button_click(dev, BTN_LEFT, 0);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_button_click(dev, BTN_LEFT, 0);
litest_touch_up(dev, 0);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_button_click(dev, BTN_LEFT, 0);
litest_touch_up(dev, 0);
return;
status = libinput_device_config_left_handed_set(d, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_scroll_set_method(
trackpoint->libinput_device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(touchpad, li, BTN_2, true); /* middle */
litest_assert(libinput_device_config_dwt_is_available(device));
state = libinput_device_config_dwt_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
state = libinput_device_config_dwt_get_default_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(libinput_device_config_dwtp_is_available(device));
state = libinput_device_config_dwtp_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
state = libinput_device_config_dwtp_get_default_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(!libinput_device_config_dwt_is_available(device));
state = libinput_device_config_dwt_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
state = libinput_device_config_dwt_get_default_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_assert(!libinput_device_config_dwtp_is_available(device));
state = libinput_device_config_dwtp_get_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
state = libinput_device_config_dwtp_get_default_enabled(device);
- litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
+ litest_assert_enum_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_ENABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device, 3);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
status = libinput_device_config_send_events_set_mode(
mouse->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
status = libinput_device_config_send_events_set_mode(
mouse1->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
enum libinput_config_status status;
status = libinput_device_config_rotation_set_angle(device, 360);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_rotation_set_angle(device, 361);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_rotation_set_angle(device, -1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
/* 0 always succeeds */
status = libinput_device_config_rotation_set_angle(device, 0);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
for (angle = 1; angle < 360; angle++) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
}
END_TEST
for (angle = 0; angle < 360; angle += 90) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
}
END_TEST
for (angle = 0; angle < 360; angle++) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
}
END_TEST
while ((event = libinput_get_event(li))) {
ptrev = libinput_event_get_pointer_event(event);
- litest_assert_int_eq(litest_event_pointer_get_axis_source(ptrev),
+ litest_assert_enum_eq(litest_event_pointer_get_axis_source(ptrev),
LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
libinput_event_destroy(event);
/* touchpad right-handed, trackpoint left-handed */
status = libinput_device_config_left_handed_set(
trackpoint->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
/* touchpad left-handed, trackpoint right-handed */
status = libinput_device_config_left_handed_set(
touchpad->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
/* touchpad left-handed, trackpoint left-handed */
status = libinput_device_config_left_handed_set(
touchpad->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_left_handed_set(
trackpoint->libinput_device, 1);
- litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_enum_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
expected = LIBINPUT_CONFIG_STATUS_SUCCESS;
status = libinput_device_config_dwtp_set_enabled(dev->libinput_device,
LIBINPUT_CONFIG_DWTP_ENABLED);
- litest_assert_int_eq(status, expected);
+ litest_assert_enum_eq(status, expected);
}
static inline void
expected = LIBINPUT_CONFIG_STATUS_SUCCESS;
status = libinput_device_config_dwtp_set_enabled(dev->libinput_device,
LIBINPUT_CONFIG_DWTP_DISABLED);
- litest_assert_int_eq(status, expected);
+ litest_assert_enum_eq(status, expected);
}
litest_dispatch(li);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_REMOVED);
litest_assert(libinput_event_get_device(event) == device);
libinput_event_destroy(event);
event = libinput_get_event(li);
- litest_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_enum_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_ADDED);
litest_assert(libinput_event_get_device(event) != device);
libinput_device_unref(device);
projects / platform / upstream / libinput.git / commitdiff