2 * Copyright © 2013 Red Hat, Inc.
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 #include <linux/input.h>
29 #include "test-common.h"
31 START_TEST(test_next_event)
33 struct uinput_device* uidev;
36 struct input_event ev;
38 rc = test_create_device(&uidev, &dev,
43 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
45 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
46 ck_assert_int_eq(rc, -EAGAIN);
48 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
49 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
50 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
51 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
52 ck_assert_int_eq(ev.type, EV_KEY);
53 ck_assert_int_eq(ev.code, BTN_LEFT);
54 ck_assert_int_eq(ev.value, 1);
57 uinput_device_free(uidev);
62 START_TEST(test_syn_event)
64 struct uinput_device* uidev;
67 struct input_event ev;
70 rc = test_create_device(&uidev, &dev,
77 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
79 /* This is a bid complicated:
80 we can't get SYN_DROPPED through uinput, so we push two events down
81 uinput, and fetch one off libevdev (reading in the other one on the
82 way). Then write a SYN_DROPPED on a pipe, switch the fd and read
83 one event off the wire (but returning the second event from
84 before). Switch back, so that when we do read off the SYN_DROPPED
85 we have the fd back on the device and the ioctls work.
87 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
88 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
89 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
90 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
91 ck_assert_int_eq(ev.type, EV_KEY);
92 ck_assert_int_eq(ev.code, BTN_LEFT);
93 rc = pipe2(pipefd, O_NONBLOCK);
94 ck_assert_int_eq(rc, 0);
96 libevdev_change_fd(dev, pipefd[0]);
98 ev.code = SYN_DROPPED;
100 rc = write(pipefd[1], &ev, sizeof(ev));
101 ck_assert_int_eq(rc, sizeof(ev));
102 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
104 libevdev_change_fd(dev, uinput_device_get_fd(uidev));
106 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
107 ck_assert_int_eq(ev.type, EV_SYN);
108 ck_assert_int_eq(ev.code, SYN_REPORT);
109 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
110 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
112 /* only check for the rc, nothing actually changed on the device */
115 uinput_device_free(uidev);
123 START_TEST(test_event_type_filtered)
125 struct uinput_device* uidev;
126 struct libevdev *dev;
128 struct input_event ev;
130 rc = test_create_device(&uidev, &dev,
135 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
137 libevdev_disable_event_type(dev, EV_REL);
139 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
140 ck_assert_int_eq(rc, -EAGAIN);
142 uinput_device_event(uidev, EV_REL, REL_X, 1);
143 uinput_device_event(uidev, EV_KEY, REL_Y, 1);
144 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
145 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
146 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
147 ck_assert_int_eq(ev.type, EV_SYN);
148 ck_assert_int_eq(ev.code, SYN_REPORT);
150 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
151 ck_assert_int_eq(rc, -EAGAIN);
154 uinput_device_free(uidev);
158 START_TEST(test_event_code_filtered)
160 struct uinput_device* uidev;
161 struct libevdev *dev;
163 struct input_event ev;
165 rc = test_create_device(&uidev, &dev,
170 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
172 libevdev_disable_event_code(dev, EV_REL, REL_X);
174 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
175 ck_assert_int_eq(rc, -EAGAIN);
177 uinput_device_event(uidev, EV_REL, REL_X, 1);
178 uinput_device_event(uidev, EV_REL, REL_Y, 1);
179 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
180 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
181 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
182 ck_assert_int_eq(ev.type, EV_REL);
183 ck_assert_int_eq(ev.code, REL_Y);
184 ck_assert_int_eq(ev.value, 1);
186 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
187 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
188 ck_assert_int_eq(ev.type, EV_SYN);
189 ck_assert_int_eq(ev.code, SYN_REPORT);
191 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
192 ck_assert_int_eq(rc, -EAGAIN);
195 uinput_device_free(uidev);
200 START_TEST(test_has_event_pending)
202 struct uinput_device* uidev;
203 struct libevdev *dev;
205 struct input_event ev;
207 rc = test_create_device(&uidev, &dev,
212 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
214 ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
216 uinput_device_event(uidev, EV_REL, REL_X, 1);
217 uinput_device_event(uidev, EV_REL, REL_Y, 1);
218 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
220 ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
222 libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
224 ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
226 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN)
229 ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
231 libevdev_change_fd(dev, -1);
232 ck_assert_int_eq(libevdev_has_event_pending(dev), -EBADF);
235 uinput_device_free(uidev);
239 START_TEST(test_syn_delta_button)
241 struct uinput_device* uidev;
242 struct libevdev *dev;
244 struct input_event ev;
246 rc = test_create_device(&uidev, &dev,
256 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
258 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
259 uinput_device_event(uidev, EV_KEY, BTN_RIGHT, 1);
260 uinput_device_event(uidev, EV_KEY, KEY_MAX, 1);
261 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
262 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
263 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
265 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
266 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
267 ck_assert_int_eq(ev.type, EV_KEY);
268 ck_assert_int_eq(ev.code, BTN_LEFT);
269 ck_assert_int_eq(ev.value, 1);
270 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
271 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
272 ck_assert_int_eq(ev.type, EV_KEY);
273 ck_assert_int_eq(ev.code, BTN_RIGHT);
274 ck_assert_int_eq(ev.value, 1);
275 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
276 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
277 ck_assert_int_eq(ev.type, EV_KEY);
278 ck_assert_int_eq(ev.code, KEY_MAX);
279 ck_assert_int_eq(ev.value, 1);
280 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
281 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
282 ck_assert_int_eq(ev.type, EV_SYN);
283 ck_assert_int_eq(ev.code, SYN_REPORT);
284 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
285 ck_assert_int_eq(rc, -EAGAIN);
287 ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT));
288 ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT));
289 ck_assert(!libevdev_get_event_value(dev, EV_KEY, BTN_MIDDLE));
290 ck_assert(libevdev_get_event_value(dev, EV_KEY, KEY_MAX));
292 uinput_device_free(uidev);
297 START_TEST(test_syn_delta_abs)
299 struct uinput_device* uidev;
300 struct libevdev *dev;
302 struct input_event ev;
303 struct input_absinfo abs[3];
305 memset(abs, 0, sizeof(abs));
306 abs[0].value = ABS_X;
307 abs[0].maximum = 1000;
309 abs[1].value = ABS_Y;
310 abs[1].maximum = 1000;
312 abs[2].value = ABS_MAX;
313 abs[2].maximum = 1000;
315 rc = test_create_abs_device(&uidev, &dev,
323 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
325 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
326 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
327 uinput_device_event(uidev, EV_ABS, ABS_MAX, 700);
328 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
329 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
330 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
332 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
333 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
334 ck_assert_int_eq(ev.type, EV_ABS);
335 ck_assert_int_eq(ev.code, ABS_X);
336 ck_assert_int_eq(ev.value, 100);
337 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
338 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
339 ck_assert_int_eq(ev.type, EV_ABS);
340 ck_assert_int_eq(ev.code, ABS_Y);
341 ck_assert_int_eq(ev.value, 500);
342 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
343 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
344 ck_assert_int_eq(ev.type, EV_ABS);
345 ck_assert_int_eq(ev.code, ABS_MAX);
346 ck_assert_int_eq(ev.value, 700);
347 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
348 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
349 ck_assert_int_eq(ev.type, EV_SYN);
350 ck_assert_int_eq(ev.code, SYN_REPORT);
351 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
352 ck_assert_int_eq(rc, -EAGAIN);
354 uinput_device_free(uidev);
359 START_TEST(test_syn_delta_mt)
361 struct uinput_device* uidev;
362 struct libevdev *dev;
364 struct input_event ev;
365 struct input_absinfo abs[6];
367 memset(abs, 0, sizeof(abs));
368 abs[0].value = ABS_X;
369 abs[0].maximum = 1000;
370 abs[1].value = ABS_MT_POSITION_X;
371 abs[1].maximum = 1000;
373 abs[2].value = ABS_Y;
374 abs[2].maximum = 1000;
375 abs[3].value = ABS_MT_POSITION_Y;
376 abs[3].maximum = 1000;
379 abs[4].value = ABS_MT_SLOT;
381 abs[5].value = ABS_MT_TRACKING_ID;
385 rc = test_create_abs_device(&uidev, &dev,
389 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
391 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
392 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
393 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
394 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
395 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
396 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
397 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
398 uinput_device_event(uidev, EV_ABS, ABS_X, 1);
399 uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
400 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
401 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
402 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
403 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
405 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
406 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
408 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
409 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
410 ck_assert_int_eq(ev.type, EV_ABS);
411 ck_assert_int_eq(ev.code, ABS_X);
412 ck_assert_int_eq(ev.value, 1);
413 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
414 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
415 ck_assert_int_eq(ev.type, EV_ABS);
416 ck_assert_int_eq(ev.code, ABS_Y);
417 ck_assert_int_eq(ev.value, 5);
418 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
419 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
420 ck_assert_int_eq(ev.type, EV_ABS);
421 ck_assert_int_eq(ev.code, ABS_MT_SLOT);
422 ck_assert_int_eq(ev.value, 0);
423 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
424 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
425 ck_assert_int_eq(ev.type, EV_ABS);
426 ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
427 ck_assert_int_eq(ev.value, 100);
428 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
429 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
430 ck_assert_int_eq(ev.type, EV_ABS);
431 ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
432 ck_assert_int_eq(ev.value, 500);
433 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
434 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
435 ck_assert_int_eq(ev.type, EV_ABS);
436 ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
437 ck_assert_int_eq(ev.value, 1);
438 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
439 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
440 ck_assert_int_eq(ev.type, EV_ABS);
441 ck_assert_int_eq(ev.code, ABS_MT_SLOT);
442 ck_assert_int_eq(ev.value, 1);
443 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
444 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
445 ck_assert_int_eq(ev.type, EV_ABS);
446 ck_assert_int_eq(ev.code, ABS_MT_POSITION_X);
447 ck_assert_int_eq(ev.value, 1);
448 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
449 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
450 ck_assert_int_eq(ev.type, EV_ABS);
451 ck_assert_int_eq(ev.code, ABS_MT_POSITION_Y);
452 ck_assert_int_eq(ev.value, 5);
453 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
454 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
455 ck_assert_int_eq(ev.type, EV_ABS);
456 ck_assert_int_eq(ev.code, ABS_MT_TRACKING_ID);
457 ck_assert_int_eq(ev.value, 2);
459 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
460 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
461 ck_assert_int_eq(ev.type, EV_SYN);
462 ck_assert_int_eq(ev.code, SYN_REPORT);
463 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
464 ck_assert_int_eq(rc, -EAGAIN);
466 uinput_device_free(uidev);
471 START_TEST(test_syn_delta_led)
473 struct uinput_device* uidev;
474 struct libevdev *dev;
476 struct input_event ev;
478 rc = test_create_device(&uidev, &dev,
485 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
487 uinput_device_event(uidev, EV_LED, LED_NUML, 1);
488 uinput_device_event(uidev, EV_LED, LED_CAPSL, 1);
489 uinput_device_event(uidev, EV_LED, LED_MAX, 1);
490 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
491 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
492 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
494 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
495 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
496 ck_assert_int_eq(ev.type, EV_LED);
497 ck_assert_int_eq(ev.code, LED_NUML);
498 ck_assert_int_eq(ev.value, 1);
499 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
500 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
501 ck_assert_int_eq(ev.type, EV_LED);
502 ck_assert_int_eq(ev.code, LED_CAPSL);
503 ck_assert_int_eq(ev.value, 1);
504 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
505 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
506 ck_assert_int_eq(ev.type, EV_LED);
507 ck_assert_int_eq(ev.code, LED_MAX);
508 ck_assert_int_eq(ev.value, 1);
509 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
510 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
511 ck_assert_int_eq(ev.type, EV_SYN);
512 ck_assert_int_eq(ev.code, SYN_REPORT);
513 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
514 ck_assert_int_eq(rc, -EAGAIN);
516 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
517 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
518 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_MAX), 1);
520 uinput_device_free(uidev);
525 START_TEST(test_syn_delta_sw)
527 struct uinput_device* uidev;
528 struct libevdev *dev;
530 struct input_event ev;
532 rc = test_create_device(&uidev, &dev,
536 EV_SW, SW_MICROPHONE_INSERT,
539 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
541 uinput_device_event(uidev, EV_SW, SW_LID, 1);
542 uinput_device_event(uidev, EV_SW, SW_MICROPHONE_INSERT, 1);
543 uinput_device_event(uidev, EV_SW, SW_MAX, 1);
544 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
545 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
546 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
548 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
549 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
550 ck_assert_int_eq(ev.type, EV_SW);
551 ck_assert_int_eq(ev.code, SW_LID);
552 ck_assert_int_eq(ev.value, 1);
553 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
554 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
555 ck_assert_int_eq(ev.type, EV_SW);
556 ck_assert_int_eq(ev.code, SW_MICROPHONE_INSERT);
557 ck_assert_int_eq(ev.value, 1);
558 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
559 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
560 ck_assert_int_eq(ev.type, EV_SW);
561 ck_assert_int_eq(ev.code, SW_MAX);
562 ck_assert_int_eq(ev.value, 1);
563 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
564 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
565 ck_assert_int_eq(ev.type, EV_SYN);
566 ck_assert_int_eq(ev.code, SYN_REPORT);
567 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
568 ck_assert_int_eq(rc, -EAGAIN);
570 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
571 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MICROPHONE_INSERT), 1);
572 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MAX), 1);
574 uinput_device_free(uidev);
579 START_TEST(test_skipped_sync)
581 struct uinput_device* uidev;
582 struct libevdev *dev;
584 struct input_event ev;
585 struct input_absinfo abs[2];
587 memset(abs, 0, sizeof(abs));
588 abs[0].value = ABS_X;
589 abs[0].maximum = 1000;
591 abs[1].value = ABS_Y;
592 abs[1].maximum = 1000;
594 rc = test_create_abs_device(&uidev, &dev,
602 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
604 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
605 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
606 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
607 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
608 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
609 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
611 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
612 ck_assert_int_eq(rc, -EAGAIN);
614 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
615 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
616 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
618 uinput_device_free(uidev);
623 START_TEST(test_incomplete_sync)
625 struct uinput_device* uidev;
626 struct libevdev *dev;
628 struct input_event ev;
629 struct input_absinfo abs[2];
631 memset(abs, 0, sizeof(abs));
632 abs[0].value = ABS_X;
633 abs[0].maximum = 1000;
635 abs[1].value = ABS_Y;
636 abs[1].maximum = 1000;
638 rc = test_create_abs_device(&uidev, &dev,
646 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
648 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
649 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
650 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
651 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
652 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
653 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
655 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
656 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
657 ck_assert_int_eq(ev.type, EV_KEY);
658 ck_assert_int_eq(ev.code, BTN_LEFT);
659 ck_assert_int_eq(ev.value, 1);
661 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
662 ck_assert_int_eq(rc, -EAGAIN);
664 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
665 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
666 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
668 uinput_device_free(uidev);
673 START_TEST(test_empty_sync)
675 struct uinput_device* uidev;
676 struct libevdev *dev;
678 struct input_event ev;
680 rc = test_create_device(&uidev, &dev,
687 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
689 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
690 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
692 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
693 ck_assert_int_eq(rc, -EAGAIN);
695 uinput_device_free(uidev);
700 START_TEST(test_event_values)
702 struct uinput_device* uidev;
703 struct libevdev *dev;
705 struct input_event ev;
706 struct input_absinfo abs[2];
709 memset(abs, 0, sizeof(abs));
710 abs[0].value = ABS_X;
711 abs[0].maximum = 1000;
713 abs[1].value = ABS_Y;
714 abs[1].maximum = 1000;
716 rc = test_create_abs_device(&uidev, &dev,
726 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
728 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
729 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
730 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
731 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
733 /* must still be on old values */
734 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
735 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
736 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
737 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
738 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
740 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
741 ck_assert_int_eq(value, 0);
744 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
746 ck_assert_int_eq(rc, -EAGAIN);
748 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
749 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
750 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
753 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
754 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
756 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
757 ck_assert_int_eq(value, 1);
758 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_X, &value), 1);
759 ck_assert_int_eq(value, 100);
760 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Y, &value), 1);
761 ck_assert_int_eq(value, 500);
763 uinput_device_free(uidev);
770 START_TEST(test_event_values_invalid)
772 struct uinput_device* uidev;
773 struct libevdev *dev;
775 struct input_absinfo abs[2];
778 memset(abs, 0, sizeof(abs));
779 abs[0].value = ABS_X;
780 abs[0].maximum = 1000;
782 abs[1].value = ABS_Y;
783 abs[1].maximum = 1000;
785 rc = test_create_abs_device(&uidev, &dev,
795 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
797 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_EXTRA), 0);
798 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Z), 0);
799 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Z), 0);
802 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_EXTRA, &value), 0);
803 ck_assert_int_eq(value, 0xab);
804 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Z, &value), 0);
805 ck_assert_int_eq(value, 0xab);
806 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_REL, REL_Z, &value), 0);
807 ck_assert_int_eq(value, 0xab);
810 uinput_device_free(uidev);
816 START_TEST(test_mt_event_values)
818 struct uinput_device* uidev;
819 struct libevdev *dev;
821 struct input_event ev;
822 struct input_absinfo abs[5];
825 memset(abs, 0, sizeof(abs));
826 abs[0].value = ABS_X;
827 abs[0].maximum = 1000;
828 abs[1].value = ABS_MT_POSITION_X;
829 abs[1].maximum = 1000;
831 abs[2].value = ABS_Y;
832 abs[2].maximum = 1000;
833 abs[3].value = ABS_MT_POSITION_Y;
834 abs[3].maximum = 1000;
836 abs[4].value = ABS_MT_SLOT;
839 rc = test_create_abs_device(&uidev, &dev,
843 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
845 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
846 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
847 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
848 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
849 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
850 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
851 uinput_device_event(uidev, EV_ABS, ABS_X, 1);
852 uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
853 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
854 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
855 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
857 /* must still be on old values */
858 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
859 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 0);
860 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 0);
861 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 0);
862 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 0);
865 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
866 } while (rc == LIBEVDEV_READ_STATUS_SUCCESS);
867 ck_assert_int_eq(rc, -EAGAIN);
869 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
870 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
871 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
872 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
873 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
875 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 1);
876 ck_assert_int_eq(value, 100);
877 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_Y, &value), 1);
878 ck_assert_int_eq(value, 500);
879 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_X, &value), 1);
880 ck_assert_int_eq(value, 1);
881 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_Y, &value), 1);
882 ck_assert_int_eq(value, 5);
884 uinput_device_free(uidev);
890 START_TEST(test_mt_event_values_invalid)
892 struct uinput_device* uidev;
893 struct libevdev *dev;
895 struct input_absinfo abs[5];
898 memset(abs, 0, sizeof(abs));
899 abs[0].value = ABS_X;
900 abs[0].maximum = 1000;
901 abs[1].value = ABS_MT_POSITION_X;
902 abs[1].maximum = 1000;
904 abs[2].value = ABS_Y;
905 abs[2].maximum = 1000;
906 abs[3].value = ABS_MT_POSITION_Y;
907 abs[3].maximum = 1000;
909 abs[4].value = ABS_MT_SLOT;
912 rc = test_create_abs_device(&uidev, &dev,
916 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
918 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
919 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_TOUCH_MINOR), 0);
921 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_TOUCH_MINOR, &value), 0);
922 ck_assert_int_eq(value, 0xab);
924 ck_assert_int_eq(libevdev_get_slot_value(dev, 10, ABS_MT_POSITION_X), 0);
925 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_X), 0);
927 uinput_device_free(uidev);
932 START_TEST(test_event_value_setters)
934 struct uinput_device* uidev;
935 struct libevdev *dev;
937 struct input_absinfo abs[2];
939 memset(abs, 0, sizeof(abs));
940 abs[0].value = ABS_X;
941 abs[0].maximum = 1000;
943 abs[1].value = ABS_Y;
944 abs[1].maximum = 1000;
946 rc = test_create_abs_device(&uidev, &dev,
957 EV_SW, SW_TABLET_MODE,
959 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
961 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
962 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
963 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
964 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
965 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
967 ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_LEFT, 1), 0);
968 ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_RIGHT, 1), 0);
970 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
971 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT), 1);
973 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_X, 10), 0);
974 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Y, 20), 0);
976 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 10);
977 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 20);
979 ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_NUML, 1), 0);
980 ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_CAPSL, 1), 0);
982 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
983 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
985 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_LID, 1), 0);
986 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_TABLET_MODE, 1), 0);
988 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
989 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_TABLET_MODE), 1);
991 uinput_device_free(uidev);
997 START_TEST(test_event_value_setters_invalid)
999 struct uinput_device* uidev;
1000 struct libevdev *dev;
1002 struct input_absinfo abs[2];
1004 memset(abs, 0, sizeof(abs));
1005 abs[0].value = ABS_X;
1006 abs[0].maximum = 1000;
1008 abs[1].value = ABS_Y;
1009 abs[1].maximum = 1000;
1011 rc = test_create_abs_device(&uidev, &dev,
1020 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1022 ck_assert_int_eq(libevdev_set_event_value(dev, EV_REL, REL_X, 1), -1);
1023 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_DOCK, 1), -1);
1024 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Z, 1), -1);
1025 ck_assert_int_eq(libevdev_set_event_value(dev, EV_MAX + 1, 0, 1), -1);
1026 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SYN, SYN_REPORT, 0), -1);
1028 uinput_device_free(uidev);
1034 START_TEST(test_event_mt_value_setters)
1036 struct uinput_device* uidev;
1037 struct libevdev *dev;
1039 struct input_absinfo abs[5];
1041 memset(abs, 0, sizeof(abs));
1042 abs[0].value = ABS_X;
1043 abs[0].maximum = 1000;
1044 abs[1].value = ABS_MT_POSITION_X;
1045 abs[1].maximum = 1000;
1047 abs[2].value = ABS_Y;
1048 abs[2].maximum = 1000;
1049 abs[3].value = ABS_MT_POSITION_Y;
1050 abs[3].maximum = 1000;
1052 abs[4].value = ABS_MT_SLOT;
1055 rc = test_create_abs_device(&uidev, &dev,
1059 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1061 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_X, 1), 0);
1062 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_Y, 2), 0);
1063 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
1064 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_Y, 4), 0);
1066 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
1067 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 2);
1068 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 3);
1069 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 4);
1071 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_SLOT, 1), 0);
1072 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_SLOT), 1);
1073 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1075 uinput_device_free(uidev);
1080 START_TEST(test_event_mt_value_setters_invalid)
1082 struct uinput_device* uidev;
1083 struct libevdev *dev;
1085 struct input_absinfo abs[5];
1087 memset(abs, 0, sizeof(abs));
1088 abs[0].value = ABS_X;
1089 abs[0].maximum = 1000;
1090 abs[1].value = ABS_MT_POSITION_X;
1091 abs[1].maximum = 1000;
1093 abs[2].value = ABS_Y;
1094 abs[2].maximum = 1000;
1095 abs[3].value = ABS_MT_POSITION_Y;
1096 abs[3].maximum = 1000;
1098 abs[4].value = ABS_MT_SLOT;
1101 rc = test_create_abs_device(&uidev, &dev,
1105 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1108 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_Z, 1), -1);
1109 /* valid, but non-mt axis */
1110 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_X, 1), -1);
1111 /* invalid mt axis */
1112 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_PRESSURE, 1), -1);
1113 /* invalid slot no */
1114 ck_assert_int_eq(libevdev_set_slot_value(dev, 4, ABS_X, 1), -1);
1116 uinput_device_free(uidev);
1121 START_TEST(test_event_mt_value_setters_current_slot)
1123 struct uinput_device* uidev;
1124 struct libevdev *dev;
1126 struct input_absinfo abs[5];
1128 memset(abs, 0, sizeof(abs));
1129 abs[0].value = ABS_X;
1130 abs[0].maximum = 1000;
1131 abs[1].value = ABS_MT_POSITION_X;
1132 abs[1].maximum = 1000;
1134 abs[2].value = ABS_Y;
1135 abs[2].maximum = 1000;
1136 abs[3].value = ABS_MT_POSITION_Y;
1137 abs[3].maximum = 1000;
1139 abs[4].value = ABS_MT_SLOT;
1142 rc = test_create_abs_device(&uidev, &dev,
1146 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
1148 /* set_event_value/get_event_value works on the current slot */
1150 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1151 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 1), 0);
1152 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 1);
1153 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 1);
1155 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
1156 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1157 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 2), 0);
1158 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
1159 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 2);
1161 /* set slot 0, but current is still slot 1 */
1162 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
1163 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
1165 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 0), 0);
1166 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1167 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 3);
1169 uinput_device_free(uidev);
1175 libevdev_events(void)
1177 Suite *s = suite_create("libevdev event tests");
1179 TCase *tc = tcase_create("event polling");
1180 tcase_add_test(tc, test_next_event);
1181 tcase_add_test(tc, test_syn_event);
1182 tcase_add_test(tc, test_event_type_filtered);
1183 tcase_add_test(tc, test_event_code_filtered);
1184 tcase_add_test(tc, test_has_event_pending);
1185 suite_add_tcase(s, tc);
1187 tc = tcase_create("SYN_DROPPED deltas");
1188 tcase_add_test(tc, test_syn_delta_button);
1189 tcase_add_test(tc, test_syn_delta_abs);
1190 tcase_add_test(tc, test_syn_delta_mt);
1191 tcase_add_test(tc, test_syn_delta_led);
1192 tcase_add_test(tc, test_syn_delta_sw);
1193 suite_add_tcase(s, tc);
1195 tc = tcase_create("skipped syncs");
1196 tcase_add_test(tc, test_skipped_sync);
1197 tcase_add_test(tc, test_incomplete_sync);
1198 tcase_add_test(tc, test_empty_sync);
1199 suite_add_tcase(s, tc);
1201 tc = tcase_create("event values");
1202 tcase_add_test(tc, test_event_values);
1203 tcase_add_test(tc, test_event_values_invalid);
1204 tcase_add_test(tc, test_mt_event_values);
1205 tcase_add_test(tc, test_mt_event_values_invalid);
1206 suite_add_tcase(s, tc);
1208 tc = tcase_create("event value setters");
1209 tcase_add_test(tc, test_event_value_setters);
1210 tcase_add_test(tc, test_event_value_setters_invalid);
1211 tcase_add_test(tc, test_event_mt_value_setters);
1212 tcase_add_test(tc, test_event_mt_value_setters_invalid);
1213 tcase_add_test(tc, test_event_mt_value_setters_current_slot);
1214 suite_add_tcase(s, tc);