mirror of
https://gitlab.freedesktop.org/libevdev/libevdev.git
synced 2025-12-20 13:50:16 +01:00
f3f31b47fc
As seen on 3M devices, which seems to be the maximum seen so far. Some Stantum devices report 255 touches but are only capable of 10, so the are not affected by our limits. Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net> Acked-by: Benjamin Tissoires <benjamin.tissoires@gmail.com>
1460 lines
45 KiB
C
1460 lines
45 KiB
C
/*
|
|
* Copyright © 2013 Red Hat, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
* that the name of the copyright holders not be used in advertising or
|
|
* publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. The copyright holders make no representations
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
* is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
* OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <linux/input.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
|
|
#include "test-common.h"
|
|
|
|
#define MAX_SLOTS 60 /* as in libevdev-int.h */
|
|
|
|
START_TEST(test_next_event)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_dropped_event)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
int pipefd[2];
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
/* This is a bit complicated:
|
|
we can't get SYN_DROPPED through uinput, so we push two events down
|
|
uinput, and fetch one off libevdev (reading in the other one on the
|
|
way). Then write a SYN_DROPPED on a pipe, switch the fd and read
|
|
one event off the wire (but returning the second event from
|
|
before). Switch back, so that when we do read off the SYN_DROPPED
|
|
we have the fd back on the device and the ioctls work.
|
|
*/
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
rc = pipe2(pipefd, O_NONBLOCK);
|
|
ck_assert_int_eq(rc, 0);
|
|
|
|
libevdev_change_fd(dev, pipefd[0]);
|
|
ev.type = EV_SYN;
|
|
ev.code = SYN_DROPPED;
|
|
ev.value = 0;
|
|
rc = write(pipefd[1], &ev, sizeof(ev));
|
|
ck_assert_int_eq(rc, sizeof(ev));
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
|
|
libevdev_change_fd(dev, uinput_device_get_fd(uidev));
|
|
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_DROPPED);
|
|
|
|
/* only check for the rc, nothing actually changed on the device */
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
close(pipefd[0]);
|
|
close(pipefd[1]);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
void double_syn_dropped_logfunc(enum libevdev_log_priority priority,
|
|
void *data,
|
|
const char *file, int line,
|
|
const char *func,
|
|
const char *format, va_list args)
|
|
{
|
|
unsigned int *hit = data;
|
|
*hit = 1;
|
|
}
|
|
|
|
START_TEST(test_double_syn_dropped_event)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
int pipefd[2];
|
|
unsigned int logfunc_hit = 0;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
libevdev_set_log_function(double_syn_dropped_logfunc, &logfunc_hit);
|
|
|
|
/* This is a bit complicated:
|
|
we can't get SYN_DROPPED through uinput, so we push two events down
|
|
uinput, and fetch one off libevdev (reading in the other one on the
|
|
way). Then write a SYN_DROPPED on a pipe, switch the fd and read
|
|
one event off the wire (but returning the second event from
|
|
before). Switch back, so that when we do read off the SYN_DROPPED
|
|
we have the fd back on the device and the ioctls work.
|
|
*/
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
rc = pipe2(pipefd, O_NONBLOCK);
|
|
ck_assert_int_eq(rc, 0);
|
|
|
|
libevdev_change_fd(dev, pipefd[0]);
|
|
ev.type = EV_SYN;
|
|
ev.code = SYN_DROPPED;
|
|
ev.value = 0;
|
|
rc = write(pipefd[1], &ev, sizeof(ev));
|
|
ck_assert_int_eq(rc, sizeof(ev));
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
|
|
/* sneak in a button change event while we're not looking, this way
|
|
* the sync queue contains 2 events: BTN_LEFT and SYN_REPORT. */
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 0);
|
|
read(pipefd[0], &ev, sizeof(ev));
|
|
|
|
libevdev_change_fd(dev, uinput_device_get_fd(uidev));
|
|
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_DROPPED);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
ck_assert_int_eq(ev.value, 0);
|
|
|
|
/* now write the second SYN_DROPPED on the pipe so we pick it up
|
|
* before we finish syncing. */
|
|
libevdev_change_fd(dev, pipefd[0]);
|
|
ev.type = EV_SYN;
|
|
ev.code = SYN_DROPPED;
|
|
ev.value = 0;
|
|
rc = write(pipefd[1], &ev, sizeof(ev));
|
|
ck_assert_int_eq(rc, sizeof(ev));
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
ck_assert_int_eq(ev.value, 0);
|
|
|
|
/* back to enable the ioctls again */
|
|
libevdev_change_fd(dev, uinput_device_get_fd(uidev));
|
|
|
|
ck_assert_int_eq(logfunc_hit, 1);
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
close(pipefd[0]);
|
|
close(pipefd[1]);
|
|
|
|
libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_type_filtered)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
libevdev_disable_event_type(dev, EV_REL);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_event(uidev, EV_REL, REL_X, 1);
|
|
uinput_device_event(uidev, EV_KEY, REL_Y, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_code_filtered)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
libevdev_disable_event_code(dev, EV_REL, REL_X);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_event(uidev, EV_REL, REL_X, 1);
|
|
uinput_device_event(uidev, EV_REL, REL_Y, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_REL);
|
|
ck_assert_int_eq(ev.code, REL_Y);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_has_event_pending)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
|
|
|
|
uinput_device_event(uidev, EV_REL, REL_X, 1);
|
|
uinput_device_event(uidev, EV_REL, REL_Y, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
|
|
ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
|
|
|
|
libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
|
|
ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
|
|
|
|
while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN)
|
|
;
|
|
|
|
ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
|
|
|
|
libevdev_change_fd(dev, -1);
|
|
ck_assert_int_eq(libevdev_has_event_pending(dev), -EBADF);
|
|
|
|
libevdev_free(dev);
|
|
uinput_device_free(uidev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_button)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
EV_KEY, KEY_MAX,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_KEY, BTN_RIGHT, 1);
|
|
uinput_device_event(uidev, EV_KEY, KEY_MAX, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_RIGHT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, KEY_MAX);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT));
|
|
ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT));
|
|
ck_assert(!libevdev_get_event_value(dev, EV_KEY, BTN_MIDDLE));
|
|
ck_assert(libevdev_get_event_value(dev, EV_KEY, KEY_MAX));
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_abs)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[3];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_MAX;
|
|
abs[2].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
3, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MAX, 700);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_X);
|
|
ck_assert_int_eq(ev.value, 100);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_Y);
|
|
ck_assert_int_eq(ev.value, 500);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MAX);
|
|
ck_assert_int_eq(ev.value, 700);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_mt)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[6];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 1;
|
|
abs[5].value = ABS_MT_TRACKING_ID;
|
|
abs[5].minimum = -1;
|
|
abs[5].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
6, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_X);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_Y);
|
|
ck_assert_int_eq(ev.value, 5);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_SLOT);
|
|
ck_assert_int_eq(ev.value, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
|
|
ck_assert_int_eq(ev.value, 100);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
|
|
ck_assert_int_eq(ev.value, 500);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_SLOT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
|
|
ck_assert_int_eq(ev.value, 5);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
|
|
ck_assert_int_eq(ev.value, 2);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_mt_too_many)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[6];
|
|
int i;
|
|
int num_slots = MAX_SLOTS + 20;
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = num_slots;
|
|
abs[5].value = ABS_MT_TOOL_Y;
|
|
abs[5].maximum = 500;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
6, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
for (i = num_slots; i >= 0; i--) {
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, i);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100 + i);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500 + i);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100 + i);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500 + i);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_TOOL_Y, 1 + i);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
}
|
|
|
|
/* drain the fd, so libevdev_next_event doesn't pick up any events
|
|
before the FORCE_SYNC */
|
|
do {
|
|
rc = read(libevdev_get_fd(dev), &ev, sizeof(ev));
|
|
} while (rc > 0);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
i = 0;
|
|
while (i < num_slots) {
|
|
int slot;
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
if (libevdev_event_is_code(&ev, EV_SYN, SYN_REPORT))
|
|
break;
|
|
|
|
if (libevdev_event_is_code(&ev, EV_ABS, ABS_X) ||
|
|
libevdev_event_is_code(&ev, EV_ABS, ABS_Y))
|
|
continue;
|
|
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_SLOT);
|
|
slot = ev.value;
|
|
ck_assert_int_lt(slot, MAX_SLOTS);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
|
|
ck_assert_int_eq(ev.value, 100 + slot);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
|
|
ck_assert_int_eq(ev.value, 500 + slot);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_ABS);
|
|
ck_assert_int_eq(ev.code, ABS_MT_TOOL_Y);
|
|
ck_assert_int_eq(ev.value, 1 + slot);
|
|
|
|
i++;
|
|
}
|
|
|
|
/* we expect eactly MAX_SLOTS to be synced */
|
|
ck_assert_int_eq(i, MAX_SLOTS);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_led)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_LED, LED_NUML,
|
|
EV_LED, LED_CAPSL,
|
|
EV_LED, LED_MAX,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_LED, LED_NUML, 1);
|
|
uinput_device_event(uidev, EV_LED, LED_CAPSL, 1);
|
|
uinput_device_event(uidev, EV_LED, LED_MAX, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_LED);
|
|
ck_assert_int_eq(ev.code, LED_NUML);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_LED);
|
|
ck_assert_int_eq(ev.code, LED_CAPSL);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_LED);
|
|
ck_assert_int_eq(ev.code, LED_MAX);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_MAX), 1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_syn_delta_sw)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_SW, SW_LID,
|
|
EV_SW, SW_MICROPHONE_INSERT,
|
|
EV_SW, SW_MAX,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_SW, SW_LID, 1);
|
|
uinput_device_event(uidev, EV_SW, SW_MICROPHONE_INSERT, 1);
|
|
uinput_device_event(uidev, EV_SW, SW_MAX, 1);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SW);
|
|
ck_assert_int_eq(ev.code, SW_LID);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SW);
|
|
ck_assert_int_eq(ev.code, SW_MICROPHONE_INSERT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SW);
|
|
ck_assert_int_eq(ev.code, SW_MAX);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_SYN);
|
|
ck_assert_int_eq(ev.code, SYN_REPORT);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MICROPHONE_INSERT), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MAX), 1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_skipped_sync)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[2];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_incomplete_sync)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[2];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
ck_assert_int_eq(ev.type, EV_KEY);
|
|
ck_assert_int_eq(ev.code, BTN_LEFT);
|
|
ck_assert_int_eq(ev.value, 1);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_empty_sync)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
|
|
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
|
|
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_values)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[2];
|
|
int value;
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
|
|
/* must still be on old values */
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
|
|
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
|
|
ck_assert_int_eq(value, 0);
|
|
|
|
do {
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
} while (rc == 0);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
|
|
|
|
/* always 0 */
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
|
|
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
|
|
ck_assert_int_eq(value, 1);
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_X, &value), 1);
|
|
ck_assert_int_eq(value, 100);
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Y, &value), 1);
|
|
ck_assert_int_eq(value, 500);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_values_invalid)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[2];
|
|
int value;
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_SYN, SYN_DROPPED,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_EXTRA), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Z), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Z), 0);
|
|
|
|
value = 0xab;
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_EXTRA, &value), 0);
|
|
ck_assert_int_eq(value, 0xab);
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Z, &value), 0);
|
|
ck_assert_int_eq(value, 0xab);
|
|
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_REL, REL_Z, &value), 0);
|
|
ck_assert_int_eq(value, 0xab);
|
|
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_mt_event_values)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_event ev;
|
|
struct input_absinfo abs[5];
|
|
int value;
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
5, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_X, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
|
|
uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
|
|
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
|
|
|
|
/* must still be on old values */
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 0);
|
|
|
|
do {
|
|
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
|
|
} while (rc == LIBEVDEV_READ_STATUS_SUCCESS);
|
|
ck_assert_int_eq(rc, -EAGAIN);
|
|
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
|
|
|
|
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 1);
|
|
ck_assert_int_eq(value, 100);
|
|
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_Y, &value), 1);
|
|
ck_assert_int_eq(value, 500);
|
|
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_X, &value), 1);
|
|
ck_assert_int_eq(value, 1);
|
|
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_Y, &value), 1);
|
|
ck_assert_int_eq(value, 5);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_mt_event_values_invalid)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[5];
|
|
int value;
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
5, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_TOUCH_MINOR), 0);
|
|
value = 0xab;
|
|
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_TOUCH_MINOR, &value), 0);
|
|
ck_assert_int_eq(value, 0xab);
|
|
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 10, ABS_MT_POSITION_X), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_X), 0);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_ev_rep_values)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
int delay = 500, period = 200;
|
|
rc = test_create_device(&uidev, &dev,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
|
|
libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
|
|
|
|
ck_assert_int_eq(libevdev_has_event_type(dev, EV_REP), 1);
|
|
ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_DELAY), 1);
|
|
ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_PERIOD), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_DELAY), 500);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_PERIOD), 200);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_value_setters)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[2];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
EV_LED, LED_NUML,
|
|
EV_LED, LED_CAPSL,
|
|
EV_SW, SW_LID,
|
|
EV_SW, SW_TABLET_MODE,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_LEFT, 1), 0);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_RIGHT, 1), 0);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT), 1);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_X, 10), 0);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Y, 20), 0);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 10);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 20);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_NUML, 1), 0);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_CAPSL, 1), 0);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_LID, 1), 0);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_TABLET_MODE, 1), 0);
|
|
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_TABLET_MODE), 1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_value_setters_invalid)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[2];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
|
|
abs[1].value = ABS_Y;
|
|
abs[1].maximum = 1000;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
2, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
EV_REL, REL_X,
|
|
EV_REL, REL_Y,
|
|
EV_KEY, BTN_LEFT,
|
|
EV_KEY, BTN_MIDDLE,
|
|
EV_KEY, BTN_RIGHT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_REL, REL_X, 1), -1);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_DOCK, 1), -1);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Z, 1), -1);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_MAX + 1, 0, 1), -1);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SYN, SYN_REPORT, 0), -1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_mt_value_setters)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[5];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
5, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_X, 1), 0);
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_Y, 2), 0);
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_Y, 4), 0);
|
|
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 2);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 3);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 4);
|
|
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_SLOT, 1), 0);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_SLOT), 1);
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_mt_value_setters_invalid)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[5];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
5, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
/* invalid axis */
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_Z, 1), -1);
|
|
/* valid, but non-mt axis */
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_X, 1), -1);
|
|
/* invalid mt axis */
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_PRESSURE, 1), -1);
|
|
/* invalid slot no */
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 4, ABS_X, 1), -1);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_event_mt_value_setters_current_slot)
|
|
{
|
|
struct uinput_device* uidev;
|
|
struct libevdev *dev;
|
|
int rc;
|
|
struct input_absinfo abs[5];
|
|
|
|
memset(abs, 0, sizeof(abs));
|
|
abs[0].value = ABS_X;
|
|
abs[0].maximum = 1000;
|
|
abs[1].value = ABS_MT_POSITION_X;
|
|
abs[1].maximum = 1000;
|
|
|
|
abs[2].value = ABS_Y;
|
|
abs[2].maximum = 1000;
|
|
abs[3].value = ABS_MT_POSITION_Y;
|
|
abs[3].maximum = 1000;
|
|
|
|
abs[4].value = ABS_MT_SLOT;
|
|
abs[4].maximum = 2;
|
|
|
|
rc = test_create_abs_device(&uidev, &dev,
|
|
5, abs,
|
|
EV_SYN, SYN_REPORT,
|
|
-1);
|
|
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
|
|
|
|
/* set_event_value/get_event_value works on the current slot */
|
|
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 1), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 1);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 1);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 2), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
|
|
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 2);
|
|
|
|
/* set slot 0, but current is still slot 1 */
|
|
ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
|
|
|
|
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 0), 0);
|
|
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
|
|
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 3);
|
|
|
|
uinput_device_free(uidev);
|
|
libevdev_free(dev);
|
|
}
|
|
END_TEST
|
|
|
|
Suite *
|
|
libevdev_events(void)
|
|
{
|
|
Suite *s = suite_create("libevdev event tests");
|
|
|
|
TCase *tc = tcase_create("event polling");
|
|
tcase_add_test(tc, test_next_event);
|
|
tcase_add_test(tc, test_syn_dropped_event);
|
|
tcase_add_test(tc, test_double_syn_dropped_event);
|
|
tcase_add_test(tc, test_event_type_filtered);
|
|
tcase_add_test(tc, test_event_code_filtered);
|
|
tcase_add_test(tc, test_has_event_pending);
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("SYN_DROPPED deltas");
|
|
tcase_add_test(tc, test_syn_delta_button);
|
|
tcase_add_test(tc, test_syn_delta_abs);
|
|
tcase_add_test(tc, test_syn_delta_mt);
|
|
tcase_add_test(tc, test_syn_delta_mt_too_many);
|
|
tcase_add_test(tc, test_syn_delta_led);
|
|
tcase_add_test(tc, test_syn_delta_sw);
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("skipped syncs");
|
|
tcase_add_test(tc, test_skipped_sync);
|
|
tcase_add_test(tc, test_incomplete_sync);
|
|
tcase_add_test(tc, test_empty_sync);
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("event values");
|
|
tcase_add_test(tc, test_event_values);
|
|
tcase_add_test(tc, test_event_values_invalid);
|
|
tcase_add_test(tc, test_mt_event_values);
|
|
tcase_add_test(tc, test_mt_event_values_invalid);
|
|
tcase_add_test(tc, test_ev_rep_values);
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("event value setters");
|
|
tcase_add_test(tc, test_event_value_setters);
|
|
tcase_add_test(tc, test_event_value_setters_invalid);
|
|
tcase_add_test(tc, test_event_mt_value_setters);
|
|
tcase_add_test(tc, test_event_mt_value_setters_invalid);
|
|
tcase_add_test(tc, test_event_mt_value_setters_current_slot);
|
|
suite_add_tcase(s, tc);
|
|
|
|
return s;
|
|
}
|
|
|