1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright © 2013 Red Hat, Inc.
4 */
5
6 #include "config.h"
7 #include <linux/input.h>
8 #include <errno.h>
9 #include <unistd.h>
10 #include <fcntl.h>
11 #include <stdio.h>
12 #include <libevdev/libevdev-util.h>
13
14 #include "test-common.h"
15
START_TEST(test_next_event)16 START_TEST(test_next_event)
17 {
18 struct uinput_device* uidev;
19 struct libevdev *dev;
20 int rc;
21 struct input_event ev;
22
23 test_create_device(&uidev, &dev,
24 EV_REL, REL_X,
25 EV_REL, REL_Y,
26 EV_KEY, BTN_LEFT,
27 -1);
28
29 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
30 ck_assert_int_eq(rc, -EAGAIN);
31
32 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
33 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
34 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
35 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
36 assert_event(&ev, EV_KEY, BTN_LEFT, 1);
37
38 libevdev_free(dev);
39 uinput_device_free(uidev);
40
41 }
42 END_TEST
43
START_TEST(test_next_event_invalid_fd)44 START_TEST(test_next_event_invalid_fd)
45 {
46 struct uinput_device* uidev;
47 struct libevdev *dev;
48 int rc;
49 struct input_event ev;
50
51 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
52
53 dev = libevdev_new();
54 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
55 ck_assert_int_eq(rc, -EBADF);
56 libevdev_free(dev);
57
58 test_create_device(&uidev, &dev,
59 EV_REL, REL_X,
60 EV_REL, REL_Y,
61 EV_KEY, BTN_LEFT,
62 -1);
63
64 /* invalid (missing) flag */
65 rc = libevdev_next_event(dev, 0x10, &ev);
66 ck_assert_int_eq(rc, -EINVAL);
67
68 /* set an invalid fd */
69 rc = libevdev_change_fd(dev, -3);
70 ck_assert_int_eq(rc, 0);
71 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
72 ck_assert_int_eq(rc, -EBADF);
73
74 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
75
76 libevdev_free(dev);
77 uinput_device_free(uidev);
78 }
79 END_TEST
80
START_TEST(test_next_event_blocking)81 START_TEST(test_next_event_blocking)
82 {
83 struct uinput_device* uidev;
84 struct libevdev *dev;
85 int fd, flags;
86 int rc;
87 struct input_event ev;
88
89 test_create_device(&uidev, &dev,
90 EV_REL, REL_X,
91 EV_REL, REL_Y,
92 EV_KEY, BTN_LEFT,
93 -1);
94
95 fd = libevdev_get_fd(dev);
96 flags = fcntl(fd, F_GETFL) & ~O_NONBLOCK;
97 rc = fcntl(fd, F_SETFL, flags);
98 ck_assert_int_eq(rc, 0);
99
100 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
101 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
102 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_BLOCKING, &ev);
103 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
104 assert_event(&ev, EV_KEY, BTN_LEFT, 1);
105
106 libevdev_free(dev);
107 uinput_device_free(uidev);
108 }
109 END_TEST
110
START_TEST(test_syn_dropped_event)111 START_TEST(test_syn_dropped_event)
112 {
113 struct uinput_device* uidev;
114 struct libevdev *dev;
115 int rc;
116 struct input_event ev;
117 int pipefd[2];
118
119 test_create_device(&uidev, &dev,
120 EV_SYN, SYN_REPORT,
121 EV_SYN, SYN_DROPPED,
122 EV_REL, REL_X,
123 EV_REL, REL_Y,
124 EV_KEY, BTN_LEFT,
125 -1);
126
127 /* This is a bit complicated:
128 we can't get SYN_DROPPED through uinput, so we push two events down
129 uinput, and process those. Then write a SYN_DROPPED on a pipe,
130 switch the fd and read one event off the wire. Switch back, so
131 that when we do read off the SYN_DROPPED we have the fd back on
132 the device and the ioctls work.
133 */
134 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
135 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
136 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
137 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
138 assert_event(&ev, EV_KEY, BTN_LEFT, 1);
139
140 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
141 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
142 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
143
144 rc = pipe2(pipefd, O_NONBLOCK);
145 ck_assert_int_eq(rc, 0);
146
147 libevdev_change_fd(dev, pipefd[0]);
148 ev.type = EV_SYN;
149 ev.code = SYN_DROPPED;
150 ev.value = 0;
151 rc = write(pipefd[1], &ev, sizeof(ev));
152 ck_assert_int_eq(rc, sizeof(ev));
153
154 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
155 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
156 assert_event(&ev, EV_SYN, SYN_DROPPED, 0);
157
158 libevdev_change_fd(dev, uinput_device_get_fd(uidev));
159 /* only check for the rc, nothing actually changed on the device */
160
161 libevdev_free(dev);
162 uinput_device_free(uidev);
163
164 close(pipefd[0]);
165 close(pipefd[1]);
166
167 }
168 END_TEST
169
START_TEST(test_event_type_filtered)170 START_TEST(test_event_type_filtered)
171 {
172 struct uinput_device* uidev;
173 struct libevdev *dev;
174 int rc;
175 struct input_event ev;
176
177 test_create_device(&uidev, &dev,
178 EV_REL, REL_X,
179 EV_REL, REL_Y,
180 EV_KEY, BTN_LEFT,
181 -1);
182
183 libevdev_disable_event_type(dev, EV_REL);
184
185 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
186 ck_assert_int_eq(rc, -EAGAIN);
187
188 uinput_device_event(uidev, EV_REL, REL_X, 1);
189 uinput_device_event(uidev, EV_KEY, REL_Y, 1);
190 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
191 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
192 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
193 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
194
195 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
196 ck_assert_int_eq(rc, -EAGAIN);
197
198 libevdev_free(dev);
199 uinput_device_free(uidev);
200
201 }
202 END_TEST
203
START_TEST(test_event_code_filtered)204 START_TEST(test_event_code_filtered)
205 {
206 struct uinput_device* uidev;
207 struct libevdev *dev;
208 int rc;
209 struct input_event ev;
210
211 test_create_device(&uidev, &dev,
212 EV_REL, REL_X,
213 EV_REL, REL_Y,
214 EV_KEY, BTN_LEFT,
215 -1);
216
217 libevdev_disable_event_code(dev, EV_REL, REL_X);
218
219 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
220 ck_assert_int_eq(rc, -EAGAIN);
221
222 uinput_device_event(uidev, EV_REL, REL_X, 1);
223 uinput_device_event(uidev, EV_REL, REL_Y, 1);
224 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
225 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
226 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
227 assert_event(&ev, EV_REL, REL_Y, 1);
228
229 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
230 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
231 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
232
233 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
234 ck_assert_int_eq(rc, -EAGAIN);
235
236 libevdev_free(dev);
237 uinput_device_free(uidev);
238
239 }
240 END_TEST
241
START_TEST(test_has_event_pending)242 START_TEST(test_has_event_pending)
243 {
244 struct uinput_device* uidev;
245 struct libevdev *dev;
246 int rc;
247 struct input_event ev;
248
249 test_create_device(&uidev, &dev,
250 EV_REL, REL_X,
251 EV_REL, REL_Y,
252 EV_KEY, BTN_LEFT,
253 -1);
254
255 ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
256
257 uinput_device_event(uidev, EV_REL, REL_X, 1);
258 uinput_device_event(uidev, EV_REL, REL_Y, 1);
259 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
260
261 ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
262
263 libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
264
265 ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
266
267 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN)
268 ;
269
270 ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
271
272 libevdev_change_fd(dev, -1);
273 ck_assert_int_eq(libevdev_has_event_pending(dev), -EBADF);
274
275 libevdev_free(dev);
276 uinput_device_free(uidev);
277
278 }
279 END_TEST
280
START_TEST(test_has_event_pending_invalid_fd)281 START_TEST(test_has_event_pending_invalid_fd)
282 {
283 struct libevdev *dev;
284 int rc;
285
286 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
287
288 dev = libevdev_new();
289 rc = libevdev_has_event_pending(dev);
290 ck_assert_int_eq(rc, -EBADF);
291
292 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
293
294 libevdev_free(dev);
295 }
296 END_TEST
297
START_TEST(test_syn_delta_button)298 START_TEST(test_syn_delta_button)
299 {
300 struct uinput_device* uidev;
301 struct libevdev *dev;
302 int rc;
303 struct input_event ev;
304
305 test_create_device(&uidev, &dev,
306 EV_SYN, SYN_REPORT,
307 EV_SYN, SYN_DROPPED,
308 EV_REL, REL_X,
309 EV_REL, REL_Y,
310 EV_KEY, BTN_LEFT,
311 EV_KEY, BTN_MIDDLE,
312 EV_KEY, BTN_RIGHT,
313 EV_KEY, KEY_MAX,
314 -1);
315
316 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
317 uinput_device_event(uidev, EV_KEY, BTN_RIGHT, 1);
318 uinput_device_event(uidev, EV_KEY, KEY_MAX, 1);
319 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
320 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
321 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
322
323 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
324 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
325 assert_event(&ev, EV_KEY, BTN_LEFT, 1);
326 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
327 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
328 assert_event(&ev, EV_KEY, BTN_RIGHT, 1);
329 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
330 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
331 assert_event(&ev, EV_KEY, KEY_MAX, 1);
332 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
333 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
334 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
335 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
336 ck_assert_int_eq(rc, -EAGAIN);
337
338 ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT));
339 ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT));
340 ck_assert(!libevdev_get_event_value(dev, EV_KEY, BTN_MIDDLE));
341 ck_assert(libevdev_get_event_value(dev, EV_KEY, KEY_MAX));
342
343 uinput_device_free(uidev);
344 libevdev_free(dev);
345 }
346 END_TEST
347
START_TEST(test_syn_delta_abs)348 START_TEST(test_syn_delta_abs)
349 {
350 struct uinput_device* uidev;
351 struct libevdev *dev;
352 int rc;
353 struct input_event ev;
354 struct input_absinfo abs[3] = {
355 { .value = ABS_X, .maximum = 1000 },
356 { .value = ABS_Y, .maximum = 1000 },
357 { .value = ABS_MAX, .maximum = 1000 },
358 };
359
360 test_create_abs_device(&uidev, &dev,
361 ARRAY_LENGTH(abs), abs,
362 EV_SYN, SYN_REPORT,
363 EV_SYN, SYN_DROPPED,
364 EV_KEY, BTN_LEFT,
365 EV_KEY, BTN_MIDDLE,
366 EV_KEY, BTN_RIGHT,
367 -1);
368
369 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
370 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
371 uinput_device_event(uidev, EV_ABS, ABS_MAX, 700);
372 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
373 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
374 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
375
376 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
377 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
378 assert_event(&ev, EV_ABS, ABS_X, 100);
379 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
380 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
381 assert_event(&ev, EV_ABS, ABS_Y, 500);
382 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
383 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
384 ck_assert_int_eq(ev.type, EV_ABS);
385 ck_assert_int_eq(ev.code, ABS_MAX);
386 ck_assert_int_eq(ev.value, 700);
387 assert_event(&ev, EV_ABS, ABS_MAX, 700);
388 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
389 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
390 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
391 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
392 ck_assert_int_eq(rc, -EAGAIN);
393
394 uinput_device_free(uidev);
395 libevdev_free(dev);
396 }
397 END_TEST
398
START_TEST(test_syn_delta_mt)399 START_TEST(test_syn_delta_mt)
400 {
401 struct uinput_device* uidev;
402 struct libevdev *dev;
403 int rc;
404 struct input_event ev;
405 struct input_absinfo abs[6] = {
406 { .value = ABS_X, .maximum = 1000 },
407 { .value = ABS_Y, .maximum = 1000 },
408 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
409 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
410 { .value = ABS_MT_SLOT, .maximum = 1 },
411 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 2 },
412 };
413
414 test_create_abs_device(&uidev, &dev,
415 ARRAY_LENGTH(abs), abs,
416 EV_SYN, SYN_REPORT,
417 -1);
418
419 uinput_device_event_multiple(uidev,
420 EV_ABS, ABS_MT_SLOT, 0,
421 EV_ABS, ABS_X, 100,
422 EV_ABS, ABS_Y, 500,
423 EV_ABS, ABS_MT_POSITION_X, 100,
424 EV_ABS, ABS_MT_POSITION_Y, 500,
425 EV_ABS, ABS_MT_TRACKING_ID, 1,
426 EV_ABS, ABS_MT_SLOT, 1,
427 EV_ABS, ABS_X, 1,
428 EV_ABS, ABS_Y, 5,
429 EV_ABS, ABS_MT_POSITION_X, 1,
430 EV_ABS, ABS_MT_POSITION_Y, 5,
431 EV_ABS, ABS_MT_TRACKING_ID, 2,
432 EV_SYN, SYN_REPORT, 0,
433 -1, -1);
434
435 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
436 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
437
438 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
439 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
440 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
441 assert_event(&ev, EV_ABS, ABS_X, 1);
442 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
443 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
444 assert_event(&ev, EV_ABS, ABS_Y, 5);
445 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
446 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
447 assert_event(&ev, EV_ABS, ABS_MT_SLOT, 0);
448 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
449 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
450 assert_event(&ev, EV_ABS, ABS_MT_POSITION_X, 100);
451 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
452 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
453 assert_event(&ev, EV_ABS, ABS_MT_POSITION_Y, 500);
454 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
455 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
456 assert_event(&ev, EV_ABS, ABS_MT_TRACKING_ID, 1);
457 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
458 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
459 assert_event(&ev, EV_ABS, ABS_MT_SLOT, 1);
460 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
461
462 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
463 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
464 assert_event(&ev, EV_ABS, ABS_MT_POSITION_X, 1);
465 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
466 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
467 assert_event(&ev, EV_ABS, ABS_MT_POSITION_Y, 5);
468 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
469 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
470 assert_event(&ev, EV_ABS, ABS_MT_TRACKING_ID, 2);
471
472 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
473 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
474 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
475 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
476 ck_assert_int_eq(rc, -EAGAIN);
477
478 uinput_device_free(uidev);
479 libevdev_free(dev);
480 }
481 END_TEST
482
START_TEST(test_syn_delta_mt_reset_slot)483 START_TEST(test_syn_delta_mt_reset_slot)
484 {
485 struct uinput_device* uidev;
486 struct libevdev *dev;
487 int rc;
488 struct input_event ev,
489 last_slot_event = { .type = 0};
490 struct input_absinfo abs[6] = {
491 { .value = ABS_X, .maximum = 1000 },
492 { .value = ABS_Y, .maximum = 1000 },
493 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
494 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
495 { .value = ABS_MT_SLOT, .maximum = 1 },
496 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 2 },
497 };
498
499 test_create_abs_device(&uidev, &dev,
500 ARRAY_LENGTH(abs), abs,
501 EV_SYN, SYN_REPORT,
502 -1);
503
504 uinput_device_event_multiple(uidev,
505 EV_ABS, ABS_MT_SLOT, 1,
506 EV_ABS, ABS_MT_POSITION_X, 100,
507 EV_ABS, ABS_MT_POSITION_Y, 500,
508 EV_ABS, ABS_MT_TRACKING_ID, 1,
509 EV_ABS, ABS_MT_SLOT, 0,
510 EV_ABS, ABS_MT_POSITION_X, 1,
511 EV_ABS, ABS_MT_POSITION_Y, 5,
512 EV_ABS, ABS_MT_TRACKING_ID, 2,
513 EV_SYN, SYN_REPORT, 0,
514 -1, -1);
515
516 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
517 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
518
519 do {
520 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
521 if (libevdev_event_is_code(&ev, EV_ABS, ABS_MT_SLOT))
522 last_slot_event = ev;
523 } while (rc != -EAGAIN);
524
525 ck_assert(libevdev_event_is_code(&last_slot_event, EV_ABS, ABS_MT_SLOT));
526 ck_assert_int_eq(last_slot_event.value, 0);
527 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
528
529 last_slot_event.type = 0;
530
531 /* same thing again, this time swap the numbers */
532 uinput_device_event_multiple(uidev,
533 EV_ABS, ABS_MT_SLOT, 0,
534 EV_ABS, ABS_MT_POSITION_X, 100,
535 EV_ABS, ABS_MT_POSITION_Y, 500,
536 EV_ABS, ABS_MT_TRACKING_ID, 1,
537 EV_ABS, ABS_MT_SLOT, 1,
538 EV_ABS, ABS_MT_POSITION_X, 1,
539 EV_ABS, ABS_MT_POSITION_Y, 5,
540 EV_ABS, ABS_MT_TRACKING_ID, 2,
541 EV_SYN, SYN_REPORT, 0,
542 -1, -1);
543
544 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
545 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
546
547 do {
548 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
549 if (libevdev_event_is_code(&ev, EV_ABS, ABS_MT_SLOT))
550 last_slot_event = ev;
551 } while (rc != -EAGAIN);
552
553 ck_assert(libevdev_event_is_code(&last_slot_event, EV_ABS, ABS_MT_SLOT));
554 ck_assert_int_eq(last_slot_event.value, 1);
555 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
556
557 uinput_device_free(uidev);
558 libevdev_free(dev);
559 }
560 END_TEST
561
START_TEST(test_syn_delta_led)562 START_TEST(test_syn_delta_led)
563 {
564 struct uinput_device* uidev;
565 struct libevdev *dev;
566 int rc;
567 struct input_event ev;
568
569 test_create_device(&uidev, &dev,
570 EV_SYN, SYN_REPORT,
571 EV_SYN, SYN_DROPPED,
572 EV_LED, LED_NUML,
573 EV_LED, LED_CAPSL,
574 EV_LED, LED_MAX,
575 -1);
576
577 uinput_device_event(uidev, EV_LED, LED_NUML, 1);
578 uinput_device_event(uidev, EV_LED, LED_CAPSL, 1);
579 uinput_device_event(uidev, EV_LED, LED_MAX, 1);
580 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
581 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
582 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
583
584 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
585 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
586 assert_event(&ev, EV_LED, LED_NUML, 1);
587 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
588 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
589 assert_event(&ev, EV_LED, LED_CAPSL, 1);
590 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
591 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
592 assert_event(&ev, EV_LED, LED_MAX, 1);
593 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
594 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
595 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
596 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
597 ck_assert_int_eq(rc, -EAGAIN);
598
599 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
600 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
601 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_MAX), 1);
602
603 uinput_device_free(uidev);
604 libevdev_free(dev);
605 }
606 END_TEST
607
START_TEST(test_syn_delta_sw)608 START_TEST(test_syn_delta_sw)
609 {
610 struct uinput_device* uidev;
611 struct libevdev *dev;
612 int rc;
613 struct input_event ev;
614
615 test_create_device(&uidev, &dev,
616 EV_SYN, SYN_REPORT,
617 EV_SYN, SYN_DROPPED,
618 EV_SW, SW_HEADPHONE_INSERT,
619 EV_SW, SW_MICROPHONE_INSERT,
620 EV_SW, SW_MAX,
621 -1);
622
623 uinput_device_event(uidev, EV_SW, SW_HEADPHONE_INSERT, 1);
624 uinput_device_event(uidev, EV_SW, SW_MICROPHONE_INSERT, 1);
625 uinput_device_event(uidev, EV_SW, SW_MAX, 1);
626 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
627 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
628 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
629
630 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
631 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
632 assert_event(&ev, EV_SW, SW_HEADPHONE_INSERT, 1);
633 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
634 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
635 assert_event(&ev, EV_SW, SW_MICROPHONE_INSERT, 1);
636 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
637 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
638 assert_event(&ev, EV_SW, SW_MAX, 1);
639 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
640 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
641 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
642 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
643 ck_assert_int_eq(rc, -EAGAIN);
644
645 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_HEADPHONE_INSERT), 1);
646 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MICROPHONE_INSERT), 1);
647 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MAX), 1);
648
649 uinput_device_free(uidev);
650 libevdev_free(dev);
651 }
652 END_TEST
653
START_TEST(test_syn_delta_tracking_ids)654 START_TEST(test_syn_delta_tracking_ids)
655 {
656 struct uinput_device* uidev;
657 struct libevdev *dev;
658 int rc;
659 struct input_event ev;
660 int i;
661 const int num_slots = 15;
662 int slot = -1;
663 unsigned long terminated[NLONGS(num_slots)];
664 unsigned long restarted[NLONGS(num_slots)];
665 struct input_absinfo abs[6] = {
666 { .value = ABS_X, .maximum = 1000 },
667 { .value = ABS_Y, .maximum = 1000 },
668 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
669 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
670 { .value = ABS_MT_SLOT, .maximum = num_slots },
671 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 0xff },
672 };
673
674 test_create_abs_device(&uidev, &dev,
675 ARRAY_LENGTH(abs), abs,
676 EV_SYN, SYN_REPORT,
677 -1);
678
679 /* Test the sync process to make sure we get touches terminated when
680 * the tracking id changes:
681 * 1) start a bunch of touch points
682 * 2) read data into libevdev, make sure state is up-to-date
683 * 3) change touchpoints
684 * 3.1) change the tracking ID on some (indicating terminated and
685 * re-started touchpoint)
686 * 3.2) change the tracking ID to -1 on some (indicating termianted
687 * touchpoint)
688 * 3.3) just update the data on others
689 * 4) force a sync on the device
690 * 5) make sure we get the right tracking ID changes in the caller
691 */
692
693 /* Start a bunch of touch points */
694 for (i = num_slots; i >= 0; i--) {
695 uinput_device_event_multiple(uidev,
696 EV_ABS, ABS_MT_SLOT, i,
697 EV_ABS, ABS_MT_TRACKING_ID, i,
698 EV_ABS, ABS_X, 100 + i,
699 EV_ABS, ABS_Y, 500 + i,
700 EV_ABS, ABS_MT_POSITION_X, 100 + i,
701 EV_ABS, ABS_MT_POSITION_Y, 500 + i,
702 EV_SYN, SYN_REPORT, 0,
703 -1, -1);
704 do {
705 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
706 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
707 } while (rc >= 0);
708 }
709
710 /* we have a bunch of touches now, and libevdev knows it. Change all
711 * touches */
712 for (i = num_slots; i >= 0; i--) {
713 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, i);
714 if (i % 3 == 0) {
715 /* change some slots with a new tracking id */
716 uinput_device_event_multiple(uidev,
717 EV_ABS, ABS_MT_TRACKING_ID, num_slots + i,
718 EV_ABS, ABS_X, 200 + i,
719 EV_ABS, ABS_Y, 700 + i,
720 EV_ABS, ABS_MT_POSITION_X, 200 + i,
721 EV_ABS, ABS_MT_POSITION_Y, 700 + i,
722 -1, -1);
723 } else if (i % 3 == 1) {
724 /* stop others */
725 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, -1);
726 } else {
727 /* just update */
728 uinput_device_event_multiple(uidev,
729 EV_ABS, ABS_X, 200 + i,
730 EV_ABS, ABS_Y, 700 + i,
731 EV_ABS, ABS_MT_POSITION_X, 200 + i,
732 EV_ABS, ABS_MT_POSITION_Y, 700 + i,
733 -1, -1);
734 }
735 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
736 }
737
738 /* Force sync */
739 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
740 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
741
742 /* now check for the right tracking IDs */
743 memset(terminated, 0, sizeof(terminated));
744 memset(restarted, 0, sizeof(restarted));
745 slot = -1;
746 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev)) != -EAGAIN) {
747 if (libevdev_event_is_code(&ev, EV_SYN, SYN_REPORT))
748 continue;
749
750 if (libevdev_event_is_code(&ev, EV_ABS, ABS_MT_SLOT)) {
751 slot = ev.value;
752 continue;
753 }
754
755 if (libevdev_event_is_code(&ev, EV_ABS, ABS_X) ||
756 libevdev_event_is_code(&ev, EV_ABS, ABS_Y))
757 continue;
758
759 ck_assert_int_ne(slot, -1);
760
761 if (libevdev_event_is_code(&ev, EV_ABS, ABS_MT_TRACKING_ID)) {
762 if (slot % 3 == 0) {
763 if (!bit_is_set(terminated, slot)) {
764 ck_assert_int_eq(ev.value, -1);
765 set_bit(terminated, slot);
766 } else {
767 ck_assert_int_eq(ev.value, num_slots + slot);
768 set_bit(restarted, slot);
769 }
770 } else if (slot % 3 == 1) {
771 ck_assert(!bit_is_set(terminated, slot));
772 ck_assert_int_eq(ev.value, -1);
773 set_bit(terminated, slot);
774 } else
775 ck_abort();
776
777 continue;
778 }
779
780 switch(ev.code) {
781 case ABS_MT_POSITION_X:
782 ck_assert_int_eq(ev.value, 200 + slot);
783 break;
784 case ABS_MT_POSITION_Y:
785 ck_assert_int_eq(ev.value, 700 + slot);
786 break;
787 default:
788 ck_abort();
789 }
790 }
791
792 for (i = 0; i < num_slots; i++) {
793 if (i % 3 == 0) {
794 ck_assert(bit_is_set(terminated, i));
795 ck_assert(bit_is_set(restarted, i));
796 } else if (i % 3 == 1) {
797 ck_assert(bit_is_set(terminated, i));
798 ck_assert(!bit_is_set(restarted, i));
799 } else {
800 ck_assert(!bit_is_set(terminated, i));
801 ck_assert(!bit_is_set(restarted, i));
802 }
803 }
804
805 uinput_device_free(uidev);
806 libevdev_free(dev);
807 }
808 END_TEST
809
START_TEST(test_syn_delta_tracking_ids_btntool)810 START_TEST(test_syn_delta_tracking_ids_btntool)
811 {
812 struct uinput_device* uidev;
813 struct libevdev *dev;
814 int rc;
815 struct input_event ev;
816 const int num_slots = 5;
817 struct input_absinfo abs[6] = {
818 { .value = ABS_X, .maximum = 1000 },
819 { .value = ABS_Y, .maximum = 1000 },
820 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
821 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
822 { .value = ABS_MT_SLOT, .maximum = num_slots },
823 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 0xffff },
824 };
825 bool have_doubletap = false,
826 have_quadtap = false,
827 have_quinttap = false;
828
829 test_create_abs_device(&uidev, &dev,
830 ARRAY_LENGTH(abs), abs,
831 EV_KEY, BTN_TOOL_FINGER,
832 EV_KEY, BTN_TOOL_DOUBLETAP,
833 EV_KEY, BTN_TOOL_TRIPLETAP,
834 EV_KEY, BTN_TOOL_QUADTAP,
835 EV_KEY, BTN_TOOL_QUINTTAP,
836 EV_SYN, SYN_REPORT,
837 -1);
838
839 /* Test the sync process to make sure we get the BTN_TOOL bits for
840 * touches adjusted correctly when the tracking id changes:
841 * 1) start a bunch of touch points
842 * 2) read data into libevdev, make sure state is up-to-date
843 * 3) change touchpoints
844 * 3.1) change the tracking ID on some (indicating terminated and
845 * re-started touchpoint)
846 * 3.2) change the tracking ID to -1 on some (indicating termianted
847 * touchpoint)
848 * 3.3) just update the data on others
849 * 4) force a sync on the device
850 * 5) make sure we get the right BTN_TOOL_ changes in the caller
851 */
852 for (int i = 0; i < num_slots; i++) {
853 uinput_device_event_multiple(uidev,
854 EV_ABS, ABS_MT_SLOT, i,
855 EV_ABS, ABS_MT_TRACKING_ID, 111,
856 EV_ABS, ABS_X, 100 + 10 * i,
857 EV_ABS, ABS_Y, 100 + 10 * i,
858 EV_ABS, ABS_MT_POSITION_X, 100,
859 EV_ABS, ABS_MT_POSITION_Y, 100,
860 -1, -1);
861 switch (i) {
862 case 0:
863 uinput_device_event(uidev, EV_KEY, BTN_TOOL_FINGER, 1);
864 break;
865 case 1:
866 uinput_device_event(uidev, EV_KEY, BTN_TOOL_FINGER, 0);
867 uinput_device_event(uidev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
868 break;
869 case 2:
870 uinput_device_event(uidev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
871 uinput_device_event(uidev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
872 break;
873 case 3:
874 uinput_device_event(uidev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
875 uinput_device_event(uidev, EV_KEY, BTN_TOOL_QUADTAP, 1);
876 break;
877 case 4:
878 uinput_device_event(uidev, EV_KEY, BTN_TOOL_QUADTAP, 0);
879 uinput_device_event(uidev, EV_KEY, BTN_TOOL_QUINTTAP, 1);
880 break;
881 default:
882 ck_abort();
883 }
884 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
885 }
886
887 do {
888 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
889 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
890 } while (rc >= 0);
891
892 /* we have a bunch of touches now, and libevdev knows it.
893 * - stop touch 0
894 * - stop and restart touch 1 and 4
895 * - leave 2, 3 unchanged
896 */
897 uinput_device_event_multiple(uidev,
898 EV_ABS, ABS_MT_SLOT, 0,
899 EV_ABS, ABS_MT_TRACKING_ID, -1,
900 EV_KEY, BTN_TOOL_QUINTTAP, 0,
901 EV_KEY, BTN_TOOL_QUADTAP, 1,
902 EV_SYN, SYN_REPORT, 0,
903 -1, -1);
904 uinput_device_event_multiple(uidev,
905 EV_ABS, ABS_MT_SLOT, 1,
906 EV_ABS, ABS_MT_TRACKING_ID, -1,
907 EV_KEY, BTN_TOOL_QUADTAP, 0,
908 EV_KEY, BTN_TOOL_TRIPLETAP, 1,
909 EV_SYN, SYN_REPORT, 0,
910 -1, -1);
911 uinput_device_event_multiple(uidev,
912 EV_ABS, ABS_MT_SLOT, 1,
913 EV_ABS, ABS_MT_TRACKING_ID, 666,
914 EV_ABS, ABS_X, 666,
915 EV_ABS, ABS_Y, 666,
916 EV_ABS, ABS_MT_POSITION_X, 666,
917 EV_ABS, ABS_MT_POSITION_Y, 666,
918 EV_KEY, BTN_TOOL_TRIPLETAP, 0,
919 EV_KEY, BTN_TOOL_QUADTAP, 1,
920 EV_SYN, SYN_REPORT, 0,
921 -1, -1);
922 uinput_device_event_multiple(uidev,
923 EV_ABS, ABS_MT_SLOT, 4,
924 EV_ABS, ABS_MT_TRACKING_ID, -1,
925 EV_KEY, BTN_TOOL_QUADTAP, 0,
926 EV_KEY, BTN_TOOL_TRIPLETAP, 1,
927 EV_SYN, SYN_REPORT, 0,
928 -1, -1);
929 uinput_device_event_multiple(uidev,
930 EV_ABS, ABS_MT_SLOT, 4,
931 EV_ABS, ABS_MT_TRACKING_ID, 777,
932 EV_ABS, ABS_X, 777,
933 EV_ABS, ABS_Y, 777,
934 EV_ABS, ABS_MT_POSITION_X, 777,
935 EV_ABS, ABS_MT_POSITION_Y, 777,
936 EV_KEY, BTN_TOOL_QUADTAP, 1,
937 EV_KEY, BTN_TOOL_TRIPLETAP, 0,
938 EV_SYN, SYN_REPORT, 0,
939 -1, -1);
940
941 /* Force sync */
942 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
943 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
944
945 /* In the first sync frame, we expect us to drop to 2 touches - we
946 * started with 5, 1 stopped, 2 stopped+restarted */
947 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev)) != -EAGAIN) {
948 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_QUINTTAP)) {
949 ck_assert(!have_quinttap);
950 assert_event(&ev, EV_KEY, BTN_TOOL_QUINTTAP, 0);
951 have_quinttap = true;
952 }
953
954 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_TRIPLETAP))
955 ck_abort();
956
957 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_DOUBLETAP)) {
958 ck_assert(!have_doubletap);
959 assert_event(&ev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
960 have_doubletap = true;
961 }
962
963 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_TRIPLETAP));
964 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_QUADTAP));
965 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_FINGER));
966
967 if (libevdev_event_is_code(&ev, EV_SYN, SYN_REPORT)) {
968 ck_assert(have_doubletap);
969 ck_assert(have_quinttap);
970 break;
971 }
972 }
973
974 have_doubletap = false;
975 have_quadtap = false;
976
977 /* In the second sync frame, we expect to go back to 4 touches,
978 * recovering the two stopped+started touches */
979 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev)) != -EAGAIN) {
980 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_QUADTAP)) {
981 ck_assert(!have_quadtap);
982 assert_event(&ev, EV_KEY, BTN_TOOL_QUADTAP, 1);
983 have_quadtap = true;
984 }
985
986 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_TRIPLETAP))
987 ck_abort();
988
989 if (libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_DOUBLETAP)) {
990 ck_assert(!have_doubletap);
991 assert_event(&ev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
992 have_doubletap = true;
993 }
994
995 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_TRIPLETAP));
996 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_QUINTTAP));
997 ck_assert(!libevdev_event_is_code(&ev, EV_KEY, BTN_TOOL_FINGER));
998
999 if (libevdev_event_is_code(&ev, EV_SYN, SYN_REPORT)) {
1000 ck_assert(have_doubletap);
1001 ck_assert(have_quadtap);
1002 break;
1003 }
1004 }
1005
1006 uinput_device_free(uidev);
1007 libevdev_free(dev);
1008 }
1009 END_TEST
1010
START_TEST(test_syn_delta_late_sync)1011 START_TEST(test_syn_delta_late_sync)
1012 {
1013 struct uinput_device* uidev;
1014 struct libevdev *dev;
1015 int rc;
1016 struct input_event ev;
1017 struct input_absinfo abs[6] = {
1018 { .value = ABS_X, .maximum = 1000 },
1019 { .value = ABS_Y, .maximum = 1000 },
1020 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1021 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1022 { .value = ABS_MT_SLOT, .maximum = 1 },
1023 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 0xff},
1024 };
1025 int i, slot;
1026
1027 test_create_abs_device(&uidev, &dev,
1028 ARRAY_LENGTH(abs), abs,
1029 EV_SYN, SYN_REPORT,
1030 -1);
1031
1032 /* emulate a touch down, make sure libevdev sees it */
1033 uinput_device_event_multiple(uidev,
1034 EV_ABS, ABS_MT_SLOT, 0,
1035 EV_ABS, ABS_MT_TRACKING_ID, 1,
1036 EV_ABS, ABS_X, 100,
1037 EV_ABS, ABS_Y, 500,
1038 EV_ABS, ABS_MT_POSITION_X, 100,
1039 EV_ABS, ABS_MT_POSITION_Y, 500,
1040 EV_SYN, SYN_REPORT, 0,
1041 -1, -1);
1042 do {
1043 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1044 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
1045 } while (rc >= 0);
1046
1047 /* force enough events to trigger a SYN_DROPPED */
1048 for (i = 0; i < 100; i++) {
1049 uinput_device_event_multiple(uidev,
1050 EV_ABS, ABS_X, 100 + i,
1051 EV_ABS, ABS_Y, 500 + i,
1052 EV_ABS, ABS_MT_POSITION_X, 100 + i,
1053 EV_ABS, ABS_MT_POSITION_Y, 500 + i,
1054 EV_SYN, SYN_REPORT, 0,
1055 -1, -1);
1056 }
1057
1058 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1059 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1060
1061 /* trigger the tracking ID change after getting the SYN_DROPPED */
1062 uinput_device_event_multiple(uidev,
1063 EV_ABS, ABS_MT_SLOT, 0,
1064 EV_ABS, ABS_MT_TRACKING_ID, -1,
1065 EV_ABS, ABS_X, 200,
1066 EV_ABS, ABS_Y, 600,
1067 EV_ABS, ABS_MT_POSITION_X, 200,
1068 EV_ABS, ABS_MT_POSITION_Y, 600,
1069 EV_SYN, SYN_REPORT, 0,
1070 -1, -1);
1071
1072 slot = 0;
1073
1074 /* Now sync the device, expect the data to be equal to the last event*/
1075 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev)) != -EAGAIN) {
1076 if (ev.type == EV_SYN)
1077 continue;
1078
1079 ck_assert_int_eq(ev.type, EV_ABS);
1080 switch(ev.code) {
1081 case ABS_MT_SLOT:
1082 slot = ev.value;
1083 break;
1084 case ABS_MT_TRACKING_ID:
1085 if (slot == 0)
1086 ck_assert_int_eq(ev.value, -1);
1087 break;
1088 case ABS_X:
1089 case ABS_MT_POSITION_X:
1090 ck_assert_int_eq(ev.value, 200);
1091 break;
1092 case ABS_Y:
1093 case ABS_MT_POSITION_Y:
1094 ck_assert_int_eq(ev.value, 600);
1095 break;
1096 }
1097 }
1098
1099 /* And a new tracking ID */
1100 uinput_device_event_multiple(uidev,
1101 EV_ABS, ABS_MT_SLOT, 0,
1102 EV_ABS, ABS_MT_TRACKING_ID, 2,
1103 EV_ABS, ABS_X, 201,
1104 EV_ABS, ABS_Y, 601,
1105 EV_ABS, ABS_MT_POSITION_X, 201,
1106 EV_ABS, ABS_MT_POSITION_Y, 601,
1107 EV_SYN, SYN_REPORT, 0,
1108 -1, -1);
1109
1110 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN) {
1111 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
1112
1113 if (ev.type == EV_SYN)
1114 continue;
1115
1116 ck_assert_int_eq(ev.type, EV_ABS);
1117
1118 switch(ev.code) {
1119 case ABS_MT_SLOT:
1120 ck_assert_int_eq(ev.value, 0);
1121 break;
1122 case ABS_MT_TRACKING_ID:
1123 ck_assert_int_eq(ev.value, 2);
1124 break;
1125 case ABS_X:
1126 case ABS_MT_POSITION_X:
1127 ck_assert_int_eq(ev.value, 201);
1128 break;
1129 case ABS_Y:
1130 case ABS_MT_POSITION_Y:
1131 ck_assert_int_eq(ev.value, 601);
1132 break;
1133 }
1134 }
1135
1136 /* Now we basically re-do the exact same test, just with the
1137 tracking ID order inverted */
1138
1139 /* drop the tracking ID, make sure libevdev sees it */
1140 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
1141 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1142 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1143 do {
1144 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1145 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
1146 } while (rc >= 0);
1147
1148 /* force enough events to trigger a SYN_DROPPED */
1149 for (i = 0; i < 100; i++) {
1150 uinput_device_event_multiple(uidev,
1151 EV_ABS, ABS_X, 100 + i,
1152 EV_ABS, ABS_Y, 500 + i,
1153 EV_ABS, ABS_MT_POSITION_X, 100 + i,
1154 EV_ABS, ABS_MT_POSITION_Y, 500 + i,
1155 EV_SYN, SYN_REPORT, 0,
1156 -1, -1);
1157 }
1158
1159 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1160 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1161
1162 /* trigger the new tracking ID after getting the SYN_DROPPED */
1163 uinput_device_event_multiple(uidev,
1164 EV_ABS, ABS_MT_SLOT, 0,
1165 EV_ABS, ABS_MT_TRACKING_ID, 5,
1166 EV_ABS, ABS_X, 200,
1167 EV_ABS, ABS_Y, 600,
1168 EV_ABS, ABS_MT_POSITION_X, 200,
1169 EV_ABS, ABS_MT_POSITION_Y, 600,
1170 EV_SYN, SYN_REPORT, 0,
1171 -1, -1);
1172
1173 slot = 0;
1174
1175 /* Now sync the device, expect the data to be equal to the last event*/
1176 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev)) != -EAGAIN) {
1177 if (ev.type == EV_SYN)
1178 continue;
1179
1180 ck_assert_int_eq(ev.type, EV_ABS);
1181 switch(ev.code) {
1182 case ABS_MT_SLOT:
1183 slot = ev.value;
1184 break;
1185 case ABS_MT_TRACKING_ID:
1186 if (slot == 0)
1187 ck_assert_int_eq(ev.value, 5);
1188 break;
1189 case ABS_X:
1190 case ABS_MT_POSITION_X:
1191 ck_assert_int_eq(ev.value, 200);
1192 break;
1193 case ABS_Y:
1194 case ABS_MT_POSITION_Y:
1195 ck_assert_int_eq(ev.value, 600);
1196 break;
1197 }
1198 }
1199
1200 /* Drop the tracking ID */
1201 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
1202 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1203 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1204
1205 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN) {
1206 ck_assert_int_ne(rc, LIBEVDEV_READ_STATUS_SYNC);
1207
1208 if (ev.type == EV_SYN)
1209 continue;
1210
1211 ck_assert_int_eq(ev.type, EV_ABS);
1212
1213 switch(ev.code) {
1214 case ABS_MT_SLOT:
1215 ck_assert_int_eq(ev.value, 0);
1216 break;
1217 case ABS_MT_TRACKING_ID:
1218 ck_assert_int_eq(ev.value, -1);
1219 break;
1220 }
1221 }
1222
1223 uinput_device_free(uidev);
1224 libevdev_free(dev);
1225 }
1226 END_TEST
1227
START_TEST(test_syn_delta_fake_mt)1228 START_TEST(test_syn_delta_fake_mt)
1229 {
1230 struct uinput_device* uidev;
1231 struct libevdev *dev;
1232 int rc;
1233 struct input_event ev;
1234 struct input_absinfo abs[] = {
1235 { .value = ABS_X, .minimum = 0, .maximum = 1000 },
1236 { .value = ABS_Y, .minimum = 0, .maximum = 1000 },
1237 { .value = ABS_MT_POSITION_X, .minimum = 0, .maximum = 1000 },
1238 { .value = ABS_MT_POSITION_Y, .minimum = 0, .maximum = 1000 },
1239 { .value = ABS_MT_SLOT - 1, .minimum = 0, .maximum = 2 }};
1240 /* don't set ABS_MT_SLOT here, otherwise uinput will init
1241 * slots and the behavior is different to real devices with
1242 * such events */
1243 unsigned long received[NLONGS(ABS_CNT)] = {0};
1244
1245 test_create_abs_device(&uidev, &dev, ARRAY_LENGTH(abs), abs, -1);
1246 /* first set of events */
1247 uinput_device_event_multiple(uidev,
1248 EV_ABS, ABS_X, 200,
1249 EV_ABS, ABS_Y, 400,
1250 EV_ABS, ABS_MT_POSITION_X, 100,
1251 EV_ABS, ABS_MT_POSITION_Y, 500,
1252 EV_ABS, ABS_MT_SLOT - 1, 1,
1253 EV_SYN, SYN_REPORT, 0,
1254 -1, -1);
1255
1256 /* second set of events */
1257 uinput_device_event_multiple(uidev,
1258 EV_ABS, ABS_X, 201,
1259 EV_ABS, ABS_Y, 401,
1260 EV_ABS, ABS_MT_POSITION_X, 101,
1261 EV_ABS, ABS_MT_POSITION_Y, 501,
1262 EV_ABS, ABS_MT_SLOT - 1, 2,
1263 EV_SYN, SYN_REPORT, 0,
1264 -1, -1);
1265
1266 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
1267 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1268
1269 while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_STATUS_SYNC, &ev)) != -EAGAIN) {
1270 if (ev.type != EV_ABS)
1271 continue;
1272
1273 ck_assert(!bit_is_set(received, ev.code));
1274
1275 switch(ev.code) {
1276 /* see comment below for ABS_MT_POSITION_X
1277 * and ABS_MT_POSITION_Y */
1278 case ABS_MT_POSITION_X:
1279 case ABS_MT_POSITION_Y:
1280 ck_abort();
1281 break;
1282
1283 case ABS_MT_SLOT - 1: ck_assert_int_eq(ev.value, 2); break;
1284 case ABS_X: ck_assert_int_eq(ev.value, 201); break;
1285 case ABS_Y: ck_assert_int_eq(ev.value, 401); break;
1286 default:
1287 ck_abort();
1288 }
1289
1290 set_bit(received, ev.code);
1291 }
1292
1293 /* Dont' expect ABS_MT values, they are ignored during the sync
1294 * process */
1295 ck_assert(!bit_is_set(received, ABS_MT_POSITION_X));
1296 ck_assert(!bit_is_set(received, ABS_MT_POSITION_Y));
1297 ck_assert(bit_is_set(received, ABS_MT_SLOT - 1));
1298 ck_assert(bit_is_set(received, ABS_X));
1299 ck_assert(bit_is_set(received, ABS_Y));
1300
1301 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 201);
1302 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 401);
1303 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_SLOT - 1), 2);
1304
1305 uinput_device_free(uidev);
1306 libevdev_free(dev);
1307 }
1308 END_TEST
1309
START_TEST(test_skipped_sync)1310 START_TEST(test_skipped_sync)
1311 {
1312 struct uinput_device* uidev;
1313 struct libevdev *dev;
1314 int rc;
1315 struct input_event ev;
1316 struct input_absinfo abs[2] = {
1317 { .value = ABS_X, .maximum = 1000 },
1318 { .value = ABS_Y, .maximum = 1000 },
1319 };
1320
1321 test_create_abs_device(&uidev, &dev,
1322 ARRAY_LENGTH(abs), abs,
1323 EV_SYN, SYN_REPORT,
1324 EV_SYN, SYN_DROPPED,
1325 EV_KEY, BTN_LEFT,
1326 EV_KEY, BTN_MIDDLE,
1327 EV_KEY, BTN_RIGHT,
1328 -1);
1329
1330 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
1331 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
1332 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
1333 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1334 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
1335 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1336
1337 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1338 ck_assert_int_eq(rc, -EAGAIN);
1339
1340 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
1341 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
1342 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
1343
1344 uinput_device_free(uidev);
1345 libevdev_free(dev);
1346 }
1347 END_TEST
1348
START_TEST(test_incomplete_sync)1349 START_TEST(test_incomplete_sync)
1350 {
1351 struct uinput_device* uidev;
1352 struct libevdev *dev;
1353 int rc;
1354 struct input_event ev;
1355 struct input_absinfo abs[2] = {
1356 { .value = ABS_X, .maximum = 1000 },
1357 { .value = ABS_Y, .maximum = 1000 },
1358 };
1359
1360 test_create_abs_device(&uidev, &dev,
1361 ARRAY_LENGTH(abs), abs,
1362 EV_SYN, SYN_REPORT,
1363 EV_SYN, SYN_DROPPED,
1364 EV_KEY, BTN_LEFT,
1365 EV_KEY, BTN_MIDDLE,
1366 EV_KEY, BTN_RIGHT,
1367 -1);
1368
1369 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
1370 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
1371 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
1372 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1373 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
1374 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1375
1376 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
1377 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1378 assert_event(&ev, EV_KEY, BTN_LEFT, 1);
1379
1380 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1381 ck_assert_int_eq(rc, -EAGAIN);
1382
1383 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
1384 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
1385 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
1386
1387 uinput_device_free(uidev);
1388 libevdev_free(dev);
1389 }
1390 END_TEST
1391
START_TEST(test_empty_sync)1392 START_TEST(test_empty_sync)
1393 {
1394 struct uinput_device* uidev;
1395 struct libevdev *dev;
1396 int rc;
1397 struct input_event ev;
1398
1399 test_create_device(&uidev, &dev,
1400 EV_SYN, SYN_REPORT,
1401 EV_SYN, SYN_DROPPED,
1402 EV_KEY, BTN_LEFT,
1403 EV_KEY, BTN_MIDDLE,
1404 EV_KEY, BTN_RIGHT,
1405 -1);
1406
1407 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
1408 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
1409
1410 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
1411 ck_assert_int_eq(rc, -EAGAIN);
1412
1413 uinput_device_free(uidev);
1414 libevdev_free(dev);
1415 }
1416 END_TEST
1417
START_TEST(test_event_values)1418 START_TEST(test_event_values)
1419 {
1420 struct uinput_device* uidev;
1421 struct libevdev *dev;
1422 int rc;
1423 struct input_event ev;
1424 struct input_absinfo abs[2] = {
1425 { .value = ABS_X, .maximum = 1000 },
1426 { .value = ABS_Y, .maximum = 1000 },
1427 };
1428 int value;
1429
1430 test_create_abs_device(&uidev, &dev,
1431 ARRAY_LENGTH(abs), abs,
1432 EV_SYN, SYN_REPORT,
1433 EV_SYN, SYN_DROPPED,
1434 EV_REL, REL_X,
1435 EV_REL, REL_Y,
1436 EV_KEY, BTN_LEFT,
1437 EV_KEY, BTN_MIDDLE,
1438 EV_KEY, BTN_RIGHT,
1439 -1);
1440
1441 uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
1442 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
1443 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
1444 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1445
1446 /* must still be on old values */
1447 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
1448 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
1449 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
1450 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
1451 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
1452
1453 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
1454 ck_assert_int_eq(value, 0);
1455
1456 do {
1457 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1458 } while (rc == 0);
1459 ck_assert_int_eq(rc, -EAGAIN);
1460
1461 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
1462 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
1463 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
1464
1465 /* always 0 */
1466 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
1467 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
1468
1469 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_LEFT, &value), 1);
1470 ck_assert_int_eq(value, 1);
1471 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_X, &value), 1);
1472 ck_assert_int_eq(value, 100);
1473 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Y, &value), 1);
1474 ck_assert_int_eq(value, 500);
1475
1476 uinput_device_free(uidev);
1477 libevdev_free(dev);
1478
1479 }
1480 END_TEST
1481
START_TEST(test_event_values_invalid)1482 START_TEST(test_event_values_invalid)
1483 {
1484 struct uinput_device* uidev;
1485 struct libevdev *dev;
1486 struct input_absinfo abs[2] = {
1487 { .value = ABS_X, .maximum = 1000 },
1488 { .value = ABS_Y, .maximum = 1000 },
1489 };
1490 int value;
1491
1492 test_create_abs_device(&uidev, &dev,
1493 ARRAY_LENGTH(abs), abs,
1494 EV_SYN, SYN_REPORT,
1495 EV_SYN, SYN_DROPPED,
1496 EV_REL, REL_X,
1497 EV_REL, REL_Y,
1498 EV_KEY, BTN_LEFT,
1499 EV_KEY, BTN_MIDDLE,
1500 EV_KEY, BTN_RIGHT,
1501 -1);
1502
1503 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_EXTRA), 0);
1504 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Z), 0);
1505 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Z), 0);
1506
1507 value = 0xab;
1508 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_EXTRA, &value), 0);
1509 ck_assert_int_eq(value, 0xab);
1510 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Z, &value), 0);
1511 ck_assert_int_eq(value, 0xab);
1512 ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_REL, REL_Z, &value), 0);
1513 ck_assert_int_eq(value, 0xab);
1514
1515 uinput_device_free(uidev);
1516 libevdev_free(dev);
1517
1518 }
1519 END_TEST
1520
START_TEST(test_mt_event_values)1521 START_TEST(test_mt_event_values)
1522 {
1523 struct uinput_device* uidev;
1524 struct libevdev *dev;
1525 int rc;
1526 struct input_event ev;
1527 struct input_absinfo abs[5] = {
1528 { .value = ABS_X, .maximum = 1000 },
1529 { .value = ABS_Y, .maximum = 1000 },
1530 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1531 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1532 { .value = ABS_MT_SLOT, .maximum = 2 },
1533 };
1534 int value;
1535 test_create_abs_device(&uidev, &dev,
1536 ARRAY_LENGTH(abs), abs,
1537 EV_SYN, SYN_REPORT,
1538 -1);
1539
1540 uinput_device_event_multiple(uidev,
1541 EV_ABS, ABS_MT_SLOT, 0,
1542 EV_ABS, ABS_X, 100,
1543 EV_ABS, ABS_Y, 500,
1544 EV_ABS, ABS_MT_POSITION_X, 100,
1545 EV_ABS, ABS_MT_POSITION_Y, 500,
1546 EV_ABS, ABS_MT_SLOT, 1,
1547 EV_ABS, ABS_X, 1,
1548 EV_ABS, ABS_Y, 5,
1549 EV_ABS, ABS_MT_POSITION_X, 1,
1550 EV_ABS, ABS_MT_POSITION_Y, 5,
1551 EV_SYN, SYN_REPORT, 0,
1552 -1, -1);
1553
1554 /* must still be on old values */
1555 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1556 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 0);
1557 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 0);
1558 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 0);
1559 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 0);
1560
1561 do {
1562 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1563 } while (rc == LIBEVDEV_READ_STATUS_SUCCESS);
1564 ck_assert_int_eq(rc, -EAGAIN);
1565
1566 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1567 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
1568 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
1569 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
1570 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
1571
1572 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 1);
1573 ck_assert_int_eq(value, 100);
1574 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_Y, &value), 1);
1575 ck_assert_int_eq(value, 500);
1576 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_X, &value), 1);
1577 ck_assert_int_eq(value, 1);
1578 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 1, ABS_MT_POSITION_Y, &value), 1);
1579 ck_assert_int_eq(value, 5);
1580
1581 uinput_device_free(uidev);
1582 libevdev_free(dev);
1583
1584 }
1585 END_TEST
1586
START_TEST(test_mt_event_values_invalid)1587 START_TEST(test_mt_event_values_invalid)
1588 {
1589 struct uinput_device* uidev;
1590 struct libevdev *dev;
1591 struct input_absinfo abs[5] = {
1592 { .value = ABS_X, .maximum = 1000 },
1593 { .value = ABS_Y, .maximum = 1000 },
1594 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1595 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1596 { .value = ABS_MT_SLOT, .maximum = 2 },
1597 };
1598 int value;
1599
1600 test_create_abs_device(&uidev, &dev,
1601 ARRAY_LENGTH(abs), abs,
1602 EV_SYN, SYN_REPORT,
1603 -1);
1604
1605 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
1606 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_TOUCH_MINOR), 0);
1607 value = 0xab;
1608 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_TOUCH_MINOR, &value), 0);
1609 ck_assert_int_eq(value, 0xab);
1610
1611 ck_assert_int_eq(libevdev_get_slot_value(dev, 10, ABS_MT_POSITION_X), 0);
1612 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_X), 0);
1613
1614 uinput_device_free(uidev);
1615 libevdev_free(dev);
1616 }
1617 END_TEST
1618
START_TEST(test_mt_slot_ranges_invalid)1619 START_TEST(test_mt_slot_ranges_invalid)
1620 {
1621 struct uinput_device* uidev;
1622 struct libevdev *dev;
1623 struct input_event ev[2];
1624 int rc;
1625 int num_slots = 2;
1626 struct input_absinfo abs[5] = {
1627 { .value = ABS_X, .maximum = 1000 },
1628 { .value = ABS_Y, .maximum = 1000 },
1629 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1630 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1631 { .value = ABS_MT_SLOT, .maximum = num_slots - 1 },
1632 };
1633 int pipefd[2];
1634
1635 test_create_abs_device(&uidev, &dev,
1636 ARRAY_LENGTH(abs), abs,
1637 EV_SYN, SYN_REPORT,
1638 -1);
1639
1640 rc = pipe2(pipefd, O_NONBLOCK);
1641 ck_assert_int_eq(rc, 0);
1642 libevdev_change_fd(dev, pipefd[0]);
1643
1644 memset(ev, 0, sizeof(ev));
1645 ev[0].type = EV_ABS;
1646 ev[0].code = ABS_MT_SLOT;
1647 ev[0].value = num_slots;
1648 ev[1].type = EV_SYN;
1649 ev[1].code = SYN_REPORT;
1650 ev[1].value = 0;
1651 rc = write(pipefd[1], ev, sizeof(ev));
1652 ck_assert_int_eq(rc, sizeof(ev));
1653
1654 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
1655
1656 libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, ev);
1657 ck_assert(libevdev_event_is_code(ev, EV_ABS, ABS_MT_SLOT));
1658 ck_assert_int_eq(ev[0].value, num_slots - 1);
1659
1660 /* drain the EV_SYN */
1661 libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, ev);
1662
1663 ev[0].type = EV_ABS;
1664 ev[0].code = ABS_MT_SLOT;
1665 ev[0].value = -1;
1666 ev[1].type = EV_SYN;
1667 ev[1].code = SYN_REPORT;
1668 ev[1].value = 0;
1669 rc = write(pipefd[1], ev, sizeof(ev));
1670 ck_assert_int_eq(rc, sizeof(ev));
1671
1672 libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, ev);
1673 ck_assert(libevdev_event_is_code(ev, EV_ABS, ABS_MT_SLOT));
1674 ck_assert_int_eq(ev[0].value, num_slots - 1);
1675
1676 ck_assert_int_eq(libevdev_get_current_slot(dev), num_slots - 1);
1677
1678 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, num_slots), -1);
1679 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, -1), -1);
1680
1681 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
1682
1683 uinput_device_free(uidev);
1684 libevdev_free(dev);
1685 }
1686 END_TEST
1687
START_TEST(test_mt_tracking_id_discard)1688 START_TEST(test_mt_tracking_id_discard)
1689 {
1690 struct uinput_device* uidev;
1691 struct libevdev *dev;
1692 int rc;
1693 struct input_event ev;
1694 struct input_absinfo abs[6] = {
1695 { .value = ABS_X, .maximum = 1000 },
1696 { .value = ABS_Y, .maximum = 1000 },
1697 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1698 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1699 { .value = ABS_MT_SLOT, .maximum = 10 },
1700 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 500 },
1701 };
1702
1703 test_create_abs_device(&uidev, &dev,
1704 ARRAY_LENGTH(abs), abs,
1705 EV_SYN, SYN_REPORT,
1706 -1);
1707
1708 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
1709 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
1710 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1711
1712 /* second tracking ID on same slot */
1713 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
1714 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1715
1716 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
1717
1718 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1719 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1720 assert_event(&ev, EV_ABS, ABS_MT_SLOT, 1);
1721
1722 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1723 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1724 assert_event(&ev, EV_ABS, ABS_MT_TRACKING_ID, 1);
1725
1726 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1727 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1728 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
1729
1730 /* expect tracking ID discarded */
1731
1732 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1733 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1734 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
1735
1736 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1737 ck_assert_int_eq(rc, -EAGAIN);
1738
1739 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
1740
1741 uinput_device_free(uidev);
1742 libevdev_free(dev);
1743 }
1744 END_TEST
1745
START_TEST(test_mt_tracking_id_discard_neg_1)1746 START_TEST(test_mt_tracking_id_discard_neg_1)
1747 {
1748 struct uinput_device* uidev;
1749 struct libevdev *dev;
1750 int rc;
1751 struct input_event ev;
1752 struct input_absinfo abs[6] = {
1753 { .value = ABS_X, .maximum = 1000 },
1754 { .value = ABS_Y, .maximum = 1000 },
1755 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1756 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1757 { .value = ABS_MT_SLOT, .maximum = 10 },
1758 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 500 },
1759 };
1760 int pipefd[2];
1761 struct input_event events[] = {
1762 { .type = EV_ABS, .code = ABS_MT_TRACKING_ID, .value = -1 },
1763 { .type = EV_SYN, .code = SYN_REPORT, .value = 0 },
1764 };
1765
1766 rc = pipe2(pipefd, O_NONBLOCK);
1767 ck_assert_int_eq(rc, 0);
1768
1769 test_create_abs_device(&uidev, &dev,
1770 ARRAY_LENGTH(abs), abs,
1771 EV_SYN, SYN_REPORT,
1772 -1);
1773 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
1774 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
1775 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
1776
1777 while (libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev) != -EAGAIN)
1778 ;
1779
1780 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
1781
1782 /* two -1 tracking ids, need to use the pipe here, the kernel will
1783 filter it otherwise */
1784 libevdev_change_fd(dev, pipefd[0]);
1785
1786 rc = write(pipefd[1], events, sizeof(events));
1787 ck_assert_int_eq(rc, sizeof(events));
1788 rc = write(pipefd[1], events, sizeof(events));
1789 ck_assert_int_eq(rc, sizeof(events));
1790
1791 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1792 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1793 assert_event(&ev, EV_ABS, ABS_MT_TRACKING_ID, -1);
1794 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1795 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1796 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
1797
1798 /* expect second tracking ID discarded */
1799
1800 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1801 ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
1802 assert_event(&ev, EV_SYN, SYN_REPORT, 0);
1803
1804 rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
1805 ck_assert_int_eq(rc, -EAGAIN);
1806
1807 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
1808
1809 uinput_device_free(uidev);
1810 libevdev_free(dev);
1811 }
1812 END_TEST
1813
START_TEST(test_ev_rep_values)1814 START_TEST(test_ev_rep_values)
1815 {
1816 struct uinput_device* uidev;
1817 struct libevdev *dev;
1818 int delay = 500, period = 200;
1819 test_create_device(&uidev, &dev,
1820 EV_KEY, BTN_LEFT,
1821 EV_REL, REL_X,
1822 EV_REL, REL_Y,
1823 EV_SYN, SYN_REPORT,
1824 -1);
1825
1826 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
1827 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
1828
1829 ck_assert_int_eq(libevdev_has_event_type(dev, EV_REP), 1);
1830 ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_DELAY), 1);
1831 ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_PERIOD), 1);
1832 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_DELAY), 500);
1833 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REP, REP_PERIOD), 200);
1834
1835 uinput_device_free(uidev);
1836 libevdev_free(dev);
1837 }
1838 END_TEST
1839
START_TEST(test_event_value_setters)1840 START_TEST(test_event_value_setters)
1841 {
1842 struct uinput_device* uidev;
1843 struct libevdev *dev;
1844 struct input_absinfo abs[2] = {
1845 { .value = ABS_X, .maximum = 1000 },
1846 { .value = ABS_Y, .maximum = 1000 },
1847 };
1848
1849 test_create_abs_device(&uidev, &dev,
1850 ARRAY_LENGTH(abs), abs,
1851 EV_SYN, SYN_REPORT,
1852 EV_REL, REL_X,
1853 EV_REL, REL_Y,
1854 EV_KEY, BTN_LEFT,
1855 EV_KEY, BTN_MIDDLE,
1856 EV_KEY, BTN_RIGHT,
1857 EV_LED, LED_NUML,
1858 EV_LED, LED_CAPSL,
1859 EV_SW, SW_HEADPHONE_INSERT,
1860 EV_SW, SW_TABLET_MODE,
1861 -1);
1862
1863 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
1864 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
1865 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
1866 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
1867 ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
1868
1869 ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_LEFT, 1), 0);
1870 ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_RIGHT, 1), 0);
1871
1872 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
1873 ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT), 1);
1874
1875 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_X, 10), 0);
1876 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Y, 20), 0);
1877
1878 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 10);
1879 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 20);
1880
1881 ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_NUML, 1), 0);
1882 ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_CAPSL, 1), 0);
1883
1884 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
1885 ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
1886
1887 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_HEADPHONE_INSERT, 1), 0);
1888 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_TABLET_MODE, 1), 0);
1889
1890 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_HEADPHONE_INSERT), 1);
1891 ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_TABLET_MODE), 1);
1892
1893 uinput_device_free(uidev);
1894 libevdev_free(dev);
1895
1896 }
1897 END_TEST
1898
START_TEST(test_event_value_setters_invalid)1899 START_TEST(test_event_value_setters_invalid)
1900 {
1901 struct uinput_device* uidev;
1902 struct libevdev *dev;
1903 struct input_absinfo abs[2] = {
1904 { .value = ABS_X, .maximum = 1000 },
1905 { .value = ABS_Y, .maximum = 1000 },
1906 };
1907
1908 test_create_abs_device(&uidev, &dev,
1909 ARRAY_LENGTH(abs), abs,
1910 EV_SYN, SYN_REPORT,
1911 EV_REL, REL_X,
1912 EV_REL, REL_Y,
1913 EV_KEY, BTN_LEFT,
1914 EV_KEY, BTN_MIDDLE,
1915 EV_KEY, BTN_RIGHT,
1916 -1);
1917
1918 ck_assert_int_eq(libevdev_set_event_value(dev, EV_REL, REL_X, 1), -1);
1919 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_DOCK, 1), -1);
1920 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Z, 1), -1);
1921 ck_assert_int_eq(libevdev_set_event_value(dev, EV_MAX + 1, 0, 1), -1);
1922 ck_assert_int_eq(libevdev_set_event_value(dev, EV_SYN, SYN_REPORT, 0), -1);
1923
1924 uinput_device_free(uidev);
1925 libevdev_free(dev);
1926
1927 }
1928 END_TEST
1929
START_TEST(test_event_mt_value_setters)1930 START_TEST(test_event_mt_value_setters)
1931 {
1932 struct uinput_device* uidev;
1933 struct libevdev *dev;
1934 struct input_absinfo abs[5] = {
1935 { .value = ABS_X, .maximum = 1000 },
1936 { .value = ABS_Y, .maximum = 1000 },
1937 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1938 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1939 { .value = ABS_MT_SLOT, .maximum = 2 },
1940 };
1941
1942 test_create_abs_device(&uidev, &dev,
1943 ARRAY_LENGTH(abs), abs,
1944 EV_SYN, SYN_REPORT,
1945 -1);
1946
1947 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_X, 1), 0);
1948 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_POSITION_Y, 2), 0);
1949 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
1950 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_Y, 4), 0);
1951
1952 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
1953 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 2);
1954 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 3);
1955 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 4);
1956
1957 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_SLOT, 1), 0);
1958 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_SLOT), 1);
1959 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
1960
1961 uinput_device_free(uidev);
1962 libevdev_free(dev);
1963 }
1964 END_TEST
1965
START_TEST(test_event_mt_value_setters_invalid)1966 START_TEST(test_event_mt_value_setters_invalid)
1967 {
1968 struct uinput_device* uidev;
1969 struct libevdev *dev;
1970 struct input_absinfo abs[5] = {
1971 { .value = ABS_X, .maximum = 1000 },
1972 { .value = ABS_Y, .maximum = 1000 },
1973 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
1974 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
1975 { .value = ABS_MT_SLOT, .maximum = 2 },
1976 };
1977
1978 test_create_abs_device(&uidev, &dev,
1979 ARRAY_LENGTH(abs), abs,
1980 EV_SYN, SYN_REPORT,
1981 -1);
1982
1983 /* invalid axis */
1984 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_Z, 1), -1);
1985 /* valid, but non-mt axis */
1986 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_X, 1), -1);
1987 /* invalid mt axis */
1988 ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_PRESSURE, 1), -1);
1989 /* invalid slot no */
1990 ck_assert_int_eq(libevdev_set_slot_value(dev, 4, ABS_X, 1), -1);
1991
1992 uinput_device_free(uidev);
1993 libevdev_free(dev);
1994 }
1995 END_TEST
1996
START_TEST(test_event_mt_value_setters_current_slot)1997 START_TEST(test_event_mt_value_setters_current_slot)
1998 {
1999 struct uinput_device* uidev;
2000 struct libevdev *dev;
2001 struct input_absinfo abs[5] = {
2002 { .value = ABS_X, .maximum = 1000 },
2003 { .value = ABS_Y, .maximum = 1000 },
2004 { .value = ABS_MT_POSITION_X, .maximum = 1000 },
2005 { .value = ABS_MT_POSITION_Y, .maximum = 1000 },
2006 { .value = ABS_MT_SLOT, .maximum = 2 },
2007 };
2008
2009 test_create_abs_device(&uidev, &dev,
2010 ARRAY_LENGTH(abs), abs,
2011 EV_SYN, SYN_REPORT,
2012 -1);
2013
2014 /* set_event_value/get_event_value works on the current slot */
2015
2016 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
2017 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 1), 0);
2018 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 1);
2019 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 1);
2020
2021 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
2022 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
2023 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 2), 0);
2024 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
2025 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 2);
2026
2027 /* set slot 0, but current is still slot 1 */
2028 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
2029 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
2030
2031 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 0), 0);
2032 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
2033 ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 3);
2034
2035 uinput_device_free(uidev);
2036 libevdev_free(dev);
2037 }
2038 END_TEST
2039
TEST_SUITE_ROOT_PRIVILEGES(libevdev_events)2040 TEST_SUITE_ROOT_PRIVILEGES(libevdev_events)
2041 {
2042 Suite *s = suite_create("libevdev event tests");
2043
2044 add_test(s, test_next_event);
2045 add_test(s, test_next_event_invalid_fd);
2046 add_test(s, test_next_event_blocking);
2047 add_test(s, test_syn_dropped_event);
2048 add_test(s, test_event_type_filtered);
2049 add_test(s, test_event_code_filtered);
2050 add_test(s, test_has_event_pending);
2051 add_test(s, test_has_event_pending_invalid_fd);
2052
2053 add_test(s, test_syn_delta_button);
2054 add_test(s, test_syn_delta_abs);
2055 add_test(s, test_syn_delta_mt);
2056 add_test(s, test_syn_delta_mt_reset_slot);
2057 add_test(s, test_syn_delta_led);
2058 add_test(s, test_syn_delta_sw);
2059 add_test(s, test_syn_delta_fake_mt);
2060 add_test(s, test_syn_delta_late_sync);
2061 add_test(s, test_syn_delta_tracking_ids);
2062 add_test(s, test_syn_delta_tracking_ids_btntool);
2063
2064 add_test(s, test_skipped_sync);
2065 add_test(s, test_incomplete_sync);
2066 add_test(s, test_empty_sync);
2067
2068 add_test(s, test_event_values);
2069 add_test(s, test_event_values_invalid);
2070 add_test(s, test_mt_event_values);
2071 add_test(s, test_mt_event_values_invalid);
2072 add_test(s, test_mt_slot_ranges_invalid);
2073 add_test(s, test_mt_tracking_id_discard);
2074 add_test(s, test_mt_tracking_id_discard_neg_1);
2075 add_test(s, test_ev_rep_values);
2076
2077 add_test(s, test_event_value_setters);
2078 add_test(s, test_event_value_setters_invalid);
2079 add_test(s, test_event_mt_value_setters);
2080 add_test(s, test_event_mt_value_setters_invalid);
2081 add_test(s, test_event_mt_value_setters_current_slot);
2082
2083 return s;
2084 }
2085