This is the first step in switching away from the check framework.
Our litest macros already do almost exactly the same anyway so most of
this is a simple sed with a few compiler fixes where things mismatch
(nonnull -> notnull) and (_tol -> _epsilon).
This now generates a whole bunch of integer mismatch warnings: check
casts everything to intmax_t whereas we use typeof, so lots of warnings
especially for enums.
Part-of: <https://gitlab.freedesktop.org/libinput/libinput/-/merge_requests/1059>
}
END_TEST
-START_TEST(ck_double_eq_and_ne)
-{
- ck_assert_double_eq(0.4,0.4);
- ck_assert_double_eq(0.4,0.4 + 1E-6);
- ck_assert_double_ne(0.4,0.4 + 1E-3);
-}
-END_TEST
-
-START_TEST(ck_double_lt_gt)
-{
- ck_assert_double_lt(12.0,13.0);
- ck_assert_double_gt(15.4,13.0);
- ck_assert_double_le(12.0,12.0);
- ck_assert_double_le(12.0,20.0);
- ck_assert_double_ge(12.0,12.0);
- ck_assert_double_ge(20.0,12.0);
-}
-END_TEST
-
-START_TEST(ck_double_eq_fails)
-{
- ck_assert_double_eq(0.41,0.4);
-}
-END_TEST
-
-START_TEST(ck_double_ne_fails)
-{
- ck_assert_double_ne(0.4 + 1E-7,0.4);
-}
-END_TEST
-
-START_TEST(ck_double_lt_fails)
-{
- ck_assert_double_lt(6,5);
-}
-END_TEST
-
-START_TEST(ck_double_gt_fails)
-{
- ck_assert_double_gt(5,6);
-}
-END_TEST
-
-START_TEST(ck_double_le_fails)
-{
- ck_assert_double_le(6,5);
-}
-END_TEST
-
-START_TEST(ck_double_ge_fails)
-{
- ck_assert_double_ge(5,6);
-}
-END_TEST
-
START_TEST(litest_double_eq_and_ne)
{
litest_assert_double_eq(0.4,0.4);
suite_add_tcase(s, tc);
tc = tcase_create("double comparison ");
- tcase_add_test(tc, ck_double_eq_and_ne);
- tcase_add_test(tc, ck_double_lt_gt);
- tcase_add_exit_test(tc, ck_double_eq_fails, 1);
- tcase_add_exit_test(tc, ck_double_ne_fails, 1);
- tcase_add_exit_test(tc, ck_double_lt_fails, 1);
- tcase_add_exit_test(tc, ck_double_gt_fails, 1);
- tcase_add_exit_test(tc, ck_double_le_fails, 1);
- tcase_add_exit_test(tc, ck_double_ge_fails, 1);
-
tcase_add_test(tc, litest_double_eq_and_ne);
tcase_add_test(tc, litest_double_lt_gt);
tcase_add_test_raise_signal(tc, litest_double_eq_fails, SIGABRT);
list_for_each(p, &ctx->paths, link) {
if (streq(p->path, devnode)) {
int rc = ioctl(p->fd, EVIOCGRAB, (void*)mode ? 1 : 0);
- ck_assert_int_gt(rc, -1);
+ litest_assert_int_gt(rc, -1);
udev_device_unref(udev_device);
return;
}
event = libinput_get_event(li);
ptrev = litest_is_axis_event(event, axis_type, axis, source);
val = litest_event_pointer_get_value(ptrev, axis);
- ck_assert(val == 0.0);
+ litest_assert(val == 0.0);
if (litest_is_high_res_axis_event(event)) {
litest_assert(!last_hi_res_event_found);
device = dev->libinput_device;
modes = libinput_device_config_send_events_get_modes(device);
- ck_assert_int_eq(modes,
+ litest_assert_int_eq(modes,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED | bit(4));
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
device = dev->libinput_device;
modes = libinput_device_config_send_events_get_modes(device);
- ck_assert_int_eq(modes, expected);
+ litest_assert_int_eq(modes, expected);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
modes);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* DISABLED supersedes the rest, expect the rest to be dropped */
modes = libinput_device_config_send_events_get_mode(device);
- ck_assert_int_eq(modes, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
+ litest_assert_int_eq(modes, LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
}
END_TEST
device = dev->libinput_device;
mode = libinput_device_config_send_events_get_mode(device);
- ck_assert_int_eq(mode,
+ litest_assert_int_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
mode = libinput_device_config_send_events_get_default_mode(device);
- ck_assert_int_eq(mode,
+ litest_assert_int_eq(mode,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
}
END_TEST
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* no event from disabling */
litest_assert_empty_queue(li);
/* create a new device so the resumed fd isn't the same as the
suspended one */
tmp = litest_add_device(li, LITEST_KEYBOARD);
- ck_assert_notnull(tmp);
+ litest_assert_notnull(tmp);
litest_drain_events(li);
/* no event from resuming */
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_assert_empty_queue(li);
/* event from re-enabled device */
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_notnull(event);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* expect above events */
litest_wait_for_event(li);
while ((event = libinput_get_event(li)) != NULL) {
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device1,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* can't really check for much here, other than that if we pump
events through libinput, none of them should be from the first
litest_dispatch(li);
while ((event = libinput_get_event(li))) {
- ck_assert(libinput_event_get_device(event) != device1);
+ litest_assert(libinput_event_get_device(event) != device1);
libinput_event_destroy(event);
}
libinput_device_ref(device);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_send_events_set_mode(device,
LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
ptrevent = libinput_event_get_pointer_event(event);
- ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_LEFT);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_wait_for_event(li);
event = libinput_get_event(li);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_KEYBOARD_KEY);
kbdevent = libinput_event_get_keyboard_event(event);
- ck_assert_int_eq(libinput_event_keyboard_get_key(kbdevent),
+ litest_assert_int_eq(libinput_event_keyboard_get_key(kbdevent),
KEY_A);
- ck_assert_int_eq(libinput_event_keyboard_get_key_state(kbdevent),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
- ck_assert_ptr_eq(libinput_event_get_device(event),
+ litest_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
- ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_RIGHT);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_PRESSED);
libinput_event_destroy(event);
event = libinput_get_event(li);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_BUTTON);
- ck_assert_ptr_eq(libinput_event_get_device(event),
+ litest_assert_ptr_eq(libinput_event_get_device(event),
trackpoint->libinput_device);
ptrevent = libinput_event_get_pointer_event(event);
- ck_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button(ptrevent),
BTN_RIGHT);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button_state(ptrevent),
LIBINPUT_BUTTON_STATE_RELEASED);
libinput_event_destroy(event);
pid = libevdev_get_id_product(dev->evdev);
vid = libevdev_get_id_vendor(dev->evdev);
- ck_assert_str_eq(name,
+ litest_assert_str_eq(name,
libinput_device_get_name(dev->libinput_device));
- ck_assert_int_eq(bus,
+ litest_assert_int_eq(bus,
libinput_device_get_id_bustype(dev->libinput_device));
- ck_assert_int_eq(pid,
+ litest_assert_int_eq(pid,
libinput_device_get_id_product(dev->libinput_device));
- ck_assert_int_eq(vid,
+ litest_assert_int_eq(vid,
libinput_device_get_id_vendor(dev->libinput_device));
}
END_TEST
struct udev_device *udev_device;
udev_device = libinput_device_get_udev_device(dev->libinput_device);
- ck_assert_notnull(udev_device);
+ litest_assert_notnull(udev_device);
udev_device_unref(udev_device);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_seat *seat;
- ck_assert(dev->libinput == libinput_device_get_context(dev->libinput_device));
+ litest_assert(dev->libinput == libinput_device_get_context(dev->libinput_device));
seat = libinput_device_get_seat(dev->libinput_device);
- ck_assert(dev->libinput == libinput_seat_get_context(seat));
+ litest_assert(dev->libinput == libinput_seat_get_context(seat));
}
END_TEST
struct libinput_device *device = dev->libinput_device;
void *userdata = &dev; /* not referenced */
- ck_assert(libinput_device_get_user_data(device) == NULL);
+ litest_assert(libinput_device_get_user_data(device) == NULL);
libinput_device_set_user_data(device, userdata);
- ck_assert_ptr_eq(libinput_device_get_user_data(device), userdata);
+ litest_assert_ptr_eq(libinput_device_get_user_data(device), userdata);
libinput_device_set_user_data(device, NULL);
- ck_assert(libinput_device_get_user_data(device) == NULL);
+ litest_assert(libinput_device_get_user_data(device) == NULL);
}
END_TEST
int userdata = 10;
group = libinput_device_get_device_group(dev->libinput_device);
- ck_assert_notnull(group);
+ litest_assert_notnull(group);
libinput_device_group_ref(group);
libinput_device_group_set_user_data(group, &userdata);
- ck_assert_ptr_eq(&userdata,
+ litest_assert_ptr_eq(&userdata,
libinput_device_group_get_user_data(group));
libinput_device_group_unref(group);
struct libinput_device_group *group;
group = libinput_device_get_device_group(device);
- ck_assert_notnull(group);
+ litest_assert_notnull(group);
libinput_device_group_ref(group);
libinput_device_ref(device);
litest_drain_events(li);
/* make sure the device is dead but the group is still around */
- ck_assert(libinput_device_unref(device) == NULL);
+ litest_assert(libinput_device_unref(device) == NULL);
libinput_device_group_ref(group);
- ck_assert_notnull(libinput_device_group_unref(group));
- ck_assert(libinput_device_group_unref(group) == NULL);
+ litest_assert_notnull(libinput_device_group_unref(group));
+ litest_assert(libinput_device_group_unref(group) == NULL);
litest_destroy_context(li);
}
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_restore_log_handler(li);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_destroy_context(li);
libevdev_uinput_destroy(uinput);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_restore_log_handler(li);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_destroy_context(li);
libevdev_uinput_destroy(uinput);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_restore_log_handler(li);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_destroy_context(li);
libevdev_uinput_destroy(uinput);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
litest_restore_log_handler(li);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_destroy_context(li);
libevdev_uinput_destroy(uinput);
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_POINTER));
}
END_TEST
prop = udev_device_get_property_value(d,
"ID_INPUT_TABLET");
- ck_assert_notnull(prop);
+ litest_assert_notnull(prop);
udev_device_unref(d);
}
END_TEST
li = litest_create_context();
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_disable_log_handler(li);
for (i = 0; i < 100; i++) {
li = litest_create_context();
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
for (i = 0; i < 100; i++) {
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
li = litest_create_context();
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_disable_log_handler(li);
for (i = 0; i < 100; i++) {
li = litest_create_context();
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
for (i = 0; i < 100; i++) {
libevdev_uinput_write_event(uinput, EV_REL, REL_X, 1);
struct libinput_device *device = dev->libinput_device;
struct libinput *li = dev->libinput;
- ck_assert(!libinput_device_pointer_has_button(device, 0x118));
- ck_assert(!libinput_device_pointer_has_button(device, 0x119));
- ck_assert(!libinput_device_pointer_has_button(device, 0x11a));
+ litest_assert(!libinput_device_pointer_has_button(device, 0x118));
+ litest_assert(!libinput_device_pointer_has_button(device, 0x119));
+ litest_assert(!libinput_device_pointer_has_button(device, 0x11a));
litest_drain_events(li);
litest_drain_events(li);
- ck_assert(!libinput_device_pointer_has_button(dev->libinput_device,
+ litest_assert(!libinput_device_pointer_has_button(dev->libinput_device,
BTN_MIDDLE));
}
END_TEST
dev = litest_add_device(li, LITEST_KEYBOARD_QUIRKED);
device = dev->libinput_device;
- ck_assert(libinput_device_pointer_has_button(device,
+ litest_assert(libinput_device_pointer_has_button(device,
BTN_LEFT));
- ck_assert(libinput_device_pointer_has_button(dev->libinput_device,
+ litest_assert(libinput_device_pointer_has_button(dev->libinput_device,
BTN_RIGHT));
- ck_assert(!libinput_device_pointer_has_button(device,
+ litest_assert(!libinput_device_pointer_has_button(device,
BTN_MIDDLE));
- ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
+ litest_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
KEY_F1));
- ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
+ litest_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
KEY_F2));
- ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
+ litest_assert(!libinput_device_keyboard_has_key(dev->libinput_device,
KEY_F3));
/* Scrape the debug messages for confirmation that our quirks are
if (strstr(*message, "disabling INPUT_PROP_POINTING_STICK"))
disable_pointingstick = true;
if (strstr(*message, "enabling INPUT_PROP_DIRECT")) {
- ck_assert(!disable_direct);
+ litest_assert(!disable_direct);
enable_direct = true;
}
if (strstr(*message, "disabling INPUT_PROP_DIRECT")) {
- ck_assert(enable_direct);
+ litest_assert(enable_direct);
disable_direct = true;
}
if (strstr(*message, "enabling INPUT_PROP_SEMI_MT")) {
- ck_assert(disable_semi_mt);
+ litest_assert(disable_semi_mt);
enable_semi_mt = true;
}
if (strstr(*message, "disabling INPUT_PROP_SEMI_MT")) {
- ck_assert(!enable_semi_mt);
+ litest_assert(!enable_semi_mt);
disable_semi_mt = true;
}
#endif
message++;
}
- ck_assert(disable_key_f1);
- ck_assert(enable_btn_left);
+ litest_assert(disable_key_f1);
+ litest_assert(enable_btn_left);
#if HAVE_LIBEVDEV_DISABLE_PROPERTY
- ck_assert(enable_buttonpad);
- ck_assert(disable_pointingstick);
- ck_assert(enable_direct);
- ck_assert(disable_direct);
- ck_assert(enable_semi_mt);
- ck_assert(disable_semi_mt);
+ litest_assert(enable_buttonpad);
+ litest_assert(disable_pointingstick);
+ litest_assert(enable_direct);
+ litest_assert(disable_direct);
+ litest_assert(enable_semi_mt);
+ litest_assert(disable_semi_mt);
#endif
litest_disable_log_handler(li);
if (libinput_device_has_capability(device, *cap))
ncaps++;
}
- ck_assert_int_gt(ncaps, 0);
+ litest_assert_int_gt(ncaps, 0);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(!libinput_device_has_capability(device, -1));
- ck_assert(!libinput_device_has_capability(device, 7));
- ck_assert(!libinput_device_has_capability(device, 0xffff));
+ litest_assert(!libinput_device_has_capability(device, -1));
+ litest_assert(!libinput_device_has_capability(device, 7));
+ litest_assert(!libinput_device_has_capability(device, 0xffff));
}
END_TEST
int rc;
rc = libinput_device_get_size(device, &w, &h);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
/* This matches the current set of test devices but may fail if
* newer ones are added */
- ck_assert_double_gt(w, 30);
- ck_assert_double_gt(h, 20);
+ litest_assert_double_gt(w, 30);
+ litest_assert_double_gt(h, 20);
}
END_TEST
int rc;
rc = libinput_device_get_size(device, &w, &h);
- ck_assert_int_eq(rc, -1);
- ck_assert_double_eq(w, 45);
- ck_assert_double_eq(h, 67);
+ litest_assert_int_eq(rc, -1);
+ litest_assert_double_eq(w, 45);
+ litest_assert_double_eq(h, 67);
}
END_TEST
const char *output_name;
output_name = libinput_device_get_output_name(device);
- ck_assert_str_eq(output_name, "myOutput");
+ litest_assert_str_eq(output_name, "myOutput");
}
END_TEST
const char *output_name;
output_name = libinput_device_get_output_name(device);
- ck_assert(output_name == NULL);
+ litest_assert(output_name == NULL);
}
END_TEST
const char *seat_name;
seat_name = libinput_seat_get_physical_name(seat);
- ck_assert(streq(seat_name, "seat0"));
+ litest_assert(streq(seat_name, "seat0"));
}
END_TEST
p = libinput_event_get_pointer_event(event);
if (libinput_event_pointer_get_button_state(p)) {
- ck_assert(button_down == 0);
+ litest_assert(button_down == 0);
button_down = libinput_event_pointer_get_button(p);
} else {
- ck_assert(button_up == 0);
+ litest_assert(button_up == 0);
button_up = libinput_event_pointer_get_button(p);
- ck_assert_int_eq(button_down, button_up);
+ litest_assert_int_eq(button_down, button_up);
}
libinput_event_destroy(event);
}
litest_destroy_context(li);
- ck_assert_int_eq(have_down, have_up);
+ litest_assert_int_eq(have_down, have_up);
}
}
END_TEST
3);
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
while ((event = libinput_get_event(li)) != NULL) {
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
}
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
3);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
4);
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
while ((event = libinput_get_event(li)) != NULL) {
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
}
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
4);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
- ck_assert(scale == 1.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
+ litest_assert(scale == 1.0);
libinput_event_destroy(event);
oldscale = scale;
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(scale < oldscale);
+ litest_assert(scale < oldscale);
angle = libinput_event_gesture_get_angle_delta(gevent);
- ck_assert_double_le(fabs(angle), 1.0);
+ litest_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
litest_dispatch(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
2);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
- ck_assert(scale == 1.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
+ litest_assert(scale == 1.0);
libinput_event_destroy(event);
oldscale = scale;
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(scale < oldscale);
+ litest_assert(scale < oldscale);
angle = libinput_event_gesture_get_angle_delta(gevent);
- ck_assert_double_le(fabs(angle), 1.0);
+ litest_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
litest_dispatch(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
3);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
- ck_assert(scale == 1.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
+ litest_assert(scale == 1.0);
libinput_event_destroy(event);
oldscale = scale;
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(scale < oldscale);
+ litest_assert(scale < oldscale);
angle = libinput_event_gesture_get_angle_delta(gevent);
- ck_assert_double_le(fabs(angle), 1.0);
+ litest_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
litest_dispatch(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
4);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
- ck_assert(scale == 1.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
+ litest_assert(scale == 1.0);
libinput_event_destroy(event);
2);
oldscale = scale;
scale = libinput_event_gesture_get_scale(gevent);
- ck_assert(scale > oldscale);
+ litest_assert(scale > oldscale);
angle = libinput_event_gesture_get_angle_delta(gevent);
- ck_assert_double_le(fabs(angle), 1.0);
+ litest_assert_double_le(fabs(angle), 1.0);
libinput_event_destroy(event);
litest_dispatch(li);
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_PINCH_END,
2);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
struct libinput_device *device = dev->libinput_device;
if (libevdev_has_property(dev->evdev, INPUT_PROP_SEMI_MT))
- ck_assert(!libinput_device_has_capability(device,
+ litest_assert(!libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_GESTURE));
else
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_GESTURE));
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(!libinput_device_has_capability(device,
+ litest_assert(!libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_GESTURE));
}
END_TEST
3);
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
while ((event = libinput_get_event(li)) != NULL) {
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
}
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
3);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
END_TEST
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
3);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
END_TEST
4);
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
while ((event = libinput_get_event(li)) != NULL) {
dx = libinput_event_gesture_get_dx(gevent);
dy = libinput_event_gesture_get_dy(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
dx = libinput_event_gesture_get_dx_unaccelerated(gevent);
dy = libinput_event_gesture_get_dy_unaccelerated(gevent);
if (dir_x == 0.0)
- ck_assert(dx == 0.0);
+ litest_assert(dx == 0.0);
else if (dir_x < 0.0)
- ck_assert(dx < 0.0);
+ litest_assert(dx < 0.0);
else if (dir_x > 0.0)
- ck_assert(dx > 0.0);
+ litest_assert(dx > 0.0);
if (dir_y == 0.0)
- ck_assert(dy == 0.0);
+ litest_assert(dy == 0.0);
else if (dir_y < 0.0)
- ck_assert(dy < 0.0);
+ litest_assert(dy < 0.0);
else if (dir_y > 0.0)
- ck_assert(dy > 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
}
gevent = litest_is_gesture_event(event,
LIBINPUT_EVENT_GESTURE_SWIPE_END,
4);
- ck_assert(!libinput_event_gesture_get_cancelled(gevent));
+ litest_assert(!libinput_event_gesture_get_cancelled(gevent));
libinput_event_destroy(event);
}
END_TEST
LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
3);
time_usec = libinput_event_gesture_get_time_usec(gevent);
- ck_assert_int_eq(libinput_event_gesture_get_time(gevent),
+ litest_assert_int_eq(libinput_event_gesture_get_time(gevent),
(uint32_t) (time_usec / 1000));
libinput_event_destroy(event);
}
ux = libinput_event_gesture_get_dx_unaccelerated(gevent);
uy = libinput_event_gesture_get_dy_unaccelerated(gevent);
- ck_assert_double_ne(ux, 0.0);
- ck_assert_double_ne(uy, 0.0);
+ litest_assert_double_ne(ux, 0.0);
+ litest_assert_double_ne(uy, 0.0);
if (!reference_ux)
reference_ux = ux;
* event, but we have rounding errors since we only control
* input data as percentage of the touchpad size.
* so we just eyeball it */
- ck_assert_double_gt(ux, reference_ux - 2);
- ck_assert_double_lt(ux, reference_ux + 2);
- ck_assert_double_gt(uy, reference_uy - 2);
- ck_assert_double_lt(uy, reference_uy + 2);
+ litest_assert_double_gt(ux, reference_ux - 2);
+ litest_assert_double_lt(ux, reference_ux + 2);
+ litest_assert_double_gt(uy, reference_uy - 2);
+ litest_assert_double_lt(uy, reference_uy + 2);
/* All our touchpads are large enough to make this is a fast
* swipe, we don't expect deceleration, unaccel should
* always be less than accel delta */
- ck_assert_double_lt(ux, dx);
- ck_assert_double_lt(ux, dx);
+ litest_assert_double_lt(ux, dx);
+ litest_assert_double_lt(ux, dx);
/* Check our accelerated delta is within the expected
* maximum. */
- ck_assert_double_lt(dx, ux * max_factor);
- ck_assert_double_lt(dy, uy * max_factor);
+ litest_assert_double_lt(dx, ux * max_factor);
+ litest_assert_double_lt(dy, uy * max_factor);
libinput_event_destroy(event);
} while ((event = libinput_get_event(li)));
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
+ litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
0);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
+ litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_default_enabled(device),
LIBINPUT_CONFIG_HOLD_ENABLED);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_int_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;
- ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, -1),
+ litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, -1),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, 2),
+ litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
+ litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
1);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_ENABLED);
- ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
+ litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
+ litest_assert_int_eq(libinput_device_config_gesture_hold_is_available(device),
0);
- ck_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
+ litest_assert_int_eq(libinput_device_config_gesture_get_hold_enabled(device),
LIBINPUT_CONFIG_HOLD_DISABLED);
- ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_ENABLED),
+ litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_ENABLED),
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- ck_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
+ litest_assert_int_eq(libinput_device_config_gesture_set_hold_enabled(device, LIBINPUT_CONFIG_HOLD_DISABLED),
LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
++expected_key_button_count;
seat_key_count =
libinput_event_keyboard_get_seat_key_count(kev);
- ck_assert_int_eq(expected_key_button_count, seat_key_count);
+ litest_assert_int_eq(expected_key_button_count, seat_key_count);
libinput_event_destroy(ev);
litest_dispatch(libinput);
}
- ck_assert_int_eq(seat_key_count, num_devices);
+ litest_assert_int_eq(seat_key_count, num_devices);
for (i = 0; i < num_devices; ++i)
litest_keyboard_key(devices[i], KEY_A, false);
litest_dispatch(libinput);
while ((ev = libinput_get_event(libinput))) {
kev = libinput_event_get_keyboard_event(ev);
- ck_assert_notnull(kev);
- ck_assert_int_eq(libinput_event_keyboard_get_key(kev), KEY_A);
- ck_assert_int_eq(libinput_event_keyboard_get_key_state(kev),
+ litest_assert_notnull(kev);
+ litest_assert_int_eq(libinput_event_keyboard_get_key(kev), KEY_A);
+ litest_assert_int_eq(libinput_event_keyboard_get_key_state(kev),
LIBINPUT_KEY_STATE_RELEASED);
--expected_key_button_count;
seat_key_count =
libinput_event_keyboard_get_seat_key_count(kev);
- ck_assert_int_eq(expected_key_button_count, seat_key_count);
+ litest_assert_int_eq(expected_key_button_count, seat_key_count);
libinput_event_destroy(ev);
litest_dispatch(libinput);
}
- ck_assert_int_eq(seat_key_count, 0);
+ litest_assert_int_eq(seat_key_count, 0);
for (i = 0; i < num_devices; ++i)
litest_delete_device(devices[i]);
ARRAY_FOR_EACH(expected_states, state) {
event = libinput_get_event(libinput);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_KEYBOARD_KEY);
kevent = libinput_event_get_keyboard_event(event);
- ck_assert_int_eq(libinput_event_keyboard_get_key(kevent),
+ litest_assert_int_eq(libinput_event_keyboard_get_key(kevent),
KEY_A);
- ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
+ litest_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
*state);
libinput_event_destroy(event);
litest_dispatch(libinput);
/* Mark all released keys until device is removed */
while (1) {
event = libinput_get_event(libinput);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
type = libinput_event_get_type(event);
if (type == LIBINPUT_EVENT_DEVICE_REMOVED) {
litest_assert_event_type(event, LIBINPUT_EVENT_KEYBOARD_KEY);
kevent = libinput_event_get_keyboard_event(event);
- ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
+ litest_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
LIBINPUT_KEY_STATE_RELEASED);
key = libinput_event_keyboard_get_key(kevent);
valid_code = 0;
for (i = 0; i < ARRAY_LENGTH(keys); ++i) {
if (keys[i].code == key) {
- ck_assert_int_eq(keys[i].released, 0);
+ litest_assert_int_eq(keys[i].released, 0);
keys[i].released = 1;
valid_code = 1;
}
}
- ck_assert_int_eq(valid_code, 1);
+ litest_assert_int_eq(valid_code, 1);
libinput_event_destroy(event);
}
/* Check that all pressed keys has been released. */
for (i = 0; i < ARRAY_LENGTH(keys); ++i) {
- ck_assert_int_eq(keys[i].released, 1);
+ litest_assert_int_eq(keys[i].released, 1);
}
litest_destroy_context(libinput);
unsigned int code;
int evdev_has, libinput_has;
- ck_assert(libinput_device_has_capability(
+ litest_assert(libinput_device_has_capability(
device,
LIBINPUT_DEVICE_CAP_KEYBOARD));
for (code = 0; code < KEY_CNT; code++) {
evdev_has = libevdev_has_event_code(dev->evdev, EV_KEY, code);
libinput_has = libinput_device_keyboard_has_key(device, code);
- ck_assert_int_eq(evdev_has, libinput_has);
+ litest_assert_int_eq(evdev_has, libinput_has);
}
}
END_TEST
for (code = 0; code < KEY_CNT; code++) {
has_key = libinput_device_keyboard_has_key(device, code);
- ck_assert_int_eq(has_key, -1);
+ litest_assert_int_eq(has_key, -1);
}
}
END_TEST
LIBINPUT_KEY_STATE_PRESSED);
time_usec = libinput_event_keyboard_get_time_usec(kev);
- ck_assert_int_eq(libinput_event_keyboard_get_time(kev),
+ litest_assert_int_eq(libinput_event_keyboard_get_time(kev),
(uint32_t) (time_usec / 1000));
libinput_event_destroy(event);
enum libinput_config_status status;
method = libinput_device_config_scroll_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
method = libinput_device_config_scroll_get_default_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_2FG);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_EDGE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
li = libinput_path_create_context(&simple_interface, NULL);
pri = libinput_log_get_priority(li);
- ck_assert_int_eq(pri, LIBINPUT_LOG_PRIORITY_ERROR);
+ litest_assert_int_eq(pri, LIBINPUT_LOG_PRIORITY_ERROR);
libinput_unref(li);
}
libinput_path_add_device(li, "/tmp");
- ck_assert_int_gt(log_handler_called, 0);
+ litest_assert_int_gt(log_handler_called, 0);
litest_destroy_context(li);
libinput_path_add_device(li, "/tmp");
- ck_assert_int_eq(log_handler_called, 0);
+ litest_assert_int_eq(log_handler_called, 0);
litest_destroy_context(li);
libinput_path_add_device(li, "/tmp");
- ck_assert_int_eq(log_handler_called, 1);
+ litest_assert_int_eq(log_handler_called, 1);
libinput_log_set_priority(li, LIBINPUT_LOG_PRIORITY_INFO);
/* event0 exists on any box we care to run the test suite on and we
* currently prints *something* for each device */
libinput_path_add_device(li, "/dev/input/event0");
- ck_assert_int_gt(log_handler_called, 1);
+ litest_assert_int_gt(log_handler_called, 1);
litest_destroy_context(li);
}
/* Expect only one message per 5 min */
- ck_assert_int_eq(axisrange_log_handler_called, 1);
+ litest_assert_int_eq(axisrange_log_handler_called, 1);
libinput_log_set_priority(li, LIBINPUT_LOG_PRIORITY_ERROR);
litest_restore_log_handler(li);
struct libinput_event *base;
dn = libinput_event_get_device_notify_event(event);
base = libinput_event_device_notify_get_base_event(dn);
- ck_assert(event == base);
+ litest_assert(event == base);
if (type == LIBINPUT_EVENT_DEVICE_ADDED)
device_added++;
device_removed++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
litest_destroy_context(li);
libevdev_uinput_destroy(uinput);
- ck_assert_int_gt(device_added, 0);
- ck_assert_int_gt(device_removed, 0);
+ litest_assert_int_gt(device_added, 0);
+ litest_assert_int_gt(device_removed, 0);
}
END_TEST
struct libinput_event *base;
p = libinput_event_get_pointer_event(event);
base = libinput_event_pointer_get_base_event(p);
- ck_assert(event == base);
+ litest_assert(event == base);
if (type == LIBINPUT_EVENT_POINTER_MOTION)
motion++;
button++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(motion, 0);
- ck_assert_int_gt(button, 0);
+ litest_assert_int_gt(motion, 0);
+ litest_assert_int_gt(button, 0);
}
END_TEST
struct libinput_event *base;
p = libinput_event_get_pointer_event(event);
base = libinput_event_pointer_get_base_event(p);
- ck_assert(event == base);
+ litest_assert(event == base);
if (type == LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE)
motion++;
button++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(motion, 0);
- ck_assert_int_gt(button, 0);
+ litest_assert_int_gt(motion, 0);
+ litest_assert_int_gt(button, 0);
}
END_TEST
struct libinput_event *base;
k = libinput_event_get_keyboard_event(event);
base = libinput_event_keyboard_get_base_event(k);
- ck_assert(event == base);
+ litest_assert(event == base);
key++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(key, 0);
+ litest_assert_int_gt(key, 0);
}
END_TEST
struct libinput_event *base;
t = libinput_event_get_touch_event(event);
base = libinput_event_touch_get_base_event(t);
- ck_assert(event == base);
+ litest_assert(event == base);
touch++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(touch, 0);
+ litest_assert_int_gt(touch, 0);
}
END_TEST
struct libinput_event *base;
g = libinput_event_get_gesture_event(event);
base = libinput_event_gesture_get_base_event(g);
- ck_assert(event == base);
+ litest_assert(event == base);
gestures++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(gestures, 0);
+ litest_assert_int_gt(gestures, 0);
}
END_TEST
struct libinput_event *base;
t = libinput_event_get_tablet_tool_event(event);
base = libinput_event_tablet_tool_get_base_event(t);
- ck_assert(event == base);
+ litest_assert(event == base);
events++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(events, 0);
+ litest_assert_int_gt(events, 0);
}
END_TEST
p = libinput_event_get_tablet_pad_event(event);
base = libinput_event_tablet_pad_get_base_event(p);
- ck_assert(event == base);
+ litest_assert(event == base);
events++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_switch_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_switch_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(events, 0);
+ litest_assert_int_gt(events, 0);
}
END_TEST
struct libinput_event *base;
s = libinput_event_get_switch_event(event);
base = libinput_event_switch_get_base_event(s);
- ck_assert(event == base);
+ litest_assert(event == base);
sw++;
litest_disable_log_handler(li);
- ck_assert(libinput_event_get_device_notify_event(event) == NULL);
- ck_assert(libinput_event_get_keyboard_event(event) == NULL);
- ck_assert(libinput_event_get_pointer_event(event) == NULL);
- ck_assert(libinput_event_get_touch_event(event) == NULL);
- ck_assert(libinput_event_get_gesture_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
- ck_assert(libinput_event_get_tablet_pad_event(event) == NULL);
+ litest_assert(libinput_event_get_device_notify_event(event) == NULL);
+ litest_assert(libinput_event_get_keyboard_event(event) == NULL);
+ litest_assert(libinput_event_get_pointer_event(event) == NULL);
+ litest_assert(libinput_event_get_touch_event(event) == NULL);
+ litest_assert(libinput_event_get_gesture_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_tool_event(event) == NULL);
+ litest_assert(libinput_event_get_tablet_pad_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
}
- ck_assert_int_gt(sw, 0);
+ litest_assert_int_gt(sw, 0);
}
END_TEST
* free errors. */
li = libinput_path_create_context(&simple_interface, NULL);
- ck_assert_notnull(li);
- ck_assert_ptr_eq(libinput_unref(li), NULL);
+ litest_assert_notnull(li);
+ litest_assert_ptr_eq(libinput_unref(li), NULL);
li = libinput_path_create_context(&simple_interface, NULL);
- ck_assert_notnull(li);
- ck_assert_ptr_eq(libinput_ref(li), li);
- ck_assert_ptr_eq(libinput_unref(li), li);
- ck_assert_ptr_eq(libinput_unref(li), NULL);
+ litest_assert_notnull(li);
+ litest_assert_ptr_eq(libinput_ref(li), li);
+ litest_assert_ptr_eq(libinput_unref(li), li);
+ litest_assert_ptr_eq(libinput_unref(li), NULL);
}
END_TEST
for (i = 0; i < ARRAY_LENGTH(strs) - 1; i++)
for (j = i + 1; j < ARRAY_LENGTH(strs); j++)
- ck_assert_str_ne(strs[i], strs[j]);
+ litest_assert_str_ne(strs[i], strs[j]);
invalid = libinput_config_status_to_str(LIBINPUT_CONFIG_STATUS_INVALID + 1);
- ck_assert(invalid == NULL);
+ litest_assert(invalid == NULL);
invalid = libinput_config_status_to_str(LIBINPUT_CONFIG_STATUS_SUCCESS - 1);
- ck_assert(invalid == NULL);
+ litest_assert(invalid == NULL);
}
END_TEST
path = libevdev_uinput_get_devnode(uinput);
fd = open(path, O_RDWR | O_NONBLOCK | O_CLOEXEC);
- ck_assert_int_gt(fd, -1);
+ litest_assert_int_gt(fd, -1);
li = libinput_path_create_context(&leak_interface, &fd);
litest_restore_log_handler(li); /* use the default litest handler */
litest_dispatch(li);
/* triggered for touch down and touch up */
- ck_assert_int_eq(warning_triggered, 2);
+ litest_assert_int_eq(warning_triggered, 2);
litest_restore_log_handler(li);
}
END_TEST
litest_dispatch(li);
}
- ck_assert_int_ge(warning_triggered, 1);
+ litest_assert_int_ge(warning_triggered, 1);
litest_restore_log_handler(li);
}
END_TEST
found_mt_x = false, found_mt_y = false;
ud = libinput_device_get_udev_device(dev->libinput_device);
- ck_assert_notnull(ud);
+ litest_assert_notnull(ud);
/* Custom checks for this special litest device only */
if (streq(key, "EVDEV_ABS_00")) {
found_x = true;
- ck_assert(streq(value, "1:1000:100:10"));
+ litest_assert(streq(value, "1:1000:100:10"));
}
if (streq(key, "EVDEV_ABS_01")) {
found_y = true;
- ck_assert(streq(value, "2:2000:200:20"));
+ litest_assert(streq(value, "2:2000:200:20"));
}
if (streq(key, "EVDEV_ABS_35")) {
found_mt_x = true;
- ck_assert(streq(value, "3:3000:300:30"));
+ litest_assert(streq(value, "3:3000:300:30"));
}
if (streq(key, "EVDEV_ABS_36")) {
found_mt_y = true;
- ck_assert(streq(value, "4:4000:400:40"));
+ litest_assert(streq(value, "4:4000:400:40"));
}
entry = udev_list_entry_get_next(entry);
}
udev_device_unref(ud);
- ck_assert(found_x);
- ck_assert(found_y);
- ck_assert(found_mt_x);
- ck_assert(found_mt_y);
+ litest_assert(found_x);
+ litest_assert(found_y);
+ litest_assert(found_mt_x);
+ litest_assert(found_mt_y);
abs = libevdev_get_abs_info(evdev, ABS_X);
- ck_assert_int_eq(abs->minimum, 1);
- ck_assert_int_eq(abs->maximum, 1000);
- ck_assert_int_eq(abs->resolution, 100);
+ litest_assert_int_eq(abs->minimum, 1);
+ litest_assert_int_eq(abs->maximum, 1000);
+ litest_assert_int_eq(abs->resolution, 100);
/* if everything goes well, we override the fuzz to 0 */
- ck_assert_int_eq(abs->fuzz, 0);
+ litest_assert_int_eq(abs->fuzz, 0);
abs = libevdev_get_abs_info(evdev, ABS_Y);
- ck_assert_int_eq(abs->minimum, 2);
- ck_assert_int_eq(abs->maximum, 2000);
- ck_assert_int_eq(abs->resolution, 200);
+ litest_assert_int_eq(abs->minimum, 2);
+ litest_assert_int_eq(abs->maximum, 2000);
+ litest_assert_int_eq(abs->resolution, 200);
/* if everything goes well, we override the fuzz to 0 */
- ck_assert_int_eq(abs->fuzz, 0);
+ litest_assert_int_eq(abs->fuzz, 0);
abs = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X);
- ck_assert_int_eq(abs->minimum, 3);
- ck_assert_int_eq(abs->maximum, 3000);
- ck_assert_int_eq(abs->resolution, 300);
+ litest_assert_int_eq(abs->minimum, 3);
+ litest_assert_int_eq(abs->maximum, 3000);
+ litest_assert_int_eq(abs->resolution, 300);
/* if everything goes well, we override the fuzz to 0 */
- ck_assert_int_eq(abs->fuzz, 0);
+ litest_assert_int_eq(abs->fuzz, 0);
abs = libevdev_get_abs_info(evdev, ABS_MT_POSITION_Y);
- ck_assert_int_eq(abs->minimum, 4);
- ck_assert_int_eq(abs->maximum, 4000);
- ck_assert_int_eq(abs->resolution, 400);
+ litest_assert_int_eq(abs->minimum, 4);
+ litest_assert_int_eq(abs->maximum, 4000);
+ litest_assert_int_eq(abs->resolution, 400);
/* if everything goes well, we override the fuzz to 0 */
- ck_assert_int_eq(abs->fuzz, 0);
+ litest_assert_int_eq(abs->fuzz, 0);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_TABLET_PAD));
}
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(!libinput_device_has_capability(device,
+ litest_assert(!libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_TABLET_PAD));
}
END_TEST
return;
ev = libinput_get_event(li);
- ck_assert_notnull(ev);
+ litest_assert_notnull(ev);
litest_assert_event_type(ev, LIBINPUT_EVENT_TABLET_PAD_BUTTON);
pev = libinput_event_get_tablet_pad_event(ev);
time = libinput_event_tablet_pad_get_time(pev);
time_usec = libinput_event_tablet_pad_get_time_usec(pev);
- ck_assert(time != 0);
- ck_assert(time == time_usec/1000);
+ litest_assert(time != 0);
+ litest_assert(time == time_usec/1000);
libinput_event_destroy(ev);
time = libinput_event_tablet_pad_get_time(pev);
time_usec = libinput_event_tablet_pad_get_time_usec(pev);
- ck_assert(time > oldtime);
- ck_assert(time != 0);
- ck_assert(time == time_usec/1000);
+ litest_assert(time > oldtime);
+ litest_assert(time != 0);
+ litest_assert(time == time_usec/1000);
libinput_event_destroy(ev);
}
unsigned int nb_lw, nb;
db = libwacom_database_new();
- ck_assert_notnull(db);
+ litest_assert_notnull(db);
wacom = libwacom_new_from_usbid(db,
libevdev_get_id_vendor(dev->evdev),
libevdev_get_id_product(dev->evdev),
NULL);
- ck_assert_notnull(wacom);
+ litest_assert_notnull(wacom);
nb_lw = libwacom_get_num_buttons(wacom);
nb = libinput_device_tablet_pad_get_num_buttons(device);
- ck_assert_int_eq(nb, nb_lw);
+ litest_assert_int_eq(nb, nb_lw);
libwacom_destroy(wacom);
libwacom_database_destroy(db);
nbuttons++;
}
- ck_assert_int_eq(libinput_device_tablet_pad_get_num_buttons(device),
+ litest_assert_int_eq(libinput_device_tablet_pad_get_num_buttons(device),
nbuttons);
}
END_TEST
/* Skip over the BTN_MOUSE and BTN_JOYSTICK range */
if ((code >= BTN_MOUSE && code < BTN_JOYSTICK) ||
(code >= BTN_DIGI)) {
- ck_assert(!libevdev_has_event_code(dev->evdev,
+ litest_assert(!libevdev_has_event_code(dev->evdev,
EV_KEY, code));
continue;
}
litest_assert_empty_queue(li);
- ck_assert_int_ge(count, 1);
+ litest_assert_int_ge(count, 1);
#endif
}
END_TEST
litest_assert_empty_queue(li);
- ck_assert_int_gt(count, 3);
+ litest_assert_int_gt(count, 3);
#endif
}
END_TEST
/* litest virtual devices don't have modes */
mode = libinput_event_tablet_pad_get_mode(pev);
- ck_assert_int_eq(mode, 0);
+ litest_assert_int_eq(mode, 0);
group = libinput_event_tablet_pad_get_mode_group(pev);
index = libinput_tablet_pad_mode_group_get_index(group);
- ck_assert_int_eq(index, 0);
+ litest_assert_int_eq(index, 0);
libinput_event_destroy(ev);
pev = libinput_event_get_tablet_pad_event(ev);
mode = libinput_event_tablet_pad_get_mode(pev);
- ck_assert_int_eq(mode, 0);
+ litest_assert_int_eq(mode, 0);
group = libinput_event_tablet_pad_get_mode_group(pev);
index = libinput_tablet_pad_mode_group_get_index(group);
- ck_assert_int_eq(index, 0);
+ litest_assert_int_eq(index, 0);
libinput_event_destroy(ev);
}
int nrings;
nrings = libinput_device_tablet_pad_get_num_rings(device);
- ck_assert_int_ge(nrings, 1);
+ litest_assert_int_ge(nrings, 1);
}
END_TEST
LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER);
degrees = libinput_event_tablet_pad_get_ring_position(pev);
- ck_assert_double_ge(degrees, 0.0);
- ck_assert_double_lt(degrees, 360.0);
+ litest_assert_double_ge(degrees, 0.0);
+ litest_assert_double_lt(degrees, 360.0);
- ck_assert_double_eq(degrees, expected);
+ litest_assert_double_eq(degrees, expected);
libinput_event_destroy(ev);
expected = fmod(degrees + step_size, 360);
}
- ck_assert_int_eq(nevents, 360/step_size - 1);
+ litest_assert_int_eq(nevents, 360/step_size - 1);
litest_pad_ring_end(dev);
}
LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER);
degrees = libinput_event_tablet_pad_get_ring_position(pev);
- ck_assert_double_eq(degrees, -1.0);
+ litest_assert_double_eq(degrees, -1.0);
libinput_event_destroy(ev);
litest_assert_empty_queue(li);
expected_ndials = 2;
ndials = libinput_device_tablet_pad_get_num_dials(device);
- ck_assert_int_eq(ndials, expected_ndials);
+ litest_assert_int_eq(ndials, expected_ndials);
}
END_TEST
double v120 = libinput_event_tablet_pad_get_dial_delta_v120(pev);
switch (code) {
case REL_WHEEL: /* inverted */
- ck_assert_double_eq(v120, -120.0 * direction);
+ litest_assert_double_eq(v120, -120.0 * direction);
break;
case REL_DIAL:
- ck_assert_double_eq(v120, 120.0 * direction);
+ litest_assert_double_eq(v120, 120.0 * direction);
break;
default:
litest_abort_msg("Invalid dial code");
struct libinput_event_tablet_pad *pev = litest_is_pad_dial_event(ev, 0);
double v120 = libinput_event_tablet_pad_get_dial_delta_v120(pev);
- ck_assert_double_eq(v120, -increment); /* REL_WHEEL is inverted */
+ litest_assert_double_eq(v120, -increment); /* REL_WHEEL is inverted */
libinput_event_destroy(ev);
}
}
int nstrips;
nstrips = libinput_device_tablet_pad_get_num_strips(device);
- ck_assert_int_ge(nstrips, 1);
+ litest_assert_int_ge(nstrips, 1);
}
END_TEST
LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER);
pos = libinput_event_tablet_pad_get_strip_position(pev);
- ck_assert_double_ge(pos, 0.0);
- ck_assert_double_lt(pos, 1.0);
+ litest_assert_double_ge(pos, 0.0);
+ litest_assert_double_lt(pos, 1.0);
/* rounding errors, mostly caused by small physical range */
- ck_assert_double_ge(pos, expected - 0.02);
- ck_assert_double_le(pos, expected + 0.02);
+ litest_assert_double_ge(pos, expected - 0.02);
+ litest_assert_double_le(pos, expected + 0.02);
libinput_event_destroy(ev);
0,
LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER);
pos = libinput_event_tablet_pad_get_strip_position(pev);
- ck_assert_double_eq(pos, 1.0);
+ litest_assert_double_eq(pos, 1.0);
libinput_event_destroy(ev);
litest_pad_strip_end(dev);
LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER);
pos = libinput_event_tablet_pad_get_strip_position(pev);
- ck_assert_double_eq(pos, -1.0);
+ litest_assert_double_eq(pos, -1.0);
libinput_event_destroy(ev);
litest_assert_empty_queue(li);
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- ck_assert(libinput_device_config_left_handed_is_available(device));
+ litest_assert(libinput_device_config_left_handed_is_available(device));
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get(device),
1);
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 0);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
#endif
/* Without libwacom we default to left-handed being available */
#if HAVE_LIBWACOM
- ck_assert(!libinput_device_config_left_handed_is_available(device));
+ litest_assert(!libinput_device_config_left_handed_is_available(device));
#else
- ck_assert(libinput_device_config_left_handed_is_available(device));
+ litest_assert(libinput_device_config_left_handed_is_available(device));
#endif
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ 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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
status = libinput_device_config_left_handed_set(dev->libinput_device, 0);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- ck_assert_int_eq(libinput_device_config_left_handed_get(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get(device),
0);
- ck_assert_int_eq(libinput_device_config_left_handed_get_default(device),
+ litest_assert_int_eq(libinput_device_config_left_handed_get_default(device),
0);
#endif
}
LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER);
degrees = libinput_event_tablet_pad_get_ring_position(pev);
- ck_assert_double_ge(degrees, 0.0);
- ck_assert_double_lt(degrees, 360.0);
+ litest_assert_double_ge(degrees, 0.0);
+ litest_assert_double_lt(degrees, 360.0);
/* rounding errors, mostly caused by small physical range */
- ck_assert_double_ge(degrees, expected - 2);
- ck_assert_double_le(degrees, expected + 2);
+ litest_assert_double_ge(degrees, expected - 2);
+ litest_assert_double_le(degrees, expected + 2);
libinput_event_destroy(ev);
int i;
ngroups = libinput_device_tablet_pad_get_num_mode_groups(device);
- ck_assert_int_eq(ngroups, 1);
+ litest_assert_int_eq(ngroups, 1);
for (i = 0; i < ngroups; i++) {
group = libinput_device_tablet_pad_get_mode_group(device, i);
- ck_assert_notnull(group);
- ck_assert_int_eq(libinput_tablet_pad_mode_group_get_index(group),
+ litest_assert_notnull(group);
+ litest_assert_int_eq(libinput_tablet_pad_mode_group_get_index(group),
i);
}
group = libinput_device_tablet_pad_get_mode_group(device, ngroups);
- ck_assert(group == NULL);
+ litest_assert(group == NULL);
group = libinput_device_tablet_pad_get_mode_group(device, ngroups + 1);
- ck_assert(group == NULL);
+ litest_assert(group == NULL);
}
END_TEST
void *userdata = &rc;
group = libinput_device_tablet_pad_get_mode_group(device, 0);
- ck_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
+ litest_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
NULL);
libinput_tablet_pad_mode_group_set_user_data(group, userdata);
- ck_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
+ litest_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
&rc);
libinput_tablet_pad_mode_group_set_user_data(group, NULL);
- ck_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
+ litest_assert(libinput_tablet_pad_mode_group_get_user_data(group) ==
NULL);
}
END_TEST
group = libinput_device_tablet_pad_get_mode_group(device, 0);
g = libinput_tablet_pad_mode_group_ref(group);
- ck_assert_ptr_eq(g, group);
+ litest_assert_ptr_eq(g, group);
/* We don't expect this to be freed. Any leaks should be caught by
* valgrind. */
g = libinput_tablet_pad_mode_group_unref(group);
- ck_assert_ptr_eq(g, group);
+ litest_assert_ptr_eq(g, group);
}
END_TEST
unsigned int nmodes, mode;
ngroups = libinput_device_tablet_pad_get_num_mode_groups(device);
- ck_assert_int_ge(ngroups, 1);
+ litest_assert_int_ge(ngroups, 1);
group = libinput_device_tablet_pad_get_mode_group(device, 0);
nmodes = libinput_tablet_pad_mode_group_get_num_modes(group);
- ck_assert_int_eq(nmodes, 1);
+ litest_assert_int_eq(nmodes, 1);
mode = libinput_tablet_pad_mode_group_get_mode(group);
- ck_assert_int_lt(mode, nmodes);
+ litest_assert_int_lt(mode, nmodes);
}
END_TEST
int i, b, r, s;
ngroups = libinput_device_tablet_pad_get_num_mode_groups(device);
- ck_assert_int_ge(ngroups, 1);
+ litest_assert_int_ge(ngroups, 1);
nbuttons = libinput_device_tablet_pad_get_num_buttons(device);
nrings = libinput_device_tablet_pad_get_num_rings(device);
i);
if (libinput_tablet_pad_mode_group_has_button(group,
b)) {
- ck_assert(!found);
+ litest_assert(!found);
found = true;
}
}
- ck_assert(found);
+ litest_assert(found);
}
for (s = 0; s < nstrips; s++) {
i);
if (libinput_tablet_pad_mode_group_has_strip(group,
s)) {
- ck_assert(!found);
+ litest_assert(!found);
found = true;
}
}
- ck_assert(found);
+ litest_assert(found);
}
for (r = 0; r < nrings; r++) {
i);
if (libinput_tablet_pad_mode_group_has_ring(group,
r)) {
- ck_assert(!found);
+ litest_assert(!found);
found = true;
}
}
- ck_assert(found);
+ litest_assert(found);
}
}
END_TEST
int rc;
ngroups = libinput_device_tablet_pad_get_num_mode_groups(device);
- ck_assert_int_ge(ngroups, 1);
+ litest_assert_int_ge(ngroups, 1);
nbuttons = libinput_device_tablet_pad_get_num_buttons(device);
nrings = libinput_device_tablet_pad_get_num_rings(device);
group = libinput_device_tablet_pad_get_mode_group(device, i);
rc = libinput_tablet_pad_mode_group_has_button(group,
nbuttons);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_button(group,
nbuttons + 1);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_button(group,
0x1000000);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
}
for (i = 0; i < ngroups; i++) {
group = libinput_device_tablet_pad_get_mode_group(device, i);
rc = libinput_tablet_pad_mode_group_has_strip(group,
nstrips);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_strip(group,
nstrips + 1);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_strip(group,
0x1000000);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
}
for (i = 0; i < ngroups; i++) {
group = libinput_device_tablet_pad_get_mode_group(device, i);
rc = libinput_tablet_pad_mode_group_has_ring(group,
nrings);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_ring(group,
nrings + 1);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_tablet_pad_mode_group_has_ring(group,
0x1000000);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
}
}
END_TEST
int i, b;
ngroups = libinput_device_tablet_pad_get_num_mode_groups(device);
- ck_assert_int_ge(ngroups, 1);
+ litest_assert_int_ge(ngroups, 1);
/* Button must not be toggle buttons */
nbuttons = libinput_device_tablet_pad_get_num_buttons(device);
for (i = 0; i < ngroups; i++) {
group = libinput_device_tablet_pad_get_mode_group(device, i);
for (b = 0; b < nbuttons; b++) {
- ck_assert(!libinput_tablet_pad_mode_group_button_is_toggle(
+ litest_assert(!libinput_tablet_pad_mode_group_button_is_toggle(
group,
b));
}
counter.close_func_count = 0;
li = libinput_path_create_context(NULL, NULL);
- ck_assert(li == NULL);
+ litest_assert(li == NULL);
li = libinput_path_create_context(&counting_interface, &counter);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
libinput_unref(li);
- ck_assert_int_eq(counter.open_func_count, 0);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.open_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
}
END_TEST
counter.close_func_count = 0;
li = libinput_path_create_context(&counting_interface, &counter);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
litest_disable_log_handler(li);
device = libinput_path_add_device(li, path);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
- ck_assert_int_eq(counter.open_func_count, 0);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.open_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
litest_restore_log_handler(li);
libinput_unref(li);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
}
END_TEST
counter.close_func_count = 0;
li = libinput_path_create_context(&counting_interface, &counter);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
litest_disable_log_handler(li);
device = libinput_path_add_device(li, path);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
- ck_assert_int_eq(counter.open_func_count, 1);
- ck_assert_int_eq(counter.close_func_count, 1);
+ litest_assert_int_eq(counter.open_func_count, 1);
+ litest_assert_int_eq(counter.close_func_count, 1);
litest_restore_log_handler(li);
libinput_unref(li);
- ck_assert_int_eq(counter.close_func_count, 1);
+ litest_assert_int_eq(counter.close_func_count, 1);
}
END_TEST
umask(002);
fd = mkstemp(path);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
close(fd);
counter.open_func_count = 0;
litest_disable_log_handler(li);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li, path);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
- ck_assert_int_eq(counter.open_func_count, 0);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.open_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
litest_restore_log_handler(li);
libinput_unref(li);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
}
END_TEST
li = libinput_path_create_context(&counting_interface, &counter);
litest_set_log_handler_bug(li);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li, path);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
- ck_assert_int_eq(counter.open_func_count, 0);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.open_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
litest_restore_log_handler(li);
libinput_unref(li);
- ck_assert_int_eq(counter.close_func_count, 0);
+ litest_assert_int_eq(counter.close_func_count, 0);
free(path);
}
-1);
li = libinput_path_create_context(&counting_interface, &counter);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
litest_disable_log_handler(li);
- ck_assert(libinput_get_user_data(li) == &counter);
+ litest_assert(libinput_get_user_data(li) == &counter);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
- ck_assert_int_eq(counter.open_func_count, 1);
+ litest_assert_int_eq(counter.open_func_count, 1);
libevdev_uinput_destroy(uinput);
libinput_unref(li);
- ck_assert_int_eq(counter.close_func_count, 1);
+ litest_assert_int_eq(counter.close_func_count, 1);
}
END_TEST
struct libinput_device *device;
li = libinput_path_create_context(&simple_interface, NULL);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
libinput_ref(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
while (libinput_unref(li) != NULL)
;
int data1, data2;
li = libinput_path_create_context(&simple_interface, &data1);
- ck_assert_notnull(li);
- ck_assert(libinput_get_user_data(li) == &data1);
+ litest_assert_notnull(li);
+ litest_assert(libinput_get_user_data(li) == &data1);
libinput_set_user_data(li, &data2);
- ck_assert(libinput_get_user_data(li) == &data2);
+ litest_assert(libinput_get_user_data(li) == &data2);
libinput_unref(li);
}
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
seat = libinput_device_get_seat(device);
- ck_assert_notnull(seat);
+ litest_assert_notnull(seat);
seat_name = libinput_seat_get_logical_name(seat);
- ck_assert_str_eq(seat_name, "default");
+ litest_assert_str_eq(seat_name, "default");
libinput_event_destroy(event);
}
rc = libinput_device_set_seat_logical_name(device,
seat2_name);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
- ck_assert(libinput_event_get_device(event) == device);
+ litest_assert(libinput_event_get_device(event) == device);
libinput_event_destroy(event);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
- ck_assert(libinput_event_get_device(event) != device);
+ litest_assert(libinput_event_get_device(event) != device);
libinput_device_unref(device);
device = libinput_event_get_device(event);
seat2 = libinput_device_get_seat(device);
- ck_assert_str_ne(libinput_seat_get_logical_name(seat2),
+ litest_assert_str_ne(libinput_seat_get_logical_name(seat2),
seat1_name);
- ck_assert_str_eq(libinput_seat_get_logical_name(seat2),
+ litest_assert_str_eq(libinput_seat_get_logical_name(seat2),
seat2_name);
libinput_event_destroy(event);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
libinput_event_destroy(event);
}
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
sysname1 = safe_strdup(libinput_device_get_sysname(device));
libinput_event_destroy(event);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(event);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
sysname2 = safe_strdup(libinput_device_get_sysname(device));
libinput_event_destroy(event);
- ck_assert_str_eq(sysname1, sysname2);
+ litest_assert_str_eq(sysname1, sysname2);
free(sysname1);
free(sysname2);
litest_disable_log_handler(li);
device = libinput_path_add_device(li, "/tmp/");
litest_restore_log_handler(li);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_dispatch(li);
litest_dispatch(dev->libinput);
ev = libinput_get_event(dev->libinput);
- ck_assert_notnull(ev);
+ litest_assert_notnull(ev);
litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(ev);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
sysname = libinput_device_get_sysname(device);
- ck_assert_notnull(sysname);
- ck_assert_int_gt(strlen(sysname), 1);
- ck_assert(strchr(sysname, '/') == NULL);
- ck_assert(strneq(sysname, "event", 5));
+ litest_assert_notnull(sysname);
+ litest_assert_int_gt(strlen(sysname), 1);
+ litest_assert(strchr(sysname, '/') == NULL);
+ litest_assert(strneq(sysname, "event", 5));
libinput_event_destroy(ev);
}
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_drain_events(li);
libinput_path_remove_device(device);
libinput_event_destroy(event);
}
- ck_assert_int_eq(remove_event, 1);
+ litest_assert_int_eq(remove_event, 1);
}
END_TEST
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(dev->uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_drain_events(li);
libinput_path_remove_device(device);
libinput_event_destroy(event);
}
- ck_assert_int_eq(remove_event, 1);
+ litest_assert_int_eq(remove_event, 1);
}
END_TEST
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
libinput_suspend(li);
libinput_resume(li);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
libinput_suspend(li);
libinput_suspend(li);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
libinput_suspend(li);
libinput_resume(li);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput1));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
libinput_path_add_device(li, libevdev_uinput_get_devnode(uinput2));
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libinput_suspend(li);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libinput_resume(li);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libevdev_uinput_destroy(uinput1);
libevdev_uinput_destroy(uinput2);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput1));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput2));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libinput_suspend(li);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
/* now drop one of the devices */
libevdev_uinput_destroy(uinput1);
rc = libinput_resume(li);
- ck_assert_int_eq(rc, -1);
+ litest_assert_int_eq(rc, -1);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libevdev_uinput_destroy(uinput2);
libinput_unref(li);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput1));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput2));
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
libinput_suspend(li);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 2);
+ litest_assert_int_eq(nevents, 2);
/* now drop and remove one of the devices */
libevdev_uinput_destroy(uinput2);
libinput_device_unref(device);
rc = libinput_resume(li);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
litest_dispatch(li);
nevents++;
}
- ck_assert_int_eq(nevents, 1);
+ litest_assert_int_eq(nevents, 1);
libevdev_uinput_destroy(uinput1);
libinput_unref(li);
-1);
li = libinput_path_create_context(&simple_interface, NULL);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_drain_events(li);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
libinput_event_destroy(event);
-1);
li = libinput_path_create_context(&simple_interface, userdata);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
device = libinput_path_add_device(li,
libevdev_uinput_get_devnode(uinput));
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
litest_dispatch(li);
ev = libinput_get_event(li);
- ck_assert_notnull(ev);
+ litest_assert_notnull(ev);
litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(ev);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
saved_seat = libinput_device_get_seat(device);
libinput_seat_set_user_data(saved_seat, &data);
libinput_seat_ref(saved_seat);
libinput_event_destroy(ev);
- ck_assert_notnull(saved_seat);
+ litest_assert_notnull(saved_seat);
litest_assert_empty_queue(li);
litest_dispatch(li);
ev = libinput_get_event(li);
- ck_assert_notnull(ev);
+ litest_assert_notnull(ev);
litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
device = libinput_event_get_device(ev);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
seat = libinput_device_get_seat(device);
user_data = libinput_seat_get_user_data(seat);
if (user_data == &data) {
found = 1;
- ck_assert(seat == saved_seat);
+ litest_assert(seat == saved_seat);
}
libinput_event_destroy(ev);
- ck_assert(found == 1);
+ litest_assert(found == 1);
libinput_unref(li);
litest_set_log_handler_bug(li);
rc = libinput_udev_assign_seat(li, "foo");
- ck_assert_int_eq(rc, -1);
+ litest_assert_int_eq(rc, -1);
litest_restore_log_handler(li);
}
END_TEST
dev = litest_create(LITEST_IGNORED_MOUSE, NULL, NULL, NULL, NULL);
path = libevdev_uinput_get_devnode(dev->uinput);
- ck_assert_notnull(path);
+ litest_assert_notnull(path);
li = litest_create_context();
device = libinput_path_add_device(li, path);
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_destroy_context(li);
litest_delete_device(dev);
prop = udev_device_get_property_value(ud, "MOUSE_DPI");
if (prop) {
dpi = parse_mouse_dpi_property(prop);
- ck_assert_int_ne(dpi, 0);
+ litest_assert_int_ne(dpi, 0);
dx *= 1000.0/dpi;
dy *= 1000.0/dpi;
evx = libinput_event_pointer_get_dx(ptrev);
evy = libinput_event_pointer_get_dy(ptrev);
- ck_assert((evx == 0.0) == (dx == 0));
- ck_assert((evy == 0.0) == (dy == 0));
+ litest_assert((evx == 0.0) == (dx == 0));
+ litest_assert((evy == 0.0) == (dy == 0));
len = hypot(evx, evy);
- ck_assert_double_ge(fabs(len), 0.3);
+ litest_assert_double_ge(fabs(len), 0.3);
libinput_event_destroy(event);
}
ev1 = libinput_get_event(libinput1);
ev2 = libinput_get_event(libinput2);
- ck_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_int_eq(libinput_event_get_type(ev1),
LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE);
- ck_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_int_eq(libinput_event_get_type(ev1),
libinput_event_get_type(ev2));
p1 = libinput_event_get_pointer_event(ev1);
/* Mark all released buttons until device is removed */
while (1) {
event = libinput_get_event(libinput);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
type = libinput_event_get_type(event);
if (type == LIBINPUT_EVENT_DEVICE_REMOVED) {
litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_BUTTON);
pevent = libinput_event_get_pointer_event(event);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(pevent),
+ litest_assert_int_eq(libinput_event_pointer_get_button_state(pevent),
LIBINPUT_BUTTON_STATE_RELEASED);
button = libinput_event_pointer_get_button(pevent);
valid_code = 0;
for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
if (buttons[i].code == button) {
- ck_assert_int_eq(buttons[i].released, 0);
+ litest_assert_int_eq(buttons[i].released, 0);
buttons[i].released = 1;
valid_code = 1;
}
}
- ck_assert_int_eq(valid_code, 1);
+ litest_assert_int_eq(valid_code, 1);
libinput_event_destroy(event);
}
/* Check that all pressed buttons has been released. */
for (i = 0; i < ARRAY_LENGTH(buttons); ++i) {
- ck_assert_int_eq(buttons[i].released, 1);
+ litest_assert_int_eq(buttons[i].released, 1);
}
litest_destroy_context(libinput);
struct libinput_device *device = dev->libinput_device;
unsigned int code;
- ck_assert(!libinput_device_has_capability(device,
+ litest_assert(!libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_POINTER));
for (code = BTN_LEFT; code < KEY_OK; code++)
- ck_assert_int_eq(-1,
+ litest_assert_int_eq(-1,
libinput_device_pointer_has_button(device, code));
}
END_TEST
litest_drain_events(dev->libinput);
/* make sure we hit at least one of the below two conditions */
- ck_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
+ litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
{
struct litest_device *dev = litest_current_device();
- ck_assert_int_ge(libinput_device_config_scroll_has_natural_scroll(dev->libinput_device), 1);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
- ck_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_ge(libinput_device_config_scroll_has_natural_scroll(dev->libinput_device), 1);
+ litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
if (libinput_device_config_scroll_has_natural_scroll(dev->libinput_device))
return;
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
- ck_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
enum libinput_config_status status;
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 1);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
libinput_device_config_scroll_set_natural_scroll_enabled(device, 1);
/* make sure we hit at least one of the below two conditions */
- ck_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
+ litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
0);
- ck_assert_int_eq(libinput_event_pointer_has_axis(pev, -1), 0);
- ck_assert_int_eq(libinput_event_pointer_has_axis(pev, 2), 0);
- ck_assert_int_eq(libinput_event_pointer_has_axis(pev, 3), 0);
- ck_assert_int_eq(libinput_event_pointer_has_axis(pev, 0xffff), 0);
+ litest_assert_int_eq(libinput_event_pointer_has_axis(pev, -1), 0);
+ litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 2), 0);
+ litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 3), 0);
+ litest_assert_int_eq(libinput_event_pointer_has_axis(pev, 0xffff), 0);
libinput_event_destroy(event);
}
END_TEST
libinput_device_config_rotation_set_angle(device, angle);
/* make sure we hit at least one of the below two conditions */
- ck_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
+ litest_assert(libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL) ||
libevdev_has_event_code(dev->evdev, EV_REL, REL_HWHEEL));
if (libevdev_has_event_code(dev->evdev, EV_REL, REL_WHEEL)) {
}
tev = libinput_event_get_pointer_event(ev);
- ck_assert_notnull(tev);
- ck_assert_int_eq(libinput_event_pointer_get_button(tev),
+ litest_assert_notnull(tev);
+ litest_assert_int_eq(libinput_event_pointer_get_button(tev),
BTN_LEFT);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_pointer_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
++expected_seat_button_count;
seat_button_count =
libinput_event_pointer_get_seat_button_count(tev);
- ck_assert_int_eq(expected_seat_button_count, seat_button_count);
+ litest_assert_int_eq(expected_seat_button_count, seat_button_count);
libinput_event_destroy(ev);
litest_dispatch(libinput);
}
- ck_assert_int_eq(seat_button_count, num_devices);
+ litest_assert_int_eq(seat_button_count, num_devices);
for (i = 0; i < num_devices; ++i)
litest_button_click_debounced(devices[i],
}
tev = libinput_event_get_pointer_event(ev);
- ck_assert_notnull(tev);
- ck_assert_int_eq(libinput_event_pointer_get_button(tev),
+ litest_assert_notnull(tev);
+ litest_assert_int_eq(libinput_event_pointer_get_button(tev),
BTN_LEFT);
- ck_assert_int_eq(libinput_event_pointer_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_pointer_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
--expected_seat_button_count;
seat_button_count =
libinput_event_pointer_get_seat_button_count(tev);
- ck_assert_int_eq(expected_seat_button_count, seat_button_count);
+ litest_assert_int_eq(expected_seat_button_count, seat_button_count);
libinput_event_destroy(ev);
litest_dispatch(libinput);
}
- ck_assert_int_eq(seat_button_count, 0);
+ litest_assert_int_eq(seat_button_count, 0);
for (i = 0; i < num_devices; ++i)
litest_delete_device(devices[i]);
float calibration[6] = {0};
rc = libinput_device_config_calibration_has_matrix(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_calibration_get_matrix(d, calibration);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_calibration_get_default_matrix(d,
calibration);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
return;
rc = libinput_device_config_left_handed_is_available(d);
- ck_assert_int_ne(rc, 0);
+ litest_assert_int_ne(rc, 0);
rc = libinput_device_config_left_handed_get(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_left_handed_get_default(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
}
END_TEST
enum libinput_config_status status;
status = libinput_device_config_left_handed_set(d, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(dev, li, BTN_LEFT, 1);
enum libinput_config_status status;
methods = libinput_device_config_scroll_get_method(device);
- ck_assert_int_eq((methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN), 0);
+ litest_assert_int_eq((methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN), 0);
button = libinput_device_config_scroll_get_button(device);
- ck_assert_int_eq(button, 0);
+ litest_assert_int_eq(button, 0);
button = libinput_device_config_scroll_get_default_button(device);
- ck_assert_int_eq(button, 0);
+ litest_assert_int_eq(button, 0);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_scroll_set_button(device, BTN_LEFT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button(device, BTN_MIDDLE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button(device, button);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_button_lock(device,
LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
state = libinput_device_config_scroll_get_default_button_lock(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_int_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);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
state = libinput_device_config_scroll_get_default_button_lock(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
state = libinput_device_config_scroll_get_button_lock(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
expected = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
method = libinput_device_config_scroll_get_method(device);
- ck_assert_int_eq(method, expected);
+ litest_assert_int_eq(method, expected);
method = libinput_device_config_scroll_get_default_method(device);
- ck_assert_int_eq(method, expected);
+ litest_assert_int_eq(method, expected);
if (method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) {
button = libinput_device_config_scroll_get_button(device);
- ck_assert_int_eq(button, BTN_MIDDLE);
+ litest_assert_int_eq(button, BTN_MIDDLE);
button = libinput_device_config_scroll_get_default_button(device);
- ck_assert_int_eq(button, BTN_MIDDLE);
+ litest_assert_int_eq(button, BTN_MIDDLE);
}
}
END_TEST
uint32_t button;
method = libinput_device_config_scroll_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
method = libinput_device_config_scroll_get_default_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
button = libinput_device_config_scroll_get_button(device);
- ck_assert_int_eq(button, BTN_SIDE);
+ litest_assert_int_eq(button, BTN_SIDE);
}
END_TEST
enum libinput_config_status status;
double speed;
- ck_assert(libinput_device_config_accel_is_available(device));
- ck_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
+ litest_assert(libinput_device_config_accel_is_available(device));
+ litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
0.0);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
for (speed = -2.0; speed < -1.0; speed += 0.2) {
status = libinput_device_config_accel_set_speed(device,
speed);
- ck_assert_int_eq(status,
+ litest_assert_int_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ 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);
- ck_assert_int_eq(status,
+ litest_assert_int_eq(status,
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ 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);
- ck_assert_int_eq(status,
+ litest_assert_int_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
1.0);
}
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- ck_assert(libinput_device_config_accel_is_available(device));
+ litest_assert(libinput_device_config_accel_is_available(device));
status = libinput_device_config_accel_set_speed(device,
NAN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_speed(device,
INFINITY);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_status status;
double speed;
- ck_assert(!libinput_device_config_accel_is_available(device));
- ck_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
+ litest_assert(!libinput_device_config_accel_is_available(device));
+ litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
0.0);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
for (speed = -2.0; speed <= 2.0; speed += 0.2) {
status = libinput_device_config_accel_set_speed(device,
speed);
if (speed >= -1.0 && speed <= 1.0)
- ck_assert_int_eq(status,
+ litest_assert_int_eq(status,
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
else
- ck_assert_int_eq(status,
+ litest_assert_int_eq(status,
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
}
}
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(libinput_device_config_accel_is_available(device));
- ck_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
+ litest_assert(libinput_device_config_accel_is_available(device));
+ litest_assert_double_eq(libinput_device_config_accel_get_default_speed(device),
0.0);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
0.0);
}
END_TEST
pev = libinput_event_get_pointer_event(event);
delta = libinput_event_pointer_get_dx(pev);
- ck_assert_double_le(delta, 0.0);
+ litest_assert_double_le(delta, 0.0);
libinput_event_destroy(event);
event = libinput_get_event(li);
} while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE);
pev = libinput_event_get_pointer_event(event);
delta = libinput_event_pointer_get_dx(pev);
- ck_assert_double_gt(delta, 0.0);
+ litest_assert_double_gt(delta, 0.0);
libinput_event_destroy(event);
}
END_TEST
enum libinput_config_accel_profile profile;
uint32_t profiles;
- ck_assert(libinput_device_config_accel_is_available(device));
+ litest_assert(libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
profiles = libinput_device_config_accel_get_profiles(device);
- ck_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- ck_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
+ litest_assert(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
profile = libinput_device_config_accel_get_default_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
}
END_TEST
};
ARRAY_FOR_EACH(profiles, profile) {
- ck_assert_int_eq(libinput_device_config_accel_set_speed(device, 1.0),
+ litest_assert_int_eq(libinput_device_config_accel_set_speed(device, 1.0),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device), 1.0);
+ 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);
- ck_assert_int_eq(libinput_device_config_accel_apply(device, config),
+ litest_assert_int_eq(libinput_device_config_accel_apply(device, config),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_double_eq(libinput_device_config_accel_get_speed(device),
+ litest_assert_double_eq(libinput_device_config_accel_get_speed(device),
default_speed);
libinput_config_accel_destroy(config);
}
{ 1, { 1.0, 2.0, 1e10, 2.6 }, invalid },
};
- ck_assert(libinput_device_config_accel_is_available(device));
+ litest_assert(libinput_device_config_accel_is_available(device));
struct libinput_config_accel *config_custom_default =
libinput_config_accel_create(LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
struct libinput_config_accel *config_custom_changed =
libinput_config_accel_create(LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
- ck_assert_ptr_nonnull(config_custom_default);
- ck_assert_ptr_nonnull(config_custom_changed);
+ litest_assert_ptr_notnull(config_custom_default);
+ litest_assert_ptr_notnull(config_custom_changed);
ARRAY_FOR_EACH(tests, t) {
ARRAY_FOR_EACH(accel_types, accel_type) {
t->step,
ARRAY_LENGTH(t->points),
t->points);
- ck_assert_int_eq(status, t->expected_status);
+ litest_assert_int_eq(status, t->expected_status);
status = libinput_device_config_accel_apply(device, config_custom_changed);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
status = libinput_device_config_accel_apply(device, config_custom_default);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
}
}
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- ck_assert(libinput_device_config_accel_is_available(device));
+ litest_assert(libinput_device_config_accel_is_available(device));
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_status status;
enum libinput_config_accel_profile profile;
- ck_assert(!libinput_device_config_accel_is_available(device));
+ litest_assert(!libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE + 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE |LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
return;
available = libinput_device_config_middle_emulation_is_available(device);
- ck_assert(available);
+ litest_assert(available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
int available;
available = libinput_device_config_middle_emulation_is_available(device);
- ck_assert(available);
+ litest_assert(available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
return;
available = libinput_device_config_middle_emulation_is_available(device);
- ck_assert(!available);
+ litest_assert(!available);
if (libinput_device_pointer_has_button(device, BTN_MIDDLE))
return;
state = libinput_device_config_middle_emulation_get_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
}
END_TEST
int available;
available = libinput_device_config_middle_emulation_is_available(device);
- ck_assert(available);
+ litest_assert(available);
state = libinput_device_config_middle_emulation_get_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
}
END_TEST
int available;
available = libinput_device_config_middle_emulation_is_available(device);
- ck_assert(!available);
+ litest_assert(!available);
state = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
state = libinput_device_config_middle_emulation_get_default_enabled(
device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
- ck_assert_double_gt(litest_event_pointer_get_value(pev,
+ litest_assert_double_gt(litest_event_pointer_get_value(pev,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL),
0.0);
libinput_event_destroy(ev);
ptrev = litest_is_motion_event(event);
time_usec = libinput_event_pointer_get_time_usec(ptrev);
- ck_assert_int_eq(libinput_event_pointer_get_time(ptrev),
+ litest_assert_int_eq(libinput_event_pointer_get_time(ptrev),
(uint32_t) (time_usec / 1000));
libinput_event_destroy(event);
log_handler,
NULL,
QLOG_LIBINPUT_LOGGING);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
}
END_TEST
log_handler,
NULL,
QLOG_LIBINPUT_LOGGING);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
quirks_context_unref(ctx);
cleanup_data_dir(dd);
}
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert(ctx == NULL);
+ litest_assert(ctx == NULL);
cleanup_data_dir(dd);
}
}
if (ctx != NULL) {
struct quirks *q;
q = quirks_fetch_for_device(ctx, ud);
- ck_assert_notnull(q);
- ck_assert(func(q, which, data));
- ck_assert(quirks_has_quirk(q, which));
+ litest_assert_notnull(q);
+ litest_assert(func(q, which, data));
+ litest_assert(quirks_has_quirk(q, which));
quirks_unref(q);
quirks_context_unref(ctx);
result = true;
t->str,
(qparsefunc)quirks_get_dimensions,
&dim);
- ck_assert_int_eq(rc, t->success);
+ litest_assert_int_eq(rc, t->success);
if (!rc)
continue;
- ck_assert_int_eq(dim.x, t->w);
- ck_assert_int_eq(dim.y, t->h);
+ litest_assert_int_eq(dim.x, t->w);
+ litest_assert_int_eq(dim.y, t->h);
}
}
}
t->str,
(qparsefunc)quirks_get_range,
&r);
- ck_assert_int_eq(rc, t->success);
+ litest_assert_int_eq(rc, t->success);
if (!rc)
continue;
- ck_assert_int_eq(r.lower, t->lo);
- ck_assert_int_eq(r.upper, t->hi);
+ litest_assert_int_eq(r.lower, t->lo);
+ litest_assert_int_eq(r.upper, t->hi);
}
}
}
t->str,
(qparsefunc)quirks_get_uint32,
&v);
- ck_assert_int_eq(rc, t->success);
+ litest_assert_int_eq(rc, t->success);
if (!rc)
continue;
- ck_assert_int_eq(v, t->val);
+ litest_assert_int_eq(v, t->val);
}
}
}
t->str,
(qparsefunc)quirks_get_double,
&v);
- ck_assert_int_eq(rc, t->success);
+ litest_assert_int_eq(rc, t->success);
if (!rc)
continue;
- ck_assert_double_eq(v, t->val);
+ litest_assert_double_eq(v, t->val);
}
}
}
(qparsefunc)quirks_get_string,
&do_not_use);
if (*a == t->where)
- ck_assert_int_eq(rc, true);
+ litest_assert_int_eq(rc, true);
else
- ck_assert_int_eq(rc, false);
+ litest_assert_int_eq(rc, false);
}
}
}
t->str,
(qparsefunc)quirks_get_bool,
&v);
- ck_assert(rc == t->success);
+ litest_assert(rc == t->success);
if (!rc)
continue;
- ck_assert(v == t->val);
+ litest_assert(v == t->val);
}
}
}
"internal",
(qparsefunc)quirks_get_string,
&do_not_use);
- ck_assert(rc);
+ litest_assert(rc);
rc = test_attr_parse(dev,
QUIRK_ATTR_KEYBOARD_INTEGRATION,
"external",
(qparsefunc)quirks_get_string,
&do_not_use);
- ck_assert(rc);
+ litest_assert(rc);
rc = test_attr_parse(dev,
QUIRK_ATTR_TRACKPOINT_INTEGRATION,
"internal",
(qparsefunc)quirks_get_string,
&do_not_use);
- ck_assert(rc);
+ litest_assert(rc);
rc = test_attr_parse(dev,
QUIRK_ATTR_TRACKPOINT_INTEGRATION,
"external",
(qparsefunc)quirks_get_string,
&do_not_use);
- ck_assert(rc);
+ litest_assert(rc);
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
q = quirks_fetch_for_device(ctx, ud);
- ck_assert_notnull(q);
+ litest_assert_notnull(q);
- ck_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
- ck_assert(isset == true);
+ litest_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
+ litest_assert(isset == true);
quirks_unref(q);
quirks_context_unref(ctx);
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
q = quirks_fetch_for_device(ctx, ud);
- ck_assert_notnull(q);
+ litest_assert_notnull(q);
- ck_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
- ck_assert(isset == false);
+ litest_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
+ litest_assert(isset == false);
quirks_unref(q);
quirks_context_unref(ctx);
"ModelAppleTouchpad=%d\n",
set ? 0 : 1,
set ? 1 : 0);
- ck_assert_int_ne(rc, -1);
+ litest_assert_int_ne(rc, -1);
dd = make_data_dir(quirks_file);
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
q = quirks_fetch_for_device(ctx, ud);
- ck_assert_notnull(q);
+ litest_assert_notnull(q);
- ck_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
- ck_assert(isset == set);
+ litest_assert(quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &isset));
+ litest_assert(isset == set);
quirks_unref(q);
quirks_context_unref(ctx);
exists = quirks_get_bool(q, QUIRK_MODEL_ALPS_SERIAL_TOUCHPAD, &value);
if (strstr(libinput_device_get_name(device), "ALPS")) {
- ck_assert(exists);
- ck_assert(value);
+ litest_assert(exists);
+ litest_assert(value);
} else {
- ck_assert(!exists);
- ck_assert(!value);
+ litest_assert(!exists);
+ litest_assert(!value);
}
}
END_TEST
exists = quirks_get_bool(q, QUIRK_MODEL_WACOM_TOUCHPAD, &value);
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_WACOM) {
- ck_assert(exists);
- ck_assert(value);
+ litest_assert(exists);
+ litest_assert(value);
} else {
- ck_assert(!exists);
- ck_assert(!value);
+ litest_assert(!exists);
+ litest_assert(!value);
}
}
END_TEST
exists = quirks_get_bool(q, QUIRK_MODEL_APPLE_TOUCHPAD, &value);
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_APPLE) {
- ck_assert(exists);
- ck_assert(value);
+ litest_assert(exists);
+ litest_assert(value);
} else {
- ck_assert(!exists);
- ck_assert(!value);
+ litest_assert(!exists);
+ litest_assert(!value);
}
}
END_TEST
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_SYNAPTICS_SERIAL &&
libevdev_get_id_product(dev->evdev) == PRODUCT_ID_SYNAPTICS_SERIAL) {
- ck_assert(exists);
- ck_assert(value);
+ litest_assert(exists);
+ litest_assert(value);
} else {
- ck_assert(!exists);
- ck_assert(!value);
+ litest_assert(!exists);
+ litest_assert(!value);
}
}
END_TEST
START_TEST(quirks_call_NULL)
{
- ck_assert(!quirks_fetch_for_device(NULL, NULL));
-
- ck_assert(!quirks_get_uint32(NULL, 0, NULL));
- ck_assert(!quirks_get_int32(NULL, 0, NULL));
- ck_assert(!quirks_get_range(NULL, 0, NULL));
- ck_assert(!quirks_get_dimensions(NULL, 0, NULL));
- ck_assert(!quirks_get_double(NULL, 0, NULL));
- ck_assert(!quirks_get_string(NULL, 0, NULL));
- ck_assert(!quirks_get_bool(NULL, 0, NULL));
+ litest_assert(!quirks_fetch_for_device(NULL, NULL));
+
+ litest_assert(!quirks_get_uint32(NULL, 0, NULL));
+ litest_assert(!quirks_get_int32(NULL, 0, NULL));
+ litest_assert(!quirks_get_range(NULL, 0, NULL));
+ litest_assert(!quirks_get_dimensions(NULL, 0, NULL));
+ litest_assert(!quirks_get_double(NULL, 0, NULL));
+ litest_assert(!quirks_get_string(NULL, 0, NULL));
+ litest_assert(!quirks_get_bool(NULL, 0, NULL));
}
END_TEST
log_handler,
NULL,
QLOG_CUSTOM_LOG_PRIORITIES);
- ck_assert_notnull(ctx);
+ litest_assert_notnull(ctx);
ctx2 = quirks_context_ref(ctx);
litest_assert_ptr_eq(ctx, ctx2);
ctx2 = quirks_context_unref(ctx);
/* Need to check for this specific device here because the
* unreliable tablet mode switch removes the capability too */
if (dev->which == LITEST_TABLET_MODE_UNRELIABLE) {
- ck_assert(!libinput_device_has_capability(dev->libinput_device,
+ litest_assert(!libinput_device_has_capability(dev->libinput_device,
LIBINPUT_DEVICE_CAP_SWITCH));
return;
}
- ck_assert(libinput_device_has_capability(dev->libinput_device,
+ litest_assert(libinput_device_has_capability(dev->libinput_device,
LIBINPUT_DEVICE_CAP_SWITCH));
}
if (!libevdev_has_event_code(dev->evdev, EV_SW, SW_LID))
return;
- ck_assert_int_eq(libinput_device_switch_has_switch(dev->libinput_device,
+ litest_assert_int_eq(libinput_device_switch_has_switch(dev->libinput_device,
LIBINPUT_SWITCH_LID),
1);
}
LIBINPUT_SWITCH_TABLET_MODE);
if (!tablet_mode_switch_is_reliable(dev))
- ck_assert_int_ne(has_switch, 1);
+ litest_assert_int_ne(has_switch, 1);
else
- ck_assert_int_eq(has_switch, 1);
+ litest_assert_int_eq(has_switch, 1);
}
END_TEST
libinput_event_destroy(event);
while ((event = libinput_get_event(li))) {
- ck_assert_int_ne(libinput_event_get_type(event),
+ litest_assert_int_ne(libinput_event_get_type(event),
LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(event);
}
litest_dispatch(li);
while ((event = libinput_get_event(li)) != NULL) {
- ck_assert_int_ne(libinput_event_get_type(event),
+ litest_assert_int_ne(libinput_event_get_type(event),
LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(event);
}
/* Separate direct libevdev context to check if the HW event goes
* through */
fd = open(libevdev_uinput_get_devnode(sw->uinput), O_RDONLY|O_NONBLOCK);
- ck_assert_int_ge(fd, 0);
- ck_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
- ck_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
+ litest_assert_int_ge(fd, 0);
+ litest_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
+ litest_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
/* Typing on the keyboard should trigger a lid open event */
litest_event(keyboard, EV_KEY, KEY_A, 1);
litest_drain_events(li);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SW);
- ck_assert_int_eq(event.code, SW_LID);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SW);
+ litest_assert_int_eq(event.code, SW_LID);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SYN);
- ck_assert_int_eq(event.code, SYN_REPORT);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SYN);
+ litest_assert_int_eq(event.code, SYN_REPORT);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, -EAGAIN);
+ litest_assert_int_eq(rc, -EAGAIN);
litest_delete_device(keyboard);
close(fd);
/* Separate direct libevdev context to check if the HW event goes
* through */
fd = open(libevdev_uinput_get_devnode(sw->uinput), O_RDONLY|O_NONBLOCK);
- ck_assert_int_ge(fd, 0);
- ck_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
- ck_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
+ litest_assert_int_ge(fd, 0);
+ litest_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
+ litest_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
keyboard = litest_add_device(sw->libinput, LITEST_KEYBOARD);
/* don't expect a switch waiting for us, this is run for an
* unreliable device */
while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE) {
- ck_assert_int_ne(libinput_next_event_type(li),
+ litest_assert_int_ne(libinput_next_event_type(li),
LIBINPUT_EVENT_SWITCH_TOGGLE);
libinput_event_destroy(libinput_get_event(li));
}
/* Make sure kernel state has updated */
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SW);
- ck_assert_int_eq(event.code, SW_LID);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SW);
+ litest_assert_int_eq(event.code, SW_LID);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SYN);
- ck_assert_int_eq(event.code, SYN_REPORT);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SYN);
+ litest_assert_int_eq(event.code, SYN_REPORT);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, -EAGAIN);
+ litest_assert_int_eq(rc, -EAGAIN);
litest_destroy_context(li);
litest_delete_device(keyboard);
/* Separate direct libevdev context to check if the HW event goes
* through */
fd = open(libevdev_uinput_get_devnode(sw->uinput), O_RDONLY|O_NONBLOCK);
- ck_assert_int_ge(fd, 0);
- ck_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
- ck_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
+ litest_assert_int_ge(fd, 0);
+ litest_assert_int_eq(libevdev_new_from_fd(fd, &evdev), 0);
+ litest_assert_int_eq(libevdev_get_event_value(evdev, EV_SW, SW_LID), 1);
/* Typing on the second keyboard should trigger a lid open event */
litest_event(keyboard2, EV_KEY, KEY_A, 1);
litest_drain_events(li);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SW);
- ck_assert_int_eq(event.code, SW_LID);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SW);
+ litest_assert_int_eq(event.code, SW_LID);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
- ck_assert_int_eq(event.type, EV_SYN);
- ck_assert_int_eq(event.code, SYN_REPORT);
- ck_assert_int_eq(event.value, 0);
+ litest_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
+ litest_assert_int_eq(event.type, EV_SYN);
+ litest_assert_int_eq(event.code, SYN_REPORT);
+ litest_assert_int_eq(event.value, 0);
rc = libevdev_next_event(evdev, LIBEVDEV_READ_FLAG_NORMAL, &event);
- ck_assert_int_eq(rc, -EAGAIN);
+ litest_assert_int_eq(rc, -EAGAIN);
litest_delete_device(keyboard1);
litest_delete_device(keyboard2);
libinput_event_destroy(event);
}
- ck_assert(have_switch_toggle);
+ litest_assert(have_switch_toggle);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10);
libinput_event_destroy(event);
}
- ck_assert(have_switch_toggle);
+ litest_assert(have_switch_toggle);
litest_keyboard_key(keyboard, KEY_A, true);
litest_keyboard_key(keyboard, KEY_A, false);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 1);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 1);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_PRESSED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 2);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 2);
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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 1);
+ 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), 1);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
LIBINPUT_BUTTON_STATE_RELEASED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tev), button);
- ck_assert_int_eq(libinput_event_tablet_tool_get_seat_button_count(tev), 0);
+ 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), 0);
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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool), LIBINPUT_TABLET_TOOL_TYPE_ERASER);
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
BTN_STYLUS);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
BTN_STYLUS);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
BTN_STYLUS);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(tablet_event),
BTN_STYLUS);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
- ck_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
- ck_assert_double_lt(last_x, x);
- ck_assert_double_lt(last_y, y);
+ litest_assert_double_lt(last_x, x);
+ litest_assert_double_lt(last_y, y);
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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
- ck_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
- ck_assert_double_ne(last_x, x);
- ck_assert_double_ne(last_y, y);
+ litest_assert_double_ne(last_x, x);
+ litest_assert_double_ne(last_y, y);
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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
switch(axis) {
case ABS_X:
- ck_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event));
- ck_assert_double_ne(last_x, x);
- ck_assert_double_eq(last_y, y);
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert_double_ne(last_x, x);
+ litest_assert_double_eq(last_y, y);
break;
case ABS_Y:
- ck_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
- ck_assert_double_eq(last_x, x);
- ck_assert_double_ne(last_y, y);
+ litest_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert_double_eq(last_x, x);
+ litest_assert_double_ne(last_y, y);
break;
}
event = libinput_get_event(li);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(tablet_event),
LIBINPUT_TABLET_TOOL_TIP_UP);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY) {
struct libinput_tablet_tool * tool;
- ck_assert(!have_tool_update);
+ litest_assert(!have_tool_update);
have_tool_update = true;
tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool), type);
+ litest_assert_int_eq(libinput_tablet_tool_get_type(tool), type);
}
libinput_event_destroy(event);
}
- ck_assert(have_tool_update);
+ litest_assert(have_tool_update);
litest_tablet_proximity_out(dev);
litest_dispatch(li);
libinput_event_destroy(event);
}
- ck_assert(have_proximity_out);
+ litest_assert(have_proximity_out);
/* Proximity out must not emit axis events */
litest_assert_empty_queue(li);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
do {
tablet_event = libinput_event_get_tablet_tool_event(event);
libinput_event_destroy(event);
} while ((event = libinput_get_event(li)));
- ck_assert_msg(button_released,
+ litest_assert_msg(button_released,
"Button %s (%d) was not released.",
libevdev_event_code_get_name(EV_KEY, *button),
event_button);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tablet_event));
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
litest_assert_double_ne(y, 0);
if (libinput_tablet_tool_has_distance(tool)) {
- ck_assert(libinput_event_tablet_tool_distance_has_changed(
+ litest_assert(libinput_event_tablet_tool_distance_has_changed(
tablet_event));
distance = libinput_event_tablet_tool_get_distance(tablet_event);
}
if (libinput_tablet_tool_has_tilt(tool)) {
- ck_assert(libinput_event_tablet_tool_tilt_x_has_changed(
+ litest_assert(libinput_event_tablet_tool_tilt_x_has_changed(
tablet_event));
- ck_assert(libinput_event_tablet_tool_tilt_y_has_changed(
+ litest_assert(libinput_event_tablet_tool_tilt_y_has_changed(
tablet_event));
x = libinput_event_tablet_tool_get_tilt_x(tablet_event);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event));
- ck_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event));
+ litest_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event));
+ litest_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event));
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
litest_assert_double_le(y, last_y + 1);
if (libinput_tablet_tool_has_distance(tool)) {
- ck_assert(!libinput_event_tablet_tool_distance_has_changed(
+ litest_assert(!libinput_event_tablet_tool_distance_has_changed(
tablet_event));
distance = libinput_event_tablet_tool_get_distance(
}
if (libinput_tablet_tool_has_tilt(tool)) {
- ck_assert(!libinput_event_tablet_tool_tilt_x_has_changed(
+ litest_assert(!libinput_event_tablet_tool_tilt_x_has_changed(
tablet_event));
- ck_assert(!libinput_event_tablet_tool_tilt_y_has_changed(
+ litest_assert(!libinput_event_tablet_tool_tilt_y_has_changed(
tablet_event));
x = libinput_event_tablet_tool_get_tilt_x(tablet_event);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
x_changed = libinput_event_tablet_tool_x_has_changed(tablet_event);
y_changed = libinput_event_tablet_tool_y_has_changed(tablet_event);
- ck_assert(x_changed);
- ck_assert(y_changed);
+ litest_assert(x_changed);
+ litest_assert(y_changed);
reported_x = libinput_event_tablet_tool_get_x(tablet_event);
reported_y = libinput_event_tablet_tool_get_y(tablet_event);
y_changed = libinput_event_tablet_tool_y_has_changed(
tablet_event);
- ck_assert(x_changed);
- ck_assert(y_changed);
+ litest_assert(x_changed);
+ litest_assert(y_changed);
reported_x = libinput_event_tablet_tool_get_x(
tablet_event);
litest_drain_events(li);
- ck_assert(libinput_device_config_left_handed_is_available(dev->libinput_device));
+ litest_assert(libinput_device_config_left_handed_is_available(dev->libinput_device));
libinput_device_get_size (dev->libinput_device,
&libinput_max_x,
/* Without libwacom we default to left-handed being available */
#if HAVE_LIBWACOM
- ck_assert(!libinput_device_config_left_handed_is_available(dev->libinput_device));
+ litest_assert(!libinput_device_config_left_handed_is_available(dev->libinput_device));
#else
- ck_assert(libinput_device_config_left_handed_is_available(dev->libinput_device));
+ litest_assert(libinput_device_config_left_handed_is_available(dev->libinput_device));
#endif
}
END_TEST
double tx, ty;
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
tx = libinput_event_tablet_tool_get_tilt_x(tev);
ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_lt(tx, 0);
- ck_assert_double_gt(ty, 0);
+ litest_assert_double_lt(tx, 0);
+ litest_assert_double_gt(ty, 0);
libinput_event_destroy(event);
#endif
int tilt_center_x, tilt_center_y;
abs = libevdev_get_abs_info(dev->evdev, ABS_TILT_X);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
tilt_center_x = absinfo_range(abs) / 2;
abs = libevdev_get_abs_info(dev->evdev, ABS_TILT_Y);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
tilt_center_y = absinfo_range(abs) / 2;
x = cos(a) * 20 + tilt_center_x;
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
val = libinput_event_tablet_tool_get_rotation(tev);
libinput_event_destroy(event);
};
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
return;
status = libinput_device_config_left_handed_set(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
abs = libevdev_get_abs_info(dev->evdev, ABS_Z);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
scale = absinfo_range(abs)/360.0;
litest_event(dev, EV_KEY, BTN_TOOL_BRUSH, 1);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
val = libinput_event_tablet_tool_get_rotation(tev);
/* artpen has a 90 deg offset cw */
- ck_assert_int_eq(round(val), (expected_angle + 90) % 360);
+ litest_assert_int_eq(round(val), (expected_angle + 90) % 360);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
libinput_event_destroy(event);
litest_dispatch(li);
- ck_assert_int_eq(libinput_next_event_type(li),
+ litest_assert_int_eq(libinput_next_event_type(li),
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
/* we expect all events up to the button event to go from
break;
tablet_event = libinput_event_get_tablet_tool_event(event);
- ck_assert_notnull(tablet_event);
+ litest_assert_notnull(tablet_event);
x = libinput_event_tablet_tool_get_x(tablet_event);
y = libinput_event_tablet_tool_get_y(tablet_event);
- ck_assert(x > last_x);
- ck_assert(y < last_y);
+ litest_assert(x > last_x);
+ litest_assert(y < last_y);
last_x = x;
last_y = y;
libinput_event_destroy(event);
}
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
libinput_event_destroy(event);
}
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
val = libinput_event_tablet_tool_get_x(tablet_event);
- ck_assert_double_lt(val, 0.0);
+ litest_assert_double_lt(val, 0.0);
val = libinput_event_tablet_tool_get_y(tablet_event);
- ck_assert_double_gt(val, 0.0);
+ litest_assert_double_gt(val, 0.0);
val = libinput_event_tablet_tool_get_x_transformed(tablet_event, 100);
- ck_assert_double_lt(val, 0.0);
+ litest_assert_double_lt(val, 0.0);
libinput_event_destroy(event);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
val = libinput_event_tablet_tool_get_x(tablet_event);
- ck_assert_double_gt(val, 0.0);
+ litest_assert_double_gt(val, 0.0);
val = libinput_event_tablet_tool_get_y(tablet_event);
- ck_assert_double_lt(val, 0.0);
+ litest_assert_double_lt(val, 0.0);
val = libinput_event_tablet_tool_get_y_transformed(tablet_event, 100);
- ck_assert_double_lt(val, 0.0);
+ litest_assert_double_lt(val, 0.0);
libinput_event_destroy(event);
}
litest_drain_events(li);
absinfo = libevdev_get_abs_info(dev->evdev, ABS_DISTANCE);
- ck_assert_notnull(absinfo);
+ litest_assert_notnull(absinfo);
litest_event(dev, EV_ABS, ABS_DISTANCE, absinfo->maximum);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert(libinput_tablet_tool_is_unique(tool));
+ litest_assert(libinput_tablet_tool_is_unique(tool));
libinput_event_destroy(event);
}
END_TEST
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 1000);
+ litest_assert_int_eq(libinput_tablet_tool_get_serial(tool), 1000);
libinput_event_destroy(event);
}
END_TEST
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_int_eq(libinput_device_get_id_vendor(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_get_id_vendor(dev->libinput_device),
VENDOR_ID_WACOM);
switch (libinput_device_get_id_product(dev->libinput_device)) {
litest_abort_msg("Invalid button code");
}
- ck_assert(tool_id == libinput_tablet_tool_get_tool_id(tool));
+ litest_assert(tool_id == libinput_tablet_tool_get_tool_id(tool));
libinput_event_destroy(event);
}
END_TEST
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 2000);
+ litest_assert_int_eq(libinput_tablet_tool_get_serial(tool), 2000);
libinput_event_destroy(event);
}
END_TEST
tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 1000);
+ litest_assert_int_eq(libinput_tablet_tool_get_serial(tool), 1000);
}
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_notnull(tool);
- ck_assert(tool == libinput_tablet_tool_ref(tool));
- ck_assert(tool == libinput_tablet_tool_unref(tool));
+ litest_assert_notnull(tool);
+ litest_assert(tool == libinput_tablet_tool_ref(tool));
+ litest_assert(tool == libinput_tablet_tool_unref(tool));
libinput_event_destroy(event);
- ck_assert(libinput_tablet_tool_unref(tool) == NULL);
+ litest_assert(libinput_tablet_tool_unref(tool) == NULL);
}
END_TEST
tablet_event = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tablet_event);
- ck_assert_notnull(tool);
+ litest_assert_notnull(tool);
- ck_assert(libinput_tablet_tool_get_user_data(tool) == NULL);
+ litest_assert(libinput_tablet_tool_get_user_data(tool) == NULL);
libinput_tablet_tool_set_user_data(tool, userdata);
- ck_assert(libinput_tablet_tool_get_user_data(tool) == userdata);
+ litest_assert(libinput_tablet_tool_get_user_data(tool) == userdata);
libinput_tablet_tool_set_user_data(tool, NULL);
- ck_assert(libinput_tablet_tool_get_user_data(tool) == NULL);
+ litest_assert(libinput_tablet_tool_get_user_data(tool) == NULL);
libinput_event_destroy(event);
}
}
/* We should get the same object for both devices */
- ck_assert_notnull(tool[0]);
- ck_assert_notnull(tool[1]);
- ck_assert_ptr_eq(tool[0], tool[1]);
+ litest_assert_notnull(tool[0]);
+ litest_assert_notnull(tool[1]);
+ litest_assert_ptr_eq(tool[0], tool[1]);
litest_delete_device(dev[0]);
litest_delete_device(dev[1]);
}
/* We should get different tool objects for each device */
- ck_assert_notnull(tool[0]);
- ck_assert_notnull(tool[1]);
- ck_assert_ptr_ne(tool[0], tool[1]);
+ litest_assert_notnull(tool[0]);
+ litest_assert_notnull(tool[1]);
+ litest_assert_ptr_ne(tool[0], tool[1]);
litest_delete_device(dev[0]);
litest_delete_device(dev[1]);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
serial = libinput_tablet_tool_get_serial(tool);
- ck_assert_int_eq(serial, 0);
+ litest_assert_int_eq(serial, 0);
libinput_event_destroy(event);
for (int x = 4500; x < 8000; x += 1000) {
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
serial = libinput_tablet_tool_get_serial(tool);
- ck_assert_int_eq(serial, 0);
+ litest_assert_int_eq(serial, 0);
libinput_event_destroy(event);
for (int x = 4500; x < 8000; x += 500) {
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
serial = libinput_tablet_tool_get_serial(tool);
- ck_assert_int_eq(serial, 0);
+ litest_assert_int_eq(serial, 0);
libinput_event_destroy(event);
event = libinput_get_event(li);
} while (event != NULL);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
serial = libinput_tablet_tool_get_serial(tool);
- ck_assert_int_eq(serial, 0);
+ litest_assert_int_eq(serial, 0);
libinput_event_destroy(event);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_TABLET_TOOL));
}
END_TEST
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(t);
- ck_assert(libinput_tablet_tool_has_pressure(tool));
- ck_assert(libinput_tablet_tool_has_distance(tool));
- ck_assert(!libinput_tablet_tool_has_tilt(tool));
+ litest_assert(libinput_tablet_tool_has_pressure(tool));
+ litest_assert(libinput_tablet_tool_has_distance(tool));
+ litest_assert(!libinput_tablet_tool_has_tilt(tool));
libinput_event_destroy(event);
litest_assert_empty_queue(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(t);
- ck_assert(libinput_tablet_tool_has_pressure(tool));
- ck_assert(libinput_tablet_tool_has_distance(tool));
- ck_assert(libinput_tablet_tool_has_tilt(tool));
+ litest_assert(libinput_tablet_tool_has_pressure(tool));
+ litest_assert(libinput_tablet_tool_has_distance(tool));
+ litest_assert(libinput_tablet_tool_has_tilt(tool));
libinput_event_destroy(event);
litest_assert_empty_queue(li);
type = libinput_tablet_tool_get_type(tool);
}
- ck_assert_int_eq(type, tt->type);
+ litest_assert_int_eq(type, tt->type);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_int_eq(serial,
+ litest_assert_int_eq(serial,
libinput_tablet_tool_get_serial(tool));
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev), tool);
+ 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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
- ck_assert_ptr_ne(libinput_event_tablet_tool_get_tool(tev), tool);
+ litest_assert_ptr_ne(libinput_event_tablet_tool_get_tool(tev), tool);
libinput_tablet_tool_unref(tool);
tool = libinput_event_tablet_tool_get_tool(tev);
libinput_tablet_tool_ref(tool);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
+ 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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
+ 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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(tev),
LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
+ 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_AXIS);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
+ 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);
- ck_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
+ litest_assert_ptr_eq(libinput_event_tablet_tool_get_tool(tev),
tool);
libinput_event_destroy(event);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
+ litest_assert_notnull(tool);
libinput_tablet_tool_ref(tool);
libinput_event_destroy(event);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_notnull(tool);
+ litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_MOUSE);
libinput_event_destroy(event);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
+ litest_assert_notnull(tool);
libinput_tablet_tool_ref(tool);
libinput_event_destroy(event);
bool has_button = libevdev_has_event_code(dev->evdev,
EV_KEY,
code);
- ck_assert_int_eq(!!has_button,
+ litest_assert_int_eq(!!has_button,
!!libinput_tablet_tool_has_button(tool, code));
if (!has_button)
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
+ litest_assert_notnull(tool);
libinput_tablet_tool_ref(tool);
libinput_event_destroy(event);
- ck_assert(libinput_tablet_tool_has_wheel(tool));
+ litest_assert(libinput_tablet_tool_has_wheel(tool));
for (i = 0; i < 3; i++) {
litest_event(dev, EV_REL, REL_WHEEL, -1);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(libinput_event_tablet_tool_wheel_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_wheel_has_changed(tev));
val = libinput_event_tablet_tool_get_wheel_delta(tev);
- ck_assert_int_eq(val, 15);
+ litest_assert_int_eq(val, 15);
val = libinput_event_tablet_tool_get_wheel_delta_discrete(tev);
- ck_assert_int_eq(val, 1);
+ litest_assert_int_eq(val, 1);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(!libinput_event_tablet_tool_wheel_has_changed(tev));
+ litest_assert(!libinput_event_tablet_tool_wheel_has_changed(tev));
val = libinput_event_tablet_tool_get_wheel_delta(tev);
- ck_assert_int_eq(val, 0);
+ litest_assert_int_eq(val, 0);
val = libinput_event_tablet_tool_get_wheel_delta_discrete(tev);
- ck_assert_int_eq(val, 0);
+ litest_assert_int_eq(val, 0);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_notnull(tool);
+ litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH);
- ck_assert(libinput_tablet_tool_has_slider(tool));
+ litest_assert(libinput_tablet_tool_has_slider(tool));
libinput_event_destroy(event);
}
litest_drain_events(li);
abs = libevdev_get_abs_info(dev->evdev, ABS_WHEEL);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
litest_event(dev, EV_KEY, BTN_TOOL_AIRBRUSH, 1);
litest_event(dev, EV_MSC, MSC_SERIAL, 1000);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(libinput_event_tablet_tool_slider_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_slider_has_changed(tev));
val = libinput_event_tablet_tool_get_slider_position(tev);
- ck_assert_double_eq(val, expected);
- ck_assert_double_ge(val, -1.0);
- ck_assert_double_le(val, 1.0);
+ litest_assert_double_eq(val, expected);
+ litest_assert_double_ge(val, -1.0);
+ litest_assert_double_le(val, 1.0);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
}
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert_notnull(tool);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_notnull(tool);
+ litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_PEN);
- ck_assert(libinput_tablet_tool_has_rotation(tool));
+ litest_assert(libinput_tablet_tool_has_rotation(tool));
libinput_event_destroy(event);
}
litest_drain_events(li);
abs = libevdev_get_abs_info(dev->evdev, ABS_Z);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
scale = absinfo_range(abs)/360.0;
litest_event(dev, EV_KEY, BTN_TOOL_BRUSH, 1);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_rotation_has_changed(tev));
val = libinput_event_tablet_tool_get_rotation(tev);
/* artpen has a 90 deg offset cw */
- ck_assert_int_eq(round(val), (angle + 90) % 360);
+ litest_assert_int_eq(round(val), (angle + 90) % 360);
libinput_event_destroy(event);
litest_assert_empty_queue(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
time_usec = libinput_event_tablet_tool_get_time_usec(tev);
- ck_assert_int_eq(libinput_event_tablet_tool_get_time(tev),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_time(tev),
(uint32_t) (time_usec / 1000));
libinput_event_destroy(event);
}
pressure = libinput_event_tablet_tool_get_pressure(tev);
distance = libinput_event_tablet_tool_get_distance(tev);
- ck_assert_double_eq(pressure, 0.001);
- ck_assert_double_eq(distance, 0.0);
+ litest_assert_double_eq(pressure, 0.001);
+ litest_assert_double_eq(distance, 0.0);
libinput_event_destroy(event);
/* We have pressure and we're above the tip threshold now */
pressure = libinput_event_tablet_tool_get_pressure(tev);
distance = libinput_event_tablet_tool_get_distance(tev);
- ck_assert_double_gt(pressure, 0.0);
- ck_assert_double_eq(distance, 0.0);
+ litest_assert_double_gt(pressure, 0.0);
+ litest_assert_double_eq(distance, 0.0);
libinput_event_destroy(event);
}
has_calibration = device_has_calibration(dev);
rc = libinput_device_config_calibration_has_matrix(d);
- ck_assert_int_eq(rc, has_calibration);
+ litest_assert_int_eq(rc, has_calibration);
rc = libinput_device_config_calibration_get_matrix(d, calibration);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_calibration_get_default_matrix(d,
calibration);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
status = libinput_device_config_calibration_set_matrix(d,
calibration);
if (has_calibration)
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
else
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
libinput_event_destroy(event);
litest_drain_events(li);
- ck_assert_double_gt(dx, mdx * 2 - 1);
- ck_assert_double_lt(dx, mdx * 2 + 1);
- ck_assert_double_gt(dy, mdy * 2 - 1);
- ck_assert_double_lt(dy, mdy * 2 + 1);
+ litest_assert_double_gt(dx, mdx * 2 - 1);
+ litest_assert_double_lt(dx, mdx * 2 + 1);
+ litest_assert_double_gt(dy, mdy * 2 - 1);
+ litest_assert_double_lt(dy, mdy * 2 + 1);
}
END_TEST
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
y = libinput_event_tablet_tool_get_y_transformed(tablet_event, 100);
libinput_event_destroy(event);
- ck_assert_double_gt(x, 49.0);
- ck_assert_double_lt(x, 51.0);
- ck_assert_double_gt(y, 99.0);
- ck_assert_double_lt(y, 100.0);
+ litest_assert_double_gt(x, 49.0);
+ litest_assert_double_lt(x, 51.0);
+ litest_assert_double_gt(y, 99.0);
+ litest_assert_double_lt(y, 100.0);
litest_tablet_proximity_out(dev);
litest_dispatch(li);
calibration[4] = 0.5;
status = libinput_device_config_calibration_set_matrix(d,
calibration);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 100, 100, axes);
litest_dispatch(li);
y = libinput_event_tablet_tool_get_y_transformed(tablet_event, 100);
libinput_event_destroy(event);
- ck_assert(x > 99.0);
- ck_assert(x < 100.0);
- ck_assert(y > 49.0);
- ck_assert(y < 51.0);
+ litest_assert(x > 99.0);
+ litest_assert(x < 100.0);
+ litest_assert(y > 49.0);
+ litest_assert(y < 51.0);
litest_tablet_proximity_out(dev);
}
struct libinput_event *event = libinput_get_event(li);
struct libinput_event_tablet_tool *tev = litest_is_tablet_event(event, type);
double pressure = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq_tol(pressure, expected_pressure, 0.01);
+ litest_assert_double_eq_epsilon(pressure, expected_pressure, 0.01);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_ge(p, 0.0);
- ck_assert_double_le(p, 1.0);
+ litest_assert_double_ge(p, 0.0);
+ litest_assert_double_le(p, 1.0);
libinput_event_destroy(event);
}
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
struct libinput_tablet_tool *tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_minimum(tool), 0.0);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_maximum(tool), 1.0);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_minimum(tool), 0.0);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_maximum(tool), 1.0);
+ litest_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
+ litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_minimum(tool), 0.0);
+ litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_maximum(tool), 1.0);
+ 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);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.0),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.0),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.2, 0.5),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.2, 0.5),
LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, -0.1, 1.0),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, -0.1, 1.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.0),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 1.0, 1.0),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 1.0, 1.0),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.1),
+ litest_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 1.1),
LIBINPUT_CONFIG_STATUS_INVALID);
/* The last successful one */
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_minimum(tool), 0.2);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_maximum(tool), 0.5);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_minimum(tool), 0.0);
- ck_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_default_maximum(tool), 1.0);
+ litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_minimum(tool), 0.2);
+ litest_assert_double_eq(libinput_tablet_tool_config_pressure_range_get_maximum(tool), 0.5);
+ 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);
libinput_event_destroy(event);
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_gt(p, 0.0);
+ litest_assert_double_gt(p, 0.0);
old_pressure = p;
- ck_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 1.0),
+ 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),
LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq(p, old_pressure);
+ litest_assert_double_eq(p, old_pressure);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq(p, 0.00);
+ litest_assert_double_eq(p, 0.00);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_gt(p, 0.15);
- ck_assert_double_le(p, 0.16);
+ litest_assert_double_gt(p, 0.15);
+ litest_assert_double_le(p, 0.16);
libinput_event_destroy(event);
for (int pos = 71; pos < 80; pos++) {
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_ge(p, 0.15);
- ck_assert_double_le(p, 0.16);
+ litest_assert_double_ge(p, 0.15);
+ litest_assert_double_le(p, 0.16);
libinput_event_destroy(event);
}
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_gt(p, 0.0);
+ litest_assert_double_gt(p, 0.0);
old_pressure = p;
- ck_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.0, 0.6),
+ 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);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq(p, old_pressure);
+ litest_assert_double_eq(p, old_pressure);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_ge(p, 0.15);
- ck_assert_double_le(p, 0.16);
- ck_assert_double_gt(p, old_pressure);
+ litest_assert_double_ge(p, 0.15);
+ litest_assert_double_le(p, 0.16);
+ litest_assert_double_gt(p, old_pressure);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_ge(p, 0.82);
- ck_assert_double_le(p, 0.84);
+ litest_assert_double_ge(p, 0.82);
+ litest_assert_double_le(p, 0.84);
libinput_event_destroy(event);
}
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq(p, 1.0);
+ litest_assert_double_eq(p, 1.0);
libinput_event_destroy(event);
}
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tool = libinput_event_tablet_tool_get_tool(tev);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_gt(p, 0.0);
+ litest_assert_double_gt(p, 0.0);
old_pressure = p;
- ck_assert(libinput_tablet_tool_config_pressure_range_is_available(tool));
- ck_assert_int_eq(libinput_tablet_tool_config_pressure_range_set(tool, 0.4, 0.6),
+ 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),
LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_event_destroy(event);
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
p = libinput_event_tablet_tool_get_pressure(tev);
- ck_assert_double_eq(p, old_pressure);
+ litest_assert_double_eq(p, old_pressure);
libinput_event_destroy(event);
}
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_TIP);
p = libinput_event_tablet_tool_get_pressure(tev);
if (pressure <= 40) {
- ck_assert_double_eq(p, 0.0);
+ litest_assert_double_eq(p, 0.0);
} else if (pressure >= 60) {
- ck_assert_double_eq(p, 1.0);
+ litest_assert_double_eq(p, 1.0);
} else {
- ck_assert_double_ge(p, (pressure - 1 - 40)/20.0);
- ck_assert_double_le(p, (pressure - 40)/20.0);
+ litest_assert_double_ge(p, (pressure - 1 - 40)/20.0);
+ litest_assert_double_le(p, (pressure - 40)/20.0);
}
libinput_event_destroy(event);
}
litest_dispatch(li);
assert_pressure(li, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, 0.60);
- ck_assert_int_eq(warning_triggered, 1);
+ litest_assert_int_eq(warning_triggered, 1);
litest_restore_log_handler(li);
}
END_TEST
event = libinput_get_event(li);
tev = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dist = libinput_event_tablet_tool_get_distance(tev);
- ck_assert_double_ge(dist, 0.0);
- ck_assert_double_le(dist, 1.0);
+ litest_assert_double_ge(dist, 0.0);
+ litest_assert_double_le(dist, 1.0);
libinput_event_destroy(event);
}
}
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert(libinput_tablet_tool_has_tilt(tool));
+ litest_assert(libinput_tablet_tool_has_tilt(tool));
libinput_event_destroy(event);
}
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(tev);
- ck_assert(!libinput_tablet_tool_has_tilt(tool));
+ litest_assert(!libinput_tablet_tool_has_tilt(tool));
libinput_event_destroy(event);
}
/* 90% of the actual axis but mapped into a [-64, 64] tilt range, so
* we expect 51 degrees ± rounding errors */
tx = libinput_event_tablet_tool_get_tilt_x(tev);
- ck_assert_double_le(tx, -50);
- ck_assert_double_ge(tx, -52);
+ litest_assert_double_le(tx, -50);
+ litest_assert_double_ge(tx, -52);
ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_ge(ty, -65);
- ck_assert_double_lt(ty, -63);
+ litest_assert_double_ge(ty, -65);
+ litest_assert_double_lt(ty, -63);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
tx = libinput_event_tablet_tool_get_tilt_x(tev);
- ck_assert_double_ge(tx, expected_tx - 2);
- ck_assert_double_le(tx, expected_tx + 2);
+ litest_assert_double_ge(tx, expected_tx - 2);
+ litest_assert_double_le(tx, expected_tx + 2);
ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_ge(ty, -65);
- ck_assert_double_lt(ty, -63);
+ litest_assert_double_ge(ty, -65);
+ litest_assert_double_lt(ty, -63);
libinput_event_destroy(event);
}
/* the last event must reach the max */
- ck_assert_double_ge(tx, 63.0);
- ck_assert_double_le(tx, 64.0);
+ litest_assert_double_ge(tx, 63.0);
+ litest_assert_double_le(tx, 64.0);
}
END_TEST
/* 90% of the actual axis but mapped into a [-64, 64] tilt range, so
* we expect 50 degrees ± rounding errors */
ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_le(ty, -50);
- ck_assert_double_ge(ty, -52);
+ litest_assert_double_le(ty, -50);
+ litest_assert_double_ge(ty, -52);
tx = libinput_event_tablet_tool_get_tilt_x(tev);
- ck_assert_double_ge(tx, -65);
- ck_assert_double_lt(tx, -63);
+ litest_assert_double_ge(tx, -65);
+ litest_assert_double_lt(tx, -63);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_ge(ty, expected_ty - 2);
- ck_assert_double_le(ty, expected_ty + 2);
+ litest_assert_double_ge(ty, expected_ty - 2);
+ litest_assert_double_le(ty, expected_ty + 2);
tx = libinput_event_tablet_tool_get_tilt_x(tev);
- ck_assert_double_ge(tx, -65);
- ck_assert_double_lt(tx, -63);
+ litest_assert_double_ge(tx, -65);
+ litest_assert_double_lt(tx, -63);
libinput_event_destroy(event);
}
/* the last event must reach the max */
- ck_assert_double_ge(ty, 63.0);
- ck_assert_double_le(tx, 64.0);
+ litest_assert_double_ge(ty, 63.0);
+ litest_assert_double_le(tx, 64.0);
}
END_TEST
double tx = libinput_event_tablet_tool_get_tilt_x(tev);
double ty = libinput_event_tablet_tool_get_tilt_y(tev);
- ck_assert_double_eq(tx, expected);
+ litest_assert_double_eq(tx, expected);
if (is_adjusted) {
- ck_assert_double_ge(ty, expected - 1);
- ck_assert_double_lt(ty, expected);
+ litest_assert_double_ge(ty, expected - 1);
+ litest_assert_double_lt(ty, expected);
} else {
- ck_assert_double_eq(ty, expected);
+ litest_assert_double_eq(ty, expected);
}
libinput_event_destroy(event);
enum libinput_config_status status;
uint32_t profiles;
- ck_assert(libinput_device_config_accel_is_available(device));
+ litest_assert(libinput_device_config_accel_is_available(device));
profile = libinput_device_config_accel_get_default_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
profiles = libinput_device_config_accel_get_profiles(device);
- ck_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE, 0);
- ck_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT, 0);
+ litest_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE, 0);
+ litest_assert_int_eq(profiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT, 0);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
status = libinput_device_config_accel_set_profile(device,
LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
profile = libinput_device_config_accel_get_profile(device);
- ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
+ litest_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_NONE);
}
END_TEST
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
}
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx > 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx > 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
/* flush the motion history */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx < 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx < 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
/* flush the motion history */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy > 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy < 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy < 0.0);
libinput_event_destroy(event);
}
END_TEST
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- ck_assert(libinput_event_tablet_tool_x_has_changed(tev));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tev));
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
/* normal motion */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx > 0.0);
- ck_assert(dy > 0.0);
+ litest_assert(dx > 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
/* tip up */
event = libinput_get_event(li);
tev = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- ck_assert(libinput_event_tablet_tool_x_has_changed(tev));
- ck_assert(libinput_event_tablet_tool_y_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(tev));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(tev));
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
}
END_TEST
status = libinput_device_config_calibration_set_matrix(
dev->libinput_device,
calibration);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_tablet_proximity_in(dev, 10, 10, axes);
litest_drain_events(li);
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx < 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx < 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
/* work around axis smoothing */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx > 0.0);
- ck_assert(dy == 0.0);
+ litest_assert(dx > 0.0);
+ litest_assert(dy == 0.0);
libinput_event_destroy(event);
/* work around axis smoothing */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy < 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy < 0.0);
libinput_event_destroy(event);
/* work around axis smoothing */
LIBINPUT_EVENT_TABLET_TOOL_AXIS);
dx = libinput_event_tablet_tool_get_dx(tev);
dy = libinput_event_tablet_tool_get_dy(tev);
- ck_assert(dx == 0.0);
- ck_assert(dy > 0.0);
+ litest_assert(dx == 0.0);
+ litest_assert(dy > 0.0);
libinput_event_destroy(event);
}
END_TEST
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 30, 30);
litest_touch_move_to(dev, 0, 30, 30, 80, 80, 10);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
p = litest_is_motion_event(event);
litest_dispatch(li);
tablet_enabled = libinput_device_config_left_handed_get(tablet_dev);
touch_enabled = libinput_device_config_left_handed_get(touch_dev);
- ck_assert_int_eq(tablet_enabled, tablet_from);
- ck_assert_int_eq(touch_enabled, touch_from);
+ litest_assert_int_eq(tablet_enabled, tablet_from);
+ litest_assert_int_eq(touch_enabled, touch_from);
libinput_device_config_left_handed_set(tablet_dev, tablet_to);
libinput_device_config_left_handed_set(touch_dev, touch_to);
litest_dispatch(li);
tablet_enabled = libinput_device_config_left_handed_get(tablet_dev);
touch_enabled = libinput_device_config_left_handed_get(touch_dev);
- ck_assert_int_eq(tablet_enabled, tablet_to);
- ck_assert_int_eq(touch_enabled, touch_to);
+ litest_assert_int_eq(tablet_enabled, tablet_to);
+ litest_assert_int_eq(touch_enabled, touch_to);
out:
litest_delete_device(finger);
ex = libinput_event_tablet_tool_get_x(tev);
ey = libinput_event_tablet_tool_get_y(tev);
- ck_assert_double_eq(ex, p->x);
- ck_assert_double_eq(ey, p->y);
+ litest_assert_double_eq(ex, p->x);
+ litest_assert_double_eq(ey, p->y);
libinput_event_destroy(event);
}
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(t);
- ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
+ litest_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_TOTEM);
libinput_event_destroy(event);
}
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
tool = libinput_event_tablet_tool_get_tool(t);
- ck_assert(libinput_tablet_tool_has_rotation(tool));
- ck_assert(libinput_tablet_tool_has_size(tool));
- ck_assert(libinput_tablet_tool_has_button(tool, BTN_0));
+ litest_assert(libinput_tablet_tool_has_rotation(tool));
+ litest_assert(libinput_tablet_tool_has_size(tool));
+ litest_assert(libinput_tablet_tool_has_button(tool, BTN_0));
libinput_event_destroy(event);
}
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_int_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);
- ck_assert_double_gt(x, w/2 - 1);
- ck_assert_double_lt(x, w/2 + 1);
- ck_assert_double_gt(y, h/2 - 1);
- ck_assert_double_lt(y, h/2 + 1);
+ litest_assert_double_gt(x, w/2 - 1);
+ litest_assert_double_lt(x, w/2 + 1);
+ litest_assert_double_gt(y, h/2 - 1);
+ litest_assert_double_lt(y, h/2 + 1);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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);
- ck_assert_double_gt(x, w/2 - 1);
- ck_assert_double_lt(x, w/2 + 1);
- ck_assert_double_gt(y, h/2 - 1);
- ck_assert_double_lt(y, h/2 + 1);
+ litest_assert_double_gt(x, w/2 - 1);
+ litest_assert_double_lt(x, w/2 + 1);
+ litest_assert_double_gt(y, h/2 - 1);
+ litest_assert_double_lt(y, h/2 + 1);
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event,
LIBINPUT_EVENT_TABLET_TOOL_TIP);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_int_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_AXIS);
- ck_assert(libinput_event_tablet_tool_x_has_changed(t));
- ck_assert(libinput_event_tablet_tool_y_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_x_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_y_has_changed(t));
current_x = libinput_event_tablet_tool_get_x(t);
current_y = libinput_event_tablet_tool_get_y(t);
if (i != 0) {
- ck_assert_double_gt(current_x, old_x);
- ck_assert_double_lt(current_y, old_y);
+ litest_assert_double_gt(current_x, old_x);
+ litest_assert_double_lt(current_y, old_y);
}
old_x = current_x;
old_y = current_y;
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(!libinput_event_tablet_tool_x_has_changed(t));
- ck_assert(!libinput_event_tablet_tool_y_has_changed(t));
- ck_assert(libinput_event_tablet_tool_rotation_has_changed(t));
+ litest_assert(!libinput_event_tablet_tool_x_has_changed(t));
+ litest_assert(!libinput_event_tablet_tool_y_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_rotation_has_changed(t));
r = libinput_event_tablet_tool_get_rotation(t);
- ck_assert_double_lt(r, old_r);
+ litest_assert_double_lt(r, old_r);
old_r = r;
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_AXIS);
- ck_assert(!libinput_event_tablet_tool_x_has_changed(t));
- ck_assert(!libinput_event_tablet_tool_y_has_changed(t));
- ck_assert(libinput_event_tablet_tool_rotation_has_changed(t));
+ litest_assert(!libinput_event_tablet_tool_x_has_changed(t));
+ litest_assert(!libinput_event_tablet_tool_y_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_rotation_has_changed(t));
r = libinput_event_tablet_tool_get_rotation(t);
- ck_assert_double_gt(r, old_r);
+ litest_assert_double_gt(r, old_r);
old_r = r;
libinput_event_destroy(event);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY);
- ck_assert(libinput_event_tablet_tool_size_major_has_changed(t));
- ck_assert(libinput_event_tablet_tool_size_minor_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_size_major_has_changed(t));
+ litest_assert(libinput_event_tablet_tool_size_minor_has_changed(t));
smaj = libinput_event_tablet_tool_get_size_major(t);
smin = libinput_event_tablet_tool_get_size_minor(t);
libinput_event_destroy(event);
- ck_assert_double_eq(smaj, 71.8);
- ck_assert_double_eq(smin, 71.8);
+ litest_assert_double_eq(smaj, 71.8);
+ litest_assert_double_eq(smin, 71.8);
litest_drain_events(li);
}
litest_dispatch(li);
event = libinput_get_event(li);
t = litest_is_tablet_event(event, LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(t), BTN_0);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(t), BTN_0);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
LIBINPUT_BUTTON_STATE_PRESSED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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_BUTTON);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button(t), BTN_0);
- ck_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button(t), BTN_0);
+ litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(t),
LIBINPUT_BUTTON_STATE_RELEASED);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_proximity_state(t),
+ litest_assert_int_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);
- ck_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
+ litest_assert_int_eq(libinput_event_tablet_tool_get_tip_state(t),
LIBINPUT_TABLET_TOOL_TIP_DOWN);
libinput_event_destroy(event);
have_frame_event++;
libinput_event_destroy(event);
}
- ck_assert_int_eq(have_frame_event, 1);
+ litest_assert_int_eq(have_frame_event, 1);
litest_touch_down(dev, 1, 10, 10);
litest_dispatch(li);
have_frame_event++;
libinput_event_destroy(event);
}
- ck_assert_int_eq(have_frame_event, 2);
+ litest_assert_int_eq(have_frame_event, 2);
}
END_TEST
libinput_event_destroy(ev);
}
- ck_assert(tested);
+ litest_assert(tested);
litest_delete_device(dev);
}
ev = libinput_get_event(li);
tev = litest_is_touch_event(ev, type);
slot = libinput_event_touch_get_slot(tev);
- ck_assert_int_eq(slot, slot);
+ litest_assert_int_eq(slot, slot);
slot = libinput_event_touch_get_seat_slot(tev);
- ck_assert_int_eq(slot, seat_slot);
+ litest_assert_int_eq(slot, seat_slot);
libinput_event_destroy(ev);
ev = libinput_get_event(li);
litest_dispatch(libinput);
}
- ck_assert_notnull(ev);
- ck_assert_int_gt(slot_count, 0);
+ litest_assert_notnull(ev);
+ litest_assert_int_gt(slot_count, 0);
litest_dispatch(libinput);
do {
type = libinput_event_get_type(ev);
- ck_assert_int_ne(type, LIBINPUT_EVENT_TOUCH_DOWN);
+ litest_assert_int_ne(type, LIBINPUT_EVENT_TOUCH_DOWN);
if (type == LIBINPUT_EVENT_TOUCH_UP)
slot_count--;
litest_dispatch(libinput);
} while ((ev = libinput_get_event(libinput)));
- ck_assert_int_eq(slot_count, 0);
+ litest_assert_int_eq(slot_count, 0);
litest_delete_device(dev);
}
while ((ev = libinput_get_event(libinput))) {
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_TOUCH_DOWN:
- ck_assert(!got_down);
+ litest_assert(!got_down);
got_down = true;
break;
case LIBINPUT_EVENT_TOUCH_UP:
- ck_assert(got_down);
- ck_assert(!got_up);
+ litest_assert(got_down);
+ litest_assert(!got_up);
got_up = true;
break;
default:
litest_dispatch(libinput);
}
- ck_assert(got_down);
- ck_assert(got_up);
+ litest_assert(got_down);
+ litest_assert(got_up);
}
END_TEST
x = libinput_event_touch_get_x_transformed(tev, width);
y = libinput_event_touch_get_y_transformed(tev, height);
- ck_assert_int_eq(round(x), round(width * matrix[0]));
- ck_assert_int_eq(round(y), round(height * matrix[4]));
+ litest_assert_int_eq(round(x), round(width * matrix[0]));
+ litest_assert_int_eq(round(y), round(height * matrix[4]));
libinput_event_destroy(ev);
litest_drain_events(li);
y = libinput_event_touch_get_y_transformed(tev, height);
/* sigh. rounding errors */
- ck_assert_int_ge(round(x), width + round(width * matrix[2]) - 1);
- ck_assert_int_ge(round(y), height + round(height * matrix[5]) - 1);
- ck_assert_int_le(round(x), width + round(width * matrix[2]) + 1);
- ck_assert_int_le(round(y), height + round(height * matrix[5]) + 1);
+ litest_assert_int_ge(round(x), width + round(width * matrix[2]) - 1);
+ litest_assert_int_ge(round(y), height + round(height * matrix[5]) - 1);
+ litest_assert_int_le(round(x), width + round(width * matrix[2]) + 1);
+ litest_assert_int_le(round(y), height + round(height * matrix[5]) + 1);
libinput_event_destroy(ev);
litest_drain_events(li);
int rc;
rc = libinput_device_config_calibration_has_matrix(dev->libinput_device);
- ck_assert_int_eq(rc, 1);
+ litest_assert_int_eq(rc, 1);
rc = libinput_device_config_calibration_get_matrix(dev->libinput_device,
matrix);
- ck_assert_int_eq(rc, 1);
-
- ck_assert_double_eq(matrix[0], 1.2);
- ck_assert_double_eq(matrix[1], 3.4);
- ck_assert_double_eq(matrix[2], 5.6);
- ck_assert_double_eq(matrix[3], 7.8);
- ck_assert_double_eq(matrix[4], 9.10);
- ck_assert_double_eq(matrix[5], 11.12);
+ litest_assert_int_eq(rc, 1);
+
+ litest_assert_double_eq(matrix[0], 1.2);
+ litest_assert_double_eq(matrix[1], 3.4);
+ litest_assert_double_eq(matrix[2], 5.6);
+ litest_assert_double_eq(matrix[3], 7.8);
+ litest_assert_double_eq(matrix[4], 9.10);
+ litest_assert_double_eq(matrix[5], 11.12);
}
END_TEST
int rc;
rc = libinput_device_config_calibration_has_matrix(dev->libinput_device);
- ck_assert_int_eq(rc, 1);
+ litest_assert_int_eq(rc, 1);
/* 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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_device_config_calibration_get_matrix(dev->libinput_device, matrix);
- ck_assert_int_eq(memcmp(matrix, identity, sizeof(matrix)), 0);
+ litest_assert_int_eq(memcmp(matrix, identity, sizeof(matrix)), 0);
status = libinput_device_config_calibration_set_matrix(dev->libinput_device, nonidentity);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
libinput_device_config_calibration_get_matrix(dev->libinput_device, matrix);
- ck_assert_int_eq(memcmp(matrix, nonidentity, sizeof(matrix)), 0);
+ litest_assert_int_eq(memcmp(matrix, nonidentity, sizeof(matrix)), 0);
}
}
int rc;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
litest_drain_events(li);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
rc = libinput_device_config_calibration_has_matrix(device);
- ck_assert_int_eq(rc, 1);
+ litest_assert_int_eq(rc, 1);
rc = libinput_device_config_calibration_get_matrix(device, matrix);
- ck_assert_int_eq(rc, 1);
+ litest_assert_int_eq(rc, 1);
- ck_assert_double_eq(matrix[0], 1.2);
- ck_assert_double_eq(matrix[1], 3.4);
- ck_assert_double_eq(matrix[2], 5.6);
- ck_assert_double_eq(matrix[3], 7.8);
- ck_assert_double_eq(matrix[4], 9.10);
- ck_assert_double_eq(matrix[5], 11.12);
+ litest_assert_double_eq(matrix[0], 1.2);
+ litest_assert_double_eq(matrix[1], 3.4);
+ litest_assert_double_eq(matrix[2], 5.6);
+ litest_assert_double_eq(matrix[3], 7.8);
+ litest_assert_double_eq(matrix[4], 9.10);
+ litest_assert_double_eq(matrix[5], 11.12);
libinput_device_unref(device);
int rc;
rc = libinput_device_config_left_handed_is_available(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_left_handed_get(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
rc = libinput_device_config_left_handed_get_default(d);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
status = libinput_device_config_left_handed_set(d, 0);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
event = libinput_get_event(li);
device = libinput_event_get_device(event);
- ck_assert(!libinput_device_has_capability(device,
+ litest_assert(!libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_TOUCH));
/* This test may need fixing if we add other fake-mt devices that
* have different capabilities */
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_POINTER));
libinput_event_destroy(event);
litest_wait_for_event(li);
- ck_assert(libinput_device_has_capability(device,
+ litest_assert(libinput_device_has_capability(device,
LIBINPUT_DEVICE_CAP_TOUCH));
}
END_TEST
x = libinput_event_touch_get_x(tev);
y = libinput_event_touch_get_y(tev);
- ck_assert_int_gt(x, oldx);
- ck_assert_int_lt(y, oldy);
+ litest_assert_int_gt(x, oldx);
+ litest_assert_int_lt(y, oldy);
oldx = x;
oldy = y;
ev = libinput_get_event(li);
tev = libinput_event_get_touch_event(ev);
- ck_assert_int_eq(libinput_event_touch_get_slot(tev), 0);
+ litest_assert_int_eq(libinput_event_touch_get_slot(tev), 0);
libinput_event_destroy(ev);
ev = libinput_get_event(li);
ev = libinput_get_event(li);
tev = libinput_event_get_touch_event(ev);
- ck_assert_int_eq(libinput_event_touch_get_slot(tev), 1);
+ litest_assert_int_eq(libinput_event_touch_get_slot(tev), 1);
libinput_event_destroy(ev);
ev = libinput_get_event(li);
t1 = litest_is_touch_event(ev1, 0);
t2 = litest_is_touch_event(ev2, 0);
- ck_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_int_eq(libinput_event_get_type(ev1),
libinput_event_get_type(ev2));
if (libinput_event_get_type(ev1) == LIBINPUT_EVENT_TOUCH_UP ||
event = libinput_get_event(li);
tev = litest_is_touch_event(event, LIBINPUT_EVENT_TOUCH_DOWN);
time_usec = libinput_event_touch_get_time_usec(tev);
- ck_assert_int_eq(libinput_event_touch_get_time(tev),
+ litest_assert_int_eq(libinput_event_touch_get_time(tev),
(uint32_t) (time_usec / 1000));
libinput_event_destroy(event);
}
const char *prop;
int fuzz = 0;
- ck_assert_int_eq(libevdev_get_abs_fuzz(dev->evdev, ABS_X), 0);
- ck_assert_int_eq(libevdev_get_abs_fuzz(dev->evdev, ABS_Y), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(dev->evdev, ABS_X), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(dev->evdev, ABS_Y), 0);
d = libinput_device_get_udev_device(dev->libinput_device);
prop = udev_device_get_property_value(d, "LIBINPUT_FUZZ_00");
- ck_assert_notnull(prop);
- ck_assert(safe_atoi(prop, &fuzz));
- ck_assert_int_eq(fuzz, 10); /* device-specific */
+ litest_assert_notnull(prop);
+ litest_assert(safe_atoi(prop, &fuzz));
+ litest_assert_int_eq(fuzz, 10); /* device-specific */
prop = udev_device_get_property_value(d, "LIBINPUT_FUZZ_01");
- ck_assert_notnull(prop);
- ck_assert(safe_atoi(prop, &fuzz));
- ck_assert_int_eq(fuzz, 12); /* device-specific */
+ litest_assert_notnull(prop);
+ litest_assert(safe_atoi(prop, &fuzz));
+ litest_assert_int_eq(fuzz, 12); /* device-specific */
udev_device_unref(d);
}
t = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
x = libinput_event_touch_get_x(t);
y = libinput_event_touch_get_y(t);
- ck_assert_double_eq(x, 300); /* device has resolution 10 */
- ck_assert_double_eq(y, 300); /* device has resolution 10 */
+ litest_assert_double_eq(x, 300); /* device has resolution 10 */
+ litest_assert_double_eq(y, 300); /* device has resolution 10 */
/* Expect the percentage to be correct too, even if > 100% */
x = libinput_event_touch_get_x_transformed(t, 100);
y = libinput_event_touch_get_y_transformed(t, 100);
- ck_assert_double_eq(round(x), 200);
- ck_assert_double_eq(round(y), 120);
+ litest_assert_double_eq(round(x), 200);
+ litest_assert_double_eq(round(y), 120);
libinput_event_destroy(ev);
}
t = litest_is_touch_event(ev, LIBINPUT_EVENT_TOUCH_DOWN);
x = libinput_event_touch_get_x(t);
y = libinput_event_touch_get_y(t);
- ck_assert_double_eq(x, -150); /* device has resolution 10 */
- ck_assert_double_eq(y, -100); /* device has resolution 10 */
+ litest_assert_double_eq(x, -150); /* device has resolution 10 */
+ litest_assert_double_eq(y, -100); /* device has resolution 10 */
/* Expect the percentage to be correct too, even if > 100% */
x = libinput_event_touch_get_x_transformed(t, 100);
y = libinput_event_touch_get_y_transformed(t, 100);
- ck_assert_double_eq(round(x), -100);
- ck_assert_double_eq(round(y), -40);
+ litest_assert_double_eq(round(x), -100);
+ litest_assert_double_eq(round(y), -40);
libinput_event_destroy(ev);
}
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_touch_get_touch_count(device), 1);
+ litest_assert_int_eq(libinput_device_touch_get_touch_count(device), 1);
}
END_TEST
struct libinput_device *device = dev->libinput_device;
struct libevdev *evdev = dev->evdev;
- ck_assert_int_eq(libinput_device_touch_get_touch_count(device),
+ litest_assert_int_eq(libinput_device_touch_get_touch_count(device),
libevdev_get_num_slots(evdev));
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_touch_get_touch_count(device), 0);
+ litest_assert_int_eq(libinput_device_touch_get_touch_count(device), 0);
}
END_TEST
struct litest_device *dev = litest_current_device();
struct libinput_device *device = dev->libinput_device;
- ck_assert_int_eq(libinput_device_touch_get_touch_count(device), -1);
+ litest_assert_int_eq(libinput_device_touch_get_touch_count(device), -1);
}
END_TEST
/* call this test for apple touchpads */
methods = libinput_device_config_click_get_methods(device);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_default_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
map = libinput_device_config_click_get_default_clickfinger_button_map(device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_click_get_clickfinger_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LRM);
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_click_get_clickfinger_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_CLICKFINGER_MAP_LMR + 1;
status = libinput_device_config_click_set_clickfinger_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
/* call this test for non-apple clickpads */
methods = libinput_device_config_click_get_methods(device);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
method = libinput_device_config_click_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
method = libinput_device_config_click_get_default_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
/* call this test for non-clickpads and non-touchpads */
methods = libinput_device_config_click_get_methods(device);
- ck_assert_int_eq(methods, 0);
+ litest_assert_int_eq(methods, 0);
method = libinput_device_config_click_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
method = libinput_device_config_click_get_default_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
enum libinput_config_status status;
methods = libinput_device_config_click_get_methods(device);
- ck_assert(!(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS));
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert(!(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS));
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
method = libinput_device_config_click_get_method(device);
- ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_click_set_method(device,
LIBINPUT_CONFIG_CLICK_METHOD_NONE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
END_TEST
double dist;
abs = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X);
- ck_assert_notnull(abs);
+ litest_assert_notnull(abs);
if (abs->resolution == 0)
return;
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *p;
event = libinput_get_event(li);
}
- ck_assert(x/nevents < 0);
- ck_assert(y/nevents > 0);
+ litest_assert(x/nevents < 0);
+ litest_assert(y/nevents > 0);
litest_event(dev, EV_KEY, BTN_LEFT, 0);
litest_event(dev, EV_SYN, SYN_REPORT, 0);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *p;
double x, y;
/* Ignore events only containing an unaccelerated motion
* vector. */
if (x != 0 || y != 0) {
- ck_assert(x > 0);
- ck_assert(y == 0);
+ litest_assert(x > 0);
+ litest_assert(y == 0);
}
libinput_event_destroy(event);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *p;
double x, y;
x = libinput_event_pointer_get_dx(p);
y = libinput_event_pointer_get_dy(p);
- ck_assert(x == 0);
- ck_assert(y > 0);
+ litest_assert(x == 0);
+ litest_assert(y > 0);
libinput_event_destroy(event);
litest_dispatch(li);
int enabled;
enabled = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert(!enabled);
+ litest_assert(!enabled);
litest_touch_down(dev, 0, 30, 95);
litest_event(dev, EV_KEY, BTN_LEFT, 1);
/* actual config is delayed, but status is immediate */
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
enabled = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert(enabled);
+ litest_assert(enabled);
status = libinput_device_config_middle_emulation_set_enabled(device,
LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
enabled = libinput_device_config_middle_emulation_get_enabled(device);
- ck_assert(!enabled);
+ litest_assert(!enabled);
}
END_TEST
libevdev_uinput_get_devnode(uinput));
methods = libinput_device_config_click_get_methods(device);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
- ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
+ litest_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
libinput_path_remove_device(device);
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_lt(oldtime, curtime);
+ litest_assert_int_lt(oldtime, curtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_lt(oldtime, curtime);
+ litest_assert_int_lt(oldtime, curtime);
oldtime = curtime;
event = libinput_get_event(li);
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_lt(oldtime, curtime);
+ litest_assert_int_lt(oldtime, curtime);
litest_assert_empty_queue(li);
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
litest_timeout_tapndrag();
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
litest_assert_only_typed_events(li,
LIBINPUT_EVENT_POINTER_MOTION);
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
litest_touch_move_to(dev, 1, 70, 50, 90, 50, 10);
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_RELEASED);
rtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
}
litest_assert_empty_queue(li);
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
litest_touch_move_to(dev, 0, 50, 50, 70, 50, 10);
*/
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_is_button_event(event,
button,
LIBINPUT_BUTTON_STATE_RELEASED);
rtime = libinput_event_pointer_get_time_usec(ptrev);
libinput_event_destroy(ev);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
litest_assert_empty_queue(li);
}
rtime = libinput_event_pointer_get_time_usec(ptrev);
libinput_event_destroy(ev);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
litest_assert_empty_queue(li);
}
rtime = libinput_event_pointer_get_time_usec(ptrev);
libinput_event_destroy(ev);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
}
}
rtime = libinput_event_pointer_get_time_usec(ptrev);
libinput_event_destroy(ev);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
}
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- ck_assert_int_ge(libinput_device_config_tap_get_finger_count(dev->libinput_device), 1);
+ litest_assert_int_ge(libinput_device_config_tap_get_finger_count(dev->libinput_device), 1);
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- ck_assert_int_eq(libinput_device_config_tap_get_finger_count(dev->libinput_device), 0);
- ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_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),
LIBINPUT_CONFIG_TAP_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
+ litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
LIBINPUT_CONFIG_TAP_ENABLED),
LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device,
+ litest_assert_int_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 */
- ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
+ litest_assert_int_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 */
- ck_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_ENABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_default_enabled(dev->libinput_device),
LIBINPUT_CONFIG_TAP_ENABLED);
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
+ litest_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_device_config_tap_set_enabled(dev->libinput_device, -1),
+ litest_assert_int_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);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_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);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
status = libinput_device_config_tap_set_button_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LMR);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_button_map(dev->libinput_device,
LIBINPUT_CONFIG_TAP_MAP_LRM);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
map = LIBINPUT_CONFIG_TAP_MAP_LRM;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = LIBINPUT_CONFIG_TAP_MAP_LMR;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
map = libinput_device_config_tap_get_button_map(dev->libinput_device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
map = LIBINPUT_CONFIG_TAP_MAP_LRM;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
map = LIBINPUT_CONFIG_TAP_MAP_LMR;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
map = LIBINPUT_CONFIG_TAP_MAP_LRM - 1;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
map = LIBINPUT_CONFIG_TAP_MAP_LMR + 1;
status = libinput_device_config_tap_set_button_map(device, map);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_tap_button_map map;
map = libinput_device_config_tap_get_button_map(device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
map = libinput_device_config_tap_get_default_button_map(device);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LRM);
+ litest_assert_int_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);
- ck_assert_int_eq(map, LIBINPUT_CONFIG_TAP_MAP_LMR);
+ litest_assert_int_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 */
- ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_int_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 */
- ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_ENABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_ENABLED);
}
END_TEST
{
struct litest_device *dev = litest_current_device();
- ck_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
+ litest_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, 2),
LIBINPUT_CONFIG_STATUS_INVALID);
- ck_assert_int_eq(libinput_device_config_tap_set_drag_enabled(dev->libinput_device, -1),
+ litest_assert_int_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;
- ck_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
+ litest_assert_int_eq(libinput_device_config_tap_get_default_drag_enabled(dev->libinput_device),
LIBINPUT_CONFIG_DRAG_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_enabled(dev->libinput_device),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_enabled(dev->libinput_device,
LIBINPUT_CONFIG_DRAG_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
litest_enable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
+ litest_assert_int_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);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_DISABLED);
litest_enable_tap_drag(dev->libinput_device);
state = libinput_device_config_tap_get_drag_enabled(dev->libinput_device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DRAG_ENABLED);
}
END_TEST
release_time = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(ev);
- ck_assert_int_gt(release_time, press_time);
+ litest_assert_int_gt(release_time, press_time);
}
END_TEST
LIBINPUT_BUTTON_STATE_PRESSED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_gt(curtime, oldtime);
+ litest_assert_int_gt(curtime, oldtime);
event = libinput_get_event(li);
ptrev = litest_is_button_event(event,
LIBINPUT_BUTTON_STATE_RELEASED);
curtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_ge(curtime, oldtime);
+ litest_assert_int_ge(curtime, oldtime);
oldtime = curtime;
}
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
/* ENABLED is a legacy spelling for ENABLED_TIMEOUT */
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
struct libinput_device *device = dev->libinput_device;
enum libinput_config_status status;
- ck_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
+ litest_assert_int_eq(libinput_device_config_tap_get_drag_lock_enabled(device),
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- ck_assert_int_eq(libinput_device_config_tap_get_default_drag_lock_enabled(device),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_TIMEOUT);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_ENABLED_STICKY);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
LIBINPUT_CONFIG_DRAG_LOCK_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_tap_set_drag_lock_enabled(device,
3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *ptrev;
event = libinput_get_event(li);
while (event) {
- ck_assert_int_ne(libinput_event_get_type(event),
+ litest_assert_int_ne(libinput_event_get_type(event),
LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
event = libinput_get_event(li);
if (!litest_has_2fg_scroll(dev))
return;
- ck_assert_int_eq(libinput_device_get_size(dev->libinput_device, &w, &h), 0);
+ litest_assert_int_eq(libinput_device_get_size(dev->libinput_device, &w, &h), 0);
ratio = w/h;
litest_enable_2fg_scroll(dev);
litest_drain_events(li);
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
- ck_assert(!libinput_event_pointer_has_axis(ptrev,
+ litest_assert(!libinput_event_pointer_has_axis(ptrev,
LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL));
libinput_event_destroy(event);
event = libinput_get_event(li);
expected_nevents--;
} while (event);
- ck_assert_int_eq(expected_nevents, 0);
+ litest_assert_int_eq(expected_nevents, 0);
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
* the same axis value (0.0). */
libinput_event_destroy(event);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
ptrev = litest_is_axis_event(event,
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
on_axis,
LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
- ck_assert(val == (litest_event_pointer_get_value(ptrev, off_axis) == 0.0));
+ litest_assert(val == (litest_event_pointer_get_value(ptrev, off_axis) == 0.0));
break;
}
- ck_assert(has_on_axis);
- ck_assert(!has_off_axis);
+ litest_assert(has_on_axis);
+ litest_assert(!has_off_axis);
libinput_event_destroy(event);
event = libinput_get_event(li);
axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
for (int i = 0; i < 4; i++) {
test_2fg_scroll(dev, delta[i][0], delta[i][1], false);
- ck_assert(is_single_axis_2fg_scroll(dev, axis));
+ litest_assert(is_single_axis_2fg_scroll(dev, axis));
litest_assert_empty_queue(li);
}
axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
for (int i = 0; i < 4; i++) {
test_2fg_scroll(dev, delta[i][1], delta[i][0], false);
- ck_assert(is_single_axis_2fg_scroll(dev, axis));
+ litest_assert(is_single_axis_2fg_scroll(dev, axis));
litest_assert_empty_queue(li);
}
}
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
- ck_assert(is_single_axis_2fg_scroll(dev, axis));
+ litest_assert(is_single_axis_2fg_scroll(dev, axis));
litest_drain_events(li);
msleep(200);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
- ck_assert(is_single_axis_2fg_scroll(dev, axis));
+ litest_assert(is_single_axis_2fg_scroll(dev, axis));
litest_drain_events(li);
/* Move in a clear diagonal direction to ensure the lock releases */
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_POINTER_AXIS);
axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
- ck_assert(!is_single_axis_2fg_scroll(dev, axis));
+ litest_assert(!is_single_axis_2fg_scroll(dev, axis));
litest_touch_up(dev, 1);
litest_touch_up(dev, 0);
last_low_res_event_found = false;
/* We want to move > 5 mm. */
- ck_assert_int_eq(libinput_device_get_size(dev->libinput_device,
+ litest_assert_int_eq(libinput_device_get_size(dev->libinput_device,
&width,
&height), 0);
y_move = 100.0/height * 7;
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *ptrev;
last_low_res_event_found = true;
}
- ck_assert(axisval >= 0.0);
+ litest_assert(axisval >= 0.0);
/* this is to verify we test the right thing, if the value
is greater than scroll.threshold we triggered the wrong
condition */
- ck_assert(axisval < 5.0);
+ litest_assert(axisval < 5.0);
libinput_event_destroy(event);
event = libinput_get_event(li);
int enabled = libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_APPLE;
- ck_assert_int_ge(libinput_device_config_scroll_has_natural_scroll(dev->libinput_device), 1);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), enabled);
- ck_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), enabled);
+ litest_assert_int_ge(libinput_device_config_scroll_has_natural_scroll(dev->libinput_device), 1);
+ litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), enabled);
+ litest_assert_int_eq(libinput_device_config_scroll_get_default_natural_scroll_enabled(dev->libinput_device), enabled);
}
END_TEST
enum libinput_config_status status;
status = libinput_device_config_scroll_set_natural_scroll_enabled(dev->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 1);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
- ck_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(libinput_device_config_scroll_get_natural_scroll_enabled(dev->libinput_device), 0);
}
END_TEST
should_have_2fg = true;
method = libinput_device_config_scroll_get_methods(device);
- ck_assert(method & LIBINPUT_CONFIG_SCROLL_EDGE);
+ litest_assert(method & LIBINPUT_CONFIG_SCROLL_EDGE);
if (should_have_2fg)
- ck_assert(method & LIBINPUT_CONFIG_SCROLL_2FG);
+ litest_assert(method & LIBINPUT_CONFIG_SCROLL_2FG);
else
- ck_assert((method & LIBINPUT_CONFIG_SCROLL_2FG) == 0);
+ litest_assert((method & LIBINPUT_CONFIG_SCROLL_2FG) == 0);
if (should_have_2fg)
expected = LIBINPUT_CONFIG_SCROLL_2FG;
expected = LIBINPUT_CONFIG_SCROLL_EDGE;
method = libinput_device_config_scroll_get_method(device);
- ck_assert_int_eq(method, expected);
+ litest_assert_int_eq(method, expected);
method = libinput_device_config_scroll_get_default_method(device);
- ck_assert_int_eq(method, expected);
+ litest_assert_int_eq(method, expected);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_EDGE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_scroll_set_method(device,
LIBINPUT_CONFIG_SCROLL_2FG);
if (should_have_2fg)
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
else
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
END_TEST
int nevents = 0;
double mm; /* one mm in percent of the device */
- ck_assert_int_eq(libinput_device_get_size(dev->libinput_device,
+ litest_assert_int_eq(libinput_device_get_size(dev->libinput_device,
&width,
&height), 0);
mm = 100.0/height;
0);
value = litest_event_pointer_get_value(ptrev,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- ck_assert_double_lt(value, 5.0);
+ litest_assert_double_lt(value, 5.0);
libinput_event_destroy(event);
nevents++;
}
/* we sent 20 events but allow for some to be swallowed by rounding
* errors, the hysteresis, etc. */
- ck_assert_int_ge(nevents, 10);
+ litest_assert_int_ge(nevents, 10);
litest_assert_empty_queue(li);
libinput_event_destroy(event);
LIBINPUT_EVENT_POINTER_SCROLL_FINGER,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
- ck_assert_int_eq(litest_event_pointer_get_axis_source(ptrev),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click(dev, BTN_LEFT, 1);
struct libinput_device *d = dev->libinput_device;
enum libinput_config_status status;
- ck_assert_int_eq(libinput_device_config_left_handed_is_available(d), 0);
+ litest_assert_int_eq(libinput_device_config_left_handed_is_available(d), 0);
status = libinput_device_config_left_handed_set(d, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
- ck_assert_int_eq(libinput_device_config_left_handed_get(d), 0);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_dispatch(li);
status = libinput_device_config_left_handed_set(d, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
do {
struct libinput_event_pointer *p;
double x, y, ux, uy;
uy = libinput_event_pointer_get_dy_unaccelerated(p);
if (rotate) {
- ck_assert_double_lt(x, 0);
- ck_assert_double_gt(y, 0);
- ck_assert_double_lt(ux, 0);
- ck_assert_double_gt(uy, 0);
+ litest_assert_double_lt(x, 0);
+ litest_assert_double_gt(y, 0);
+ litest_assert_double_lt(ux, 0);
+ litest_assert_double_gt(uy, 0);
} else {
- ck_assert_double_gt(x, 0);
- ck_assert_double_lt(y, 0);
- ck_assert_double_gt(ux, 0);
- ck_assert_double_lt(uy, 0);
+ litest_assert_double_gt(x, 0);
+ litest_assert_double_lt(y, 0);
+ litest_assert_double_gt(ux, 0);
+ litest_assert_double_lt(uy, 0);
}
libinput_event_destroy(event);
status = libinput_device_config_scroll_set_method(
trackpoint->libinput_device,
LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_drain_events(li);
litest_button_click_debounced(touchpad, li, BTN_2, true); /* middle */
0);
val = litest_event_pointer_get_value(pev,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- ck_assert(val != 0.0);
+ litest_assert(val != 0.0);
libinput_event_destroy(e);
}
0);
val = litest_event_pointer_get_value(pev,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- ck_assert(val != 0.0);
+ litest_assert(val != 0.0);
libinput_event_destroy(e);
}
p1 = litest_is_motion_event(ev1);
p2 = litest_is_motion_event(ev2);
- ck_assert_int_eq(libinput_event_get_type(ev1),
+ litest_assert_int_eq(libinput_event_get_type(ev1),
libinput_event_get_type(ev2));
litest_assert_double_eq(libinput_event_pointer_get_dx(p1),
if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_WACOM ||
libevdev_get_id_bustype(dev->evdev) == BUS_BLUETOOTH) {
- ck_assert(!libinput_device_config_dwt_is_available(device));
+ litest_assert(!libinput_device_config_dwt_is_available(device));
return;
}
- ck_assert(libinput_device_config_dwt_is_available(device));
+ litest_assert(libinput_device_config_dwt_is_available(device));
state = libinput_device_config_dwt_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
state = libinput_device_config_dwt_get_default_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_ENABLED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_dwtp_state state;
if (litest_touchpad_is_external(dev)) {
- ck_assert(!libinput_device_config_dwtp_is_available(device));
+ litest_assert(!libinput_device_config_dwtp_is_available(device));
return;
}
- ck_assert(libinput_device_config_dwtp_is_available(device));
+ litest_assert(libinput_device_config_dwtp_is_available(device));
state = libinput_device_config_dwtp_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
state = libinput_device_config_dwtp_get_default_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_ENABLED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_status status;
enum libinput_config_dwt_state state;
- ck_assert(!libinput_device_config_dwt_is_available(device));
+ litest_assert(!libinput_device_config_dwt_is_available(device));
state = libinput_device_config_dwt_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
state = libinput_device_config_dwt_get_default_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWT_DISABLED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_dwt_set_enabled(device,
LIBINPUT_CONFIG_DWT_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwt_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_status status;
enum libinput_config_dwtp_state state;
- ck_assert(!libinput_device_config_dwtp_is_available(device));
+ litest_assert(!libinput_device_config_dwtp_is_available(device));
state = libinput_device_config_dwtp_get_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
state = libinput_device_config_dwtp_get_default_enabled(device);
- ck_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
+ litest_assert_int_eq(state, LIBINPUT_CONFIG_DWTP_DISABLED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_ENABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
status = libinput_device_config_dwtp_set_enabled(device,
LIBINPUT_CONFIG_DWTP_DISABLED);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_dwtp_set_enabled(device, 3);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
struct litest_device *apple_keyboard;
struct libinput *li = touchpad->libinput;
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
apple_keyboard = litest_add_device(li, LITEST_APPLE_KEYBOARD);
litest_drain_events(li);
struct litest_device *keyboard, *hawaii_keyboard;
struct libinput *li = touchpad->libinput;
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
/* Only the hawaii keyboard can trigger DWT */
keyboard = litest_add_device(li, LITEST_KEYBOARD);
struct litest_device *k1, *k2;
struct libinput *li = touchpad->libinput;
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
enable_dwt(touchpad);
struct libinput *li = keyboard->libinput;
touchpad = litest_add_device(li, LITEST_SYNAPTICS_RMI4);
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
litest_dispatch(li);
struct litest_device *k1, *k2;
struct libinput *li = touchpad->libinput;
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
enable_dwt(touchpad);
struct litest_device *k1, *k2;
struct libinput *li = touchpad->libinput;
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
enable_dwt(touchpad);
int which = _i; /* ranged test */
struct litest_device *removed, *remained;
- ck_assert_int_le(which, 1);
+ litest_assert_int_le(which, 1);
- ck_assert(has_disable_while_typing(touchpad));
+ litest_assert(has_disable_while_typing(touchpad));
enable_dwt(touchpad);
struct libinput_event_pointer *ptrev;
ptrev = litest_is_motion_event(event);
- ck_assert_double_eq(libinput_event_pointer_get_dx(ptrev), 0.0);
- ck_assert_double_lt(libinput_event_pointer_get_dy(ptrev), 1.0);
+ litest_assert_double_eq(libinput_event_pointer_get_dx(ptrev), 0.0);
+ litest_assert_double_lt(libinput_event_pointer_get_dy(ptrev), 1.0);
libinput_event_destroy(event);
event = libinput_get_event(li);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
struct libinput_event_pointer *ptrev;
ptrev = litest_is_motion_event(event);
utime = libinput_event_pointer_get_time_usec(ptrev);
- ck_assert_int_eq(libinput_event_pointer_get_time(ptrev),
+ litest_assert_int_eq(libinput_event_pointer_get_time(ptrev),
(uint32_t) (utime / 1000));
libinput_event_destroy(event);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
dx = libinput_event_pointer_get_dx(ptrev);
dy = libinput_event_pointer_get_dy(ptrev);
- ck_assert_int_lt(abs((int)dx), 20);
- ck_assert_int_lt(abs((int)dy), 20);
+ litest_assert_int_lt(abs((int)dx), 20);
+ litest_assert_int_lt(abs((int)dy), 20);
libinput_event_destroy(event);
event = libinput_get_event(li);
ptrev = litest_is_motion_event(event);
dx = libinput_event_pointer_get_dx(ptrev);
dy = libinput_event_pointer_get_dy(ptrev);
- ck_assert_int_lt(abs((int)dx), 20);
- ck_assert_int_lt(abs((int)dy), 20);
+ litest_assert_int_lt(abs((int)dx), 20);
+ litest_assert_int_lt(abs((int)dy), 20);
libinput_event_destroy(event);
event = libinput_get_event(li);
status = libinput_device_config_send_events_set_mode(
dev->libinput_device,
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(dev, 0, 20, 30);
litest_touch_move_to(dev, 0, 20, 30, 90, 30, 10);
struct libevdev *evdev = dev->evdev;
/* We expect our udev callout to always set this to 0 */
- ck_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_X), 0);
- ck_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_Y), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_X), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_Y), 0);
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_POSITION_X))
- ck_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_MT_POSITION_X), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_MT_POSITION_X), 0);
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_POSITION_Y))
- ck_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_MT_POSITION_Y), 0);
+ litest_assert_int_eq(libevdev_get_abs_fuzz(evdev, ABS_MT_POSITION_Y), 0);
}
END_TEST
struct libinput_device *device = dev->libinput_device;
int angle;
- ck_assert(libinput_device_config_rotation_is_available(device));
+ litest_assert(libinput_device_config_rotation_is_available(device));
angle = libinput_device_config_rotation_get_angle(device);
- ck_assert_int_eq(angle, 0);
+ litest_assert_int_eq(angle, 0);
angle = libinput_device_config_rotation_get_default_angle(device);
- ck_assert_int_eq(angle, 0);
+ litest_assert_int_eq(angle, 0);
}
END_TEST
enum libinput_config_status status;
status = libinput_device_config_rotation_set_angle(device, 360);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_rotation_set_angle(device, 361);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
status = libinput_device_config_rotation_set_angle(device, -1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_INVALID);
}
END_TEST
enum libinput_config_status status;
int angle;
- ck_assert(!libinput_device_config_rotation_is_available(device));
+ litest_assert(!libinput_device_config_rotation_is_available(device));
angle = libinput_device_config_rotation_get_angle(device);
- ck_assert_int_eq(angle, 0);
+ litest_assert_int_eq(angle, 0);
angle = libinput_device_config_rotation_get_default_angle(device);
- ck_assert_int_eq(angle, 0);
+ litest_assert_int_eq(angle, 0);
/* 0 always succeeds */
status = libinput_device_config_rotation_set_angle(device, 0);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
for (angle = 1; angle < 360; angle++) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
}
}
END_TEST
enum libinput_config_status status;
int angle;
- ck_assert(libinput_device_config_rotation_is_available(device));
+ litest_assert(libinput_device_config_rotation_is_available(device));
for (angle = 0; angle < 360; angle += 90) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
}
END_TEST
enum libinput_config_status status;
int angle;
- ck_assert(libinput_device_config_rotation_is_available(device));
+ litest_assert(libinput_device_config_rotation_is_available(device));
for (angle = 0; angle < 360; angle++) {
status = libinput_device_config_rotation_set_angle(device,
angle);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
}
}
END_TEST
switch (angle) {
case 0:
- ck_assert_double_eq(dx, 1.0);
- ck_assert_double_eq(dy, 0.0);
+ litest_assert_double_eq(dx, 1.0);
+ litest_assert_double_eq(dy, 0.0);
break;
case 90:
- ck_assert_double_eq(dx, 0.0);
- ck_assert_double_eq(dy, 1.0);
+ litest_assert_double_eq(dx, 0.0);
+ litest_assert_double_eq(dy, 1.0);
break;
case 180:
- ck_assert_double_eq(dx, -1.0);
- ck_assert_double_eq(dy, 0.0);
+ litest_assert_double_eq(dx, -1.0);
+ litest_assert_double_eq(dy, 0.0);
break;
case 270:
- ck_assert_double_eq(dx, 0.0);
- ck_assert_double_eq(dy, -1.0);
+ litest_assert_double_eq(dx, 0.0);
+ litest_assert_double_eq(dy, -1.0);
break;
}
libinput_event_destroy(event);
switch (angle) {
case 0:
- ck_assert_double_eq(dx, 0.0);
- ck_assert_double_eq(dy, 1.0);
+ litest_assert_double_eq(dx, 0.0);
+ litest_assert_double_eq(dy, 1.0);
break;
case 90:
- ck_assert_double_eq(dx, -1.0);
- ck_assert_double_eq(dy, 0.0);
+ litest_assert_double_eq(dx, -1.0);
+ litest_assert_double_eq(dy, 0.0);
break;
case 180:
- ck_assert_double_eq(dx, 0.0);
- ck_assert_double_eq(dy, -1.0);
+ litest_assert_double_eq(dx, 0.0);
+ litest_assert_double_eq(dy, -1.0);
break;
case 270:
- ck_assert_double_eq(dx, 1.0);
- ck_assert_double_eq(dy, 0.0);
+ litest_assert_double_eq(dx, 1.0);
+ litest_assert_double_eq(dy, 0.0);
break;
}
libinput_event_destroy(event);
dx = libinput_event_pointer_get_dx(ptrev);
dy = libinput_event_pointer_get_dy(ptrev);
- ck_assert_double_lt(dx, 0.0);
- ck_assert_double_gt(dy, 0.0);
+ litest_assert_double_lt(dx, 0.0);
+ litest_assert_double_gt(dy, 0.0);
libinput_event_destroy(event);
}
END_TEST
rtime = libinput_event_pointer_get_time(ptrev);
libinput_event_destroy(event);
- ck_assert_int_lt(ptime, rtime);
+ litest_assert_int_lt(ptime, rtime);
litest_assert_empty_queue(li);
}
litest_assert_button_event(li, BTN_MIDDLE, 1);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
libinput_event_destroy(event);
while ((event = libinput_get_event(li))) {
ptrev = libinput_event_get_pointer_event(event);
- ck_assert_int_eq(litest_event_pointer_get_axis_source(ptrev),
+ litest_assert_int_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);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_delete_device(trackpoint);
/* touchpad left-handed, trackpoint right-handed */
status = libinput_device_config_left_handed_set(
touchpad->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
event = libinput_get_event(li);
litest_is_button_event(event, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
BTN_LEFT,
LIBINPUT_BUTTON_STATE_RELEASED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_delete_device(trackpoint);
/* touchpad left-handed, trackpoint left-handed */
status = libinput_device_config_left_handed_set(
touchpad->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
status = libinput_device_config_left_handed_set(
trackpoint->libinput_device, 1);
- ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+ litest_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
litest_touch_down(touchpad, 0, 5, 5);
litest_dispatch(li);
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_PRESSED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_button_click_debounced(touchpad, li, BTN_LEFT, false);
BTN_RIGHT,
LIBINPUT_BUTTON_STATE_RELEASED);
device = libinput_event_get_device(event);
- ck_assert(device == trackpoint->libinput_device);
+ litest_assert(device == trackpoint->libinput_device);
libinput_event_destroy(event);
litest_delete_device(trackpoint);
udev = udev_new();
li = libinput_udev_create_context(NULL, NULL, NULL);
- ck_assert(li == NULL);
+ litest_assert(li == NULL);
li = libinput_udev_create_context(&simple_interface, NULL, NULL);
- ck_assert(li == NULL);
+ litest_assert(li == NULL);
li = libinput_udev_create_context(NULL, NULL, udev);
- ck_assert(li == NULL);
+ litest_assert(li == NULL);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, NULL), -1);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, NULL), -1);
libinput_unref(li);
udev_unref(udev);
int fd;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
fd = libinput_get_fd(li);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
/* expect at least one event */
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
libinput_event_destroy(event);
libinput_unref(li);
int fd;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
/* expect a libinput reference, but no events */
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seatdoesntexist"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seatdoesntexist"), 0);
fd = libinput_get_fd(li);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert(event == NULL);
+ litest_assert(event == NULL);
libinput_event_destroy(event);
libinput_unref(li);
seatname[sizeof(seatname) - 1] = '\0';
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
litest_set_log_handler_bug(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, seatname), -1);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, seatname), -1);
litest_assert_empty_queue(li);
int data1, data2;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, &data1, udev);
- ck_assert_notnull(li);
- ck_assert(libinput_get_user_data(li) == &data1);
+ litest_assert_notnull(li);
+ litest_assert(libinput_get_user_data(li) == &data1);
libinput_set_user_data(li, &data2);
- ck_assert(libinput_get_user_data(li) == &data2);
+ litest_assert(libinput_get_user_data(li) == &data2);
libinput_unref(li);
udev_unref(udev);
struct litest_device *dev;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
/* Drop any events from other devices */
event = libinput_get_event(li);
device = libinput_event_get_device(event);
seat = libinput_device_get_seat(device);
- ck_assert_notnull(seat);
+ litest_assert_notnull(seat);
seat_name = libinput_seat_get_logical_name(seat);
- ck_assert_str_eq(seat_name, "default");
+ litest_assert_str_eq(seat_name, "default");
libinput_event_destroy(event);
libinput_unref(li);
struct litest_device *dev;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
/* Drop any events from other devices */
/* Changing the logical seat name will remove and re-add the device */
rc = libinput_device_set_seat_logical_name(device,
seat2_name);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_REMOVED);
- ck_assert(libinput_event_get_device(event) == device);
+ litest_assert(libinput_event_get_device(event) == device);
libinput_event_destroy(event);
event = libinput_get_event(li);
- ck_assert_int_eq(libinput_event_get_type(event),
+ litest_assert_int_eq(libinput_event_get_type(event),
LIBINPUT_EVENT_DEVICE_ADDED);
- ck_assert(libinput_event_get_device(event) != device);
+ litest_assert(libinput_event_get_device(event) != device);
libinput_device_unref(device);
device = libinput_event_get_device(event);
seat2 = libinput_device_get_seat(device);
- ck_assert_str_ne(libinput_seat_get_logical_name(seat2),
+ litest_assert_str_ne(libinput_seat_get_logical_name(seat2),
seat1_name);
- ck_assert_str_eq(libinput_seat_get_logical_name(seat2),
+ litest_assert_str_eq(libinput_seat_get_logical_name(seat2),
seat2_name);
libinput_event_destroy(event);
int fd;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
fd = libinput_get_fd(li);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
/* expect at least one event */
- ck_assert_int_ge(litest_dispatch(li), 0);
+ litest_assert_int_ge(litest_dispatch(li), 0);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
libinput_suspend(li);
libinput_suspend(li);
int fd;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
fd = libinput_get_fd(li);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
/* expect at least one event */
- ck_assert_int_ge(litest_dispatch(li), 0);
+ litest_assert_int_ge(litest_dispatch(li), 0);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
libinput_suspend(li);
libinput_resume(li);
int num_devices = 0;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
fd = libinput_get_fd(li);
- ck_assert_int_ge(fd, 0);
+ litest_assert_int_ge(fd, 0);
/* Check that at least one device was discovered after creation. */
- ck_assert_int_ge(litest_dispatch(li), 0);
+ litest_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
- ck_assert_int_gt(num_devices, 0);
+ litest_assert_int_gt(num_devices, 0);
/* Check that after a suspend, no devices are left. */
libinput_suspend(li);
- ck_assert_int_ge(litest_dispatch(li), 0);
+ litest_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
- ck_assert_int_eq(num_devices, 0);
+ litest_assert_int_eq(num_devices, 0);
/* Check that after a resume, at least one device is discovered. */
libinput_resume(li);
- ck_assert_int_ge(litest_dispatch(li), 0);
+ litest_assert_int_ge(litest_dispatch(li), 0);
process_events_count_devices(li, &num_devices);
- ck_assert_int_gt(num_devices, 0);
+ litest_assert_int_gt(num_devices, 0);
libinput_unref(li);
udev_unref(udev);
int rc;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
rc = libinput_resume(li);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
libinput_unref(li);
udev_unref(udev);
int rc;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
libinput_suspend(li);
rc = libinput_resume(li);
- ck_assert_int_eq(rc, 0);
+ litest_assert_int_eq(rc, 0);
libinput_unref(li);
udev_unref(udev);
struct udev *udev;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
device = libinput_event_get_device(ev);
sysname = libinput_device_get_sysname(device);
- ck_assert_notnull(sysname);
- ck_assert_int_gt(strlen(sysname), 1);
- ck_assert(strchr(sysname, '/') == NULL);
- ck_assert(strneq(sysname, "event", 5));
+ litest_assert_notnull(sysname);
+ litest_assert_int_gt(strlen(sysname), 1);
+ litest_assert(strchr(sysname, '/') == NULL);
+ litest_assert(strneq(sysname, "event", 5));
libinput_event_destroy(ev);
}
void *user_data;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
while ((ev = libinput_get_event(li))) {
break;
device = libinput_event_get_device(ev);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
saved_seat = libinput_device_get_seat(device);
libinput_seat_set_user_data(saved_seat, &data);
libinput_seat_ref(saved_seat);
libinput_event_destroy(ev);
}
- ck_assert_notnull(saved_seat);
+ litest_assert_notnull(saved_seat);
libinput_suspend(li);
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_DEVICE_ADDED:
device = libinput_event_get_device(ev);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
seat = libinput_device_get_seat(device);
user_data = libinput_seat_get_user_data(seat);
if (user_data == &data) {
found = 1;
- ck_assert(seat == saved_seat);
+ litest_assert(seat == saved_seat);
}
break;
default:
libinput_event_destroy(ev);
}
- ck_assert(found == 1);
+ litest_assert(found == 1);
libinput_unref(li);
udev_unref(udev);
struct libinput_device *device;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_set_log_handler_bug(li);
device = libinput_path_add_device(li, "/dev/input/event0");
- ck_assert(device == NULL);
+ litest_assert(device == NULL);
litest_restore_log_handler(li);
libinput_unref(li);
struct libinput_event *event;
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_notnull(li);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
litest_wait_for_event_of_type(li, LIBINPUT_EVENT_DEVICE_ADDED);
event = libinput_get_event(li);
device = libinput_event_get_device(event);
- ck_assert_notnull(device);
+ litest_assert_notnull(device);
/* no effect bug a bug log msg */
litest_set_log_handler_bug(li);
devname = libevdev_get_name(dev->evdev);
udev = udev_new();
- ck_assert_notnull(udev);
+ litest_assert_notnull(udev);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
- ck_assert_notnull(li);
+ litest_assert_notnull(li);
litest_restore_log_handler(li);
- ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
+ litest_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
litest_dispatch(li);
event = libinput_get_event(li);
- ck_assert_notnull(event);
+ litest_assert_notnull(event);
while (event) {
if (libinput_event_get_type(event) ==
LIBINPUT_EVENT_DEVICE_ADDED) {
device = libinput_event_get_device(event);
name = libinput_device_get_name(device);
- ck_assert_str_ne(devname, name);
+ litest_assert_str_ne(devname, name);
}
libinput_event_destroy(event);
litest_dispatch(li);
projects / platform / upstream / libinput.git / commitdiff