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 <limits.h>
11 #include <fcntl.h>
12
13 #include "test-common.h"
14
15 static int evbits[] = {
16 EV_SYN, EV_KEY, EV_REL, EV_ABS, EV_MSC,
17 EV_SW, EV_LED, EV_SND, EV_FF,
18 /* Intentionally skipping these, they're different
19 * EV_PWR, EV_FF_STATUS, EV_REP, */
20 -1,
21 };
22
START_TEST(test_has_ev_bit)23 START_TEST(test_has_ev_bit)
24 {
25 int *evbit = evbits;
26
27 while(*evbit != -1) {
28 struct uinput_device* uidev;
29 struct libevdev *dev;
30 int i;
31
32 if (*evbit == EV_ABS) {
33 struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
34 test_create_abs_device(&uidev, &dev,
35 1, &abs,
36 -1);
37 } else
38 test_create_device(&uidev, &dev,
39 *evbit, 0,
40 -1);
41
42 ck_assert_msg(libevdev_has_event_type(dev, EV_SYN), "for event type %d\n", *evbit);
43 ck_assert_msg(libevdev_has_event_type(dev, *evbit), "for event type %d\n", *evbit);
44
45 for (i = 0; i <= EV_MAX; i++) {
46 if (i == EV_SYN || i == *evbit)
47 continue;
48
49 ck_assert_msg(!libevdev_has_event_type(dev, i), "for event type %d\n", i);
50 }
51
52 libevdev_free(dev);
53 uinput_device_free(uidev);
54
55 evbit++;
56 }
57 }
58 END_TEST
59
START_TEST(test_ev_bit_limits)60 START_TEST(test_ev_bit_limits)
61 {
62 int *evbit = evbits;
63
64 while(*evbit != -1) {
65 struct uinput_device* uidev;
66 struct libevdev *dev;
67
68 if (*evbit == EV_ABS) {
69 struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
70 test_create_abs_device(&uidev, &dev,
71 1, &abs,
72 -1);
73 } else
74 test_create_device(&uidev, &dev,
75 *evbit, 0,
76 -1);
77
78 ck_assert_int_eq(libevdev_has_event_type(dev, EV_MAX + 1), 0);
79 ck_assert_int_eq(libevdev_has_event_type(dev, INT_MAX), 0);
80 ck_assert_int_eq(libevdev_has_event_type(dev, UINT_MAX), 0);
81
82 libevdev_free(dev);
83 uinput_device_free(uidev);
84
85 evbit++;
86 }
87 }
88 END_TEST
89
START_TEST(test_event_codes)90 START_TEST(test_event_codes)
91 {
92 int *evbit = evbits;
93
94 while(*evbit != -1) {
95 struct uinput_device* uidev;
96 struct libevdev *dev;
97 int code, max;
98 if (*evbit == EV_SYN) {
99 evbit++;
100 continue;
101 }
102
103 #ifdef __FreeBSD__
104 /* Force feedback events are not supported by FreeBSD */
105 if (*evbit == EV_FF) {
106 evbit++;
107 continue;
108 }
109 #endif
110
111 max = libevdev_event_type_get_max(*evbit);
112
113 for (code = 1; code < max; code += 10) {
114 if (*evbit == EV_ABS) {
115 struct input_absinfo abs = { code, 0, 2, 0, 0, 0};
116 test_create_abs_device(&uidev, &dev,
117 1, &abs,
118 -1);
119 } else
120 test_create_device(&uidev, &dev,
121 *evbit, code,
122 -1);
123
124 ck_assert_msg(libevdev_has_event_type(dev, *evbit), "for event type %d\n", *evbit);
125 ck_assert_msg(libevdev_has_event_code(dev, *evbit, code), "for type %d code %d", *evbit, code);
126 ck_assert_msg(libevdev_has_event_code(dev, EV_SYN, SYN_REPORT), "for EV_SYN");
127 /* always false */
128 ck_assert_msg(!libevdev_has_event_code(dev, EV_PWR, 0), "for EV_PWR");
129
130 libevdev_free(dev);
131 uinput_device_free(uidev);
132 }
133
134 evbit++;
135 }
136 }
137 END_TEST
138
START_TEST(test_event_code_limits)139 START_TEST(test_event_code_limits)
140 {
141 int *evbit = evbits;
142
143 while(*evbit != -1) {
144 struct uinput_device* uidev;
145 struct libevdev *dev;
146 int max;
147
148 if (*evbit == EV_SYN) {
149 evbit++;
150 continue;
151 }
152
153 max = libevdev_event_type_get_max(*evbit);
154 ck_assert(max != -1);
155
156 if (*evbit == EV_ABS) {
157 struct input_absinfo abs = { ABS_X, 0, 2, 0, 0, 0};
158 test_create_abs_device(&uidev, &dev,
159 1, &abs,
160 -1);
161 } else
162 test_create_device(&uidev, &dev,
163 *evbit, 1,
164 -1);
165
166 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, max), "for type %d code %d", *evbit, max);
167 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, INT_MAX), "for type %d code %d", *evbit, INT_MAX);
168 ck_assert_msg(!libevdev_has_event_code(dev, *evbit, UINT_MAX), "for type %d code %d", *evbit, UINT_MAX);
169
170 libevdev_free(dev);
171 uinput_device_free(uidev);
172
173 evbit++;
174 }
175 }
176 END_TEST
177
START_TEST(test_ev_rep)178 START_TEST(test_ev_rep)
179 {
180 struct libevdev *dev;
181 struct uinput_device* uidev;
182 int rc;
183 int rep, delay;
184 const int KERNEL_DEFAULT_REP = 250;
185 const int KERNEL_DEFAULT_DELAY = 33;
186
187 /* EV_REP is special, it's always fully set if set at all,
188 can't test this through uinput though */
189 uidev = uinput_device_new(TEST_DEVICE_NAME);
190 ck_assert(uidev != NULL);
191 rc = uinput_device_set_bit(uidev, EV_REP);
192 ck_assert_int_eq(rc, 0);
193
194 rc = uinput_device_create(uidev);
195 ck_assert_int_eq(rc, 0);
196
197 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
198 ck_assert_int_eq(rc, 0);
199
200 ck_assert_int_eq(libevdev_has_event_type(dev, EV_REP), 1);
201 ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_DELAY), 1);
202 ck_assert_int_eq(libevdev_has_event_code(dev, EV_REP, REP_PERIOD), 1);
203
204 ck_assert_int_eq(libevdev_get_repeat(dev, &rep, &delay), 0);
205 /* default values as set by the kernel,
206 see drivers/input/input.c:input_register_device() */
207 ck_assert_int_eq(rep, KERNEL_DEFAULT_REP);
208 ck_assert_int_eq(delay, KERNEL_DEFAULT_DELAY);
209
210 libevdev_free(dev);
211 uinput_device_free(uidev);
212 }
213 END_TEST
214
START_TEST(test_ev_rep_values)215 START_TEST(test_ev_rep_values)
216 {
217 struct uinput_device* uidev;
218 struct libevdev *dev;
219 int delay = 0xab, period = 0xbc;
220
221 /* EV_REP is special, it's always fully set if set at all, can't set
222 it through uinput though. */
223 test_create_device(&uidev, &dev, -1);
224
225 ck_assert_int_eq(libevdev_get_repeat(dev, NULL, NULL), -1);
226 ck_assert_int_eq(libevdev_get_repeat(dev, &delay, NULL), -1);
227 ck_assert_int_eq(libevdev_get_repeat(dev, NULL, &period), -1);
228 ck_assert_int_eq(libevdev_get_repeat(dev, &delay, &period), -1);
229
230 ck_assert_int_eq(delay, 0xab);
231 ck_assert_int_eq(period, 0xbc);
232
233 uinput_device_free(uidev);
234 libevdev_free(dev);
235 }
236 END_TEST
237
START_TEST(test_input_props)238 START_TEST(test_input_props)
239 {
240 struct uinput_device* uidev;
241 struct libevdev *dev;
242 int rc, i;
243 struct input_absinfo abs = { .value = 0, .minimum = 0, .maximum = 2};
244
245 uidev = uinput_device_new(TEST_DEVICE_NAME);
246 rc = uinput_device_set_abs_bit(uidev, ABS_X, &abs);
247 ck_assert_int_eq(rc, 0);
248 uinput_device_set_prop(uidev, INPUT_PROP_DIRECT);
249 uinput_device_set_prop(uidev, INPUT_PROP_BUTTONPAD);
250 rc = uinput_device_create(uidev);
251 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
252
253 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
254 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
255
256 for (i = 0; i < INPUT_PROP_CNT; i++) {
257 if (i == INPUT_PROP_DIRECT || i == INPUT_PROP_BUTTONPAD)
258 ck_assert_int_eq(libevdev_has_property(dev, i), 1);
259 else
260 ck_assert_int_eq(libevdev_has_property(dev, i), 0);
261 }
262
263 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_MAX + 1), 0);
264 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_MAX), 0);
265
266 uinput_device_free(uidev);
267 libevdev_free(dev);
268 }
269 END_TEST
270
START_TEST(test_set_input_props)271 START_TEST(test_set_input_props)
272 {
273 struct uinput_device* uidev;
274 struct libevdev *dev;
275 int rc, fd;
276 struct input_absinfo abs = { .value = 0, .minimum = 0, .maximum = 2};
277
278 dev = libevdev_new();
279 ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_MAX + 1), -1);
280 ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_DIRECT), 0);
281 ck_assert_int_eq(libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD), 0);
282 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_DIRECT), 1);
283 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_BUTTONPAD), 1);
284
285 uidev = uinput_device_new(TEST_DEVICE_NAME);
286 rc = uinput_device_set_abs_bit(uidev, ABS_X, &abs);
287 ck_assert_int_eq(rc, 0);
288 uinput_device_set_prop(uidev, INPUT_PROP_BUTTONPAD);
289 rc = uinput_device_create(uidev);
290 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
291
292 fd = uinput_device_get_fd(uidev);
293 rc = libevdev_set_fd(dev, fd);
294 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
295
296 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_DIRECT), 0);
297 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_BUTTONPAD), 1);
298
299 /* Test disabling the properties too */
300 ck_assert_int_eq(libevdev_disable_property(dev, INPUT_PROP_MAX + 1), -1);
301 ck_assert_int_eq(libevdev_disable_property(dev, INPUT_PROP_DIRECT), 0);
302 ck_assert_int_eq(libevdev_disable_property(dev, INPUT_PROP_BUTTONPAD), 0);
303 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_DIRECT), 0);
304 ck_assert_int_eq(libevdev_has_property(dev, INPUT_PROP_BUTTONPAD), 0);
305
306 uinput_device_free(uidev);
307 libevdev_free(dev);
308 }
309 END_TEST
310
START_TEST(test_slot_init_value)311 START_TEST(test_slot_init_value)
312 {
313 struct uinput_device *uidev;
314 struct libevdev *dev;
315 int rc;
316 const int nabs = 6;
317 int i;
318 int fd;
319 struct input_absinfo abs[] = {
320 { .value = ABS_X, .minimum = 0, .maximum = 1000 },
321 { .value = ABS_Y, .minimum = 0, .maximum = 1000 },
322 { .value = ABS_MT_POSITION_X, .minimum = 0, .maximum = 1000 },
323 { .value = ABS_MT_POSITION_Y, .minimum = 0, .maximum = 1000 },
324 { .value = ABS_MT_TRACKING_ID, .minimum = -1, .maximum = 2 },
325 { .value = ABS_MT_SLOT, .minimum = 0, .maximum = 1 }
326 };
327
328 uidev = uinput_device_new(TEST_DEVICE_NAME);
329
330 for (i = 0; i < nabs; i++) {
331 rc = uinput_device_set_abs_bit(uidev, abs[i].value, &abs[i]);
332 ck_assert_int_eq(rc, 0);
333 }
334
335 rc = uinput_device_create(uidev);
336 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
337
338 fd = uinput_device_get_fd(uidev);
339 rc = fcntl(fd, F_SETFL, O_NONBLOCK);
340 ck_assert_msg(rc == 0, "fcntl failed: %s", strerror(errno));
341
342 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 0);
343 uinput_device_event(uidev, EV_ABS, ABS_X, 100);
344 uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
345 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 100);
346 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 500);
347 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 1);
348 uinput_device_event(uidev, EV_ABS, ABS_MT_SLOT, 1);
349 uinput_device_event(uidev, EV_ABS, ABS_X, 1);
350 uinput_device_event(uidev, EV_ABS, ABS_Y, 5);
351 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_X, 1);
352 uinput_device_event(uidev, EV_ABS, ABS_MT_POSITION_Y, 5);
353 uinput_device_event(uidev, EV_ABS, ABS_MT_TRACKING_ID, 2);
354 uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
355
356 rc = libevdev_new_from_fd(fd, &dev);
357 ck_assert_int_eq(rc, 0);
358
359 ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
360 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 100);
361 ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_Y), 500);
362 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 1);
363 ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_Y), 5);
364
365 uinput_device_free(uidev);
366 libevdev_free(dev);
367 }
368 END_TEST
369
START_TEST(test_no_slots)370 START_TEST(test_no_slots)
371 {
372 struct uinput_device* uidev;
373 struct libevdev *dev;
374 struct input_absinfo abs[] = {
375 { .value = ABS_X, .minimum = 0, .maximum = 2 },
376 { .value = ABS_Y, .minimum = 0, .maximum = 2 },
377 { .value = ABS_MT_POSITION_X, .minimum = 0, .maximum = 2 },
378 { .value = ABS_MT_POSITION_Y, .minimum = 0, .maximum = 2 }
379 };
380
381 test_create_abs_device(&uidev, &dev, 4, abs,
382 -1);
383
384 ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
385 ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
386
387 uinput_device_free(uidev);
388 libevdev_free(dev);
389 }
390 END_TEST
391
START_TEST(test_slot_number)392 START_TEST(test_slot_number)
393 {
394 struct uinput_device* uidev;
395 struct libevdev *dev;
396 const int nslots = 4;
397 struct input_absinfo abs[] = {
398 { .value = ABS_X, .minimum = 0, .maximum = 2 },
399 { .value = ABS_Y, .minimum = 0, .maximum = 2 },
400 { .value = ABS_MT_POSITION_X, .minimum = 0, .maximum = 2 },
401 { .value = ABS_MT_POSITION_Y, .minimum = 0, .maximum = 2 },
402 { .value = ABS_MT_SLOT, .minimum = 0, .maximum = nslots - 1 }
403 };
404
405 test_create_abs_device(&uidev, &dev, 5, abs,
406 -1);
407
408 ck_assert_int_eq(libevdev_get_num_slots(dev), nslots);
409 ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
410
411 uinput_device_free(uidev);
412 libevdev_free(dev);
413 }
414 END_TEST
415
START_TEST(test_invalid_mt_device)416 START_TEST(test_invalid_mt_device)
417 {
418 struct uinput_device* uidev;
419 struct libevdev *dev;
420 const int nslots = 4;
421 int value;
422 struct input_absinfo abs[] = {
423 { .value = ABS_X, .minimum = 0, .maximum = 2 },
424 { .value = ABS_Y, .minimum = 0, .maximum = 2 },
425 { .value = ABS_MT_POSITION_X, .minimum = 0, .maximum = 2 },
426 { .value = ABS_MT_POSITION_Y, .minimum = 0, .maximum = 2 },
427 { .value = ABS_MT_SLOT - 1, .minimum = 0, .maximum = 2 },
428 { .value = ABS_MT_SLOT, .minimum = 0, .maximum = nslots - 1 }
429 };
430
431 test_create_abs_device(&uidev, &dev, 6, abs,
432 -1);
433
434 ck_assert_int_eq(libevdev_get_num_slots(dev), -1);
435 ck_assert_int_eq(libevdev_get_current_slot(dev), -1);
436 ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 0), -1);
437 ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_POSITION_X, &value), 0);
438
439 ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT - 1));
440 ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT));
441
442 ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
443 ck_assert(libevdev_get_event_value(dev, EV_ABS, ABS_MT_SLOT) == 1);
444
445 uinput_device_free(uidev);
446 libevdev_free(dev);
447 }
448 END_TEST
449
START_TEST(test_device_name)450 START_TEST(test_device_name)
451 {
452 struct uinput_device* uidev;
453 struct libevdev *dev;
454 struct input_id ids = {1, 2, 3, 4};
455 const char *str;
456 int rc;
457
458 dev = libevdev_new();
459
460 str = libevdev_get_name(dev);
461 ck_assert(str != NULL);
462 ck_assert_int_eq(strlen(str), 0);
463
464 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
465 EV_REL, REL_X,
466 -1);
467 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
468 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
469 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
470
471 str = libevdev_get_name(dev);
472 ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
473
474 str = libevdev_get_phys(dev);
475 ck_assert(str == NULL);
476
477 str = libevdev_get_uniq(dev);
478 ck_assert(str == NULL);
479
480 ck_assert_int_eq(libevdev_get_id_bustype(dev), ids.bustype);
481 ck_assert_int_eq(libevdev_get_id_vendor(dev), ids.vendor);
482 ck_assert_int_eq(libevdev_get_id_product(dev), ids.product);
483 ck_assert_int_eq(libevdev_get_id_version(dev), ids.version);
484 ck_assert_int_eq(libevdev_get_driver_version(dev), EV_VERSION);
485
486 uinput_device_free(uidev);
487 libevdev_free(dev);
488 }
489 END_TEST
490
START_TEST(test_device_set_name)491 START_TEST(test_device_set_name)
492 {
493 struct uinput_device* uidev;
494 struct libevdev *dev;
495 struct input_id ids = {1, 2, 3, 4};
496 const char *str;
497 int rc;
498
499 dev = libevdev_new();
500
501 libevdev_set_name(dev, "the name");
502 libevdev_set_phys(dev, "the phys");
503 libevdev_set_uniq(dev, "the uniq");
504
505 str = libevdev_get_name(dev);
506 ck_assert(str != NULL);
507 ck_assert_int_eq(strcmp(str, "the name"), 0);
508
509 str = libevdev_get_phys(dev);
510 ck_assert(str != NULL);
511 ck_assert_int_eq(strcmp(str, "the phys"), 0);
512
513 str = libevdev_get_uniq(dev);
514 ck_assert(str != NULL);
515 ck_assert_int_eq(strcmp(str, "the uniq"), 0);
516
517 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
518 EV_REL, REL_X,
519 -1);
520 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
521 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
522 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
523
524 str = libevdev_get_name(dev);
525 ck_assert_int_eq(strcmp(str, TEST_DEVICE_NAME), 0);
526
527 str = libevdev_get_phys(dev);
528 ck_assert(str == NULL);
529
530 str = libevdev_get_uniq(dev);
531 ck_assert(str == NULL);
532
533 uinput_device_free(uidev);
534 libevdev_free(dev);
535 }
536 END_TEST
537
START_TEST(test_device_set_ids)538 START_TEST(test_device_set_ids)
539 {
540 struct uinput_device* uidev;
541 struct libevdev *dev;
542 struct input_id ids = {1, 2, 3, 4};
543 int rc;
544
545 dev = libevdev_new();
546
547 libevdev_set_id_product(dev, 10);
548 libevdev_set_id_vendor(dev, 20);
549 libevdev_set_id_bustype(dev, 30);
550 libevdev_set_id_version(dev, 40);
551
552 ck_assert_int_eq(libevdev_get_id_product(dev), 10);
553 ck_assert_int_eq(libevdev_get_id_vendor(dev), 20);
554 ck_assert_int_eq(libevdev_get_id_bustype(dev), 30);
555 ck_assert_int_eq(libevdev_get_id_version(dev), 40);
556
557 rc = uinput_device_new_with_events(&uidev, TEST_DEVICE_NAME, &ids,
558 EV_REL, REL_X,
559 -1);
560 ck_assert_msg(rc == 0, "Failed to create uinput device: %s", strerror(-rc));
561 rc = libevdev_set_fd(dev, uinput_device_get_fd(uidev));
562 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
563
564 ck_assert_int_eq(libevdev_get_id_bustype(dev), ids.bustype);
565 ck_assert_int_eq(libevdev_get_id_vendor(dev), ids.vendor);
566 ck_assert_int_eq(libevdev_get_id_product(dev), ids.product);
567 ck_assert_int_eq(libevdev_get_id_version(dev), ids.version);
568
569 uinput_device_free(uidev);
570 libevdev_free(dev);
571 }
572 END_TEST
573
START_TEST(test_device_get_abs_info)574 START_TEST(test_device_get_abs_info)
575 {
576 struct uinput_device* uidev;
577 struct libevdev *dev;
578 struct input_absinfo abs;
579 const struct input_absinfo *a;
580 int rc;
581
582 uidev = uinput_device_new(TEST_DEVICE_NAME);
583 ck_assert(uidev != NULL);
584
585 abs.minimum = 0;
586 abs.maximum = 1000;
587 abs.fuzz = 1;
588 abs.flat = 2;
589 abs.resolution = 3;
590 abs.value = 0;
591
592 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
593 uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_X, &abs);
594
595 abs.minimum = -500;
596 abs.maximum = 500;
597 abs.fuzz = 10;
598 abs.flat = 20;
599 abs.resolution = 30;
600 abs.value = 0;
601
602 uinput_device_set_abs_bit(uidev, ABS_Y, &abs);
603 uinput_device_set_abs_bit(uidev, ABS_MT_POSITION_Y, &abs);
604
605 rc = uinput_device_create(uidev);
606 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
607
608 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
609 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
610
611 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MAX + 1), 0);
612 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MAX + 1), 0);
613 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MAX + 1), 0);
614 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MAX + 1), 0);
615 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MAX + 1), 0);
616 ck_assert(!libevdev_get_abs_info(dev, ABS_MAX + 1));
617
618 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
619 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
620 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
621 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
622 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
623 a = libevdev_get_abs_info(dev, ABS_X);
624 ck_assert(a != NULL);
625 ck_assert_int_eq(a->minimum, 0);
626 ck_assert_int_eq(a->maximum, 1000);
627 ck_assert_int_eq(a->fuzz, 1);
628 ck_assert_int_eq(a->flat, 2);
629 ck_assert_int_eq(a->resolution, 3);
630
631 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_X), 0);
632 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_X), 1000);
633 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_X), 1);
634 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_X), 2);
635 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_X), 3);
636 a = libevdev_get_abs_info(dev, ABS_MT_POSITION_X);
637 ck_assert(a != NULL);
638 ck_assert_int_eq(a->minimum, 0);
639 ck_assert_int_eq(a->maximum, 1000);
640 ck_assert_int_eq(a->fuzz, 1);
641 ck_assert_int_eq(a->flat, 2);
642 ck_assert_int_eq(a->resolution, 3);
643
644 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_Y), -500);
645 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_Y), 500);
646 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_Y), 10);
647 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_Y), 20);
648 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_Y), 30);
649 a = libevdev_get_abs_info(dev, ABS_Y);
650 ck_assert(a != NULL);
651 ck_assert_int_eq(a->minimum, -500);
652 ck_assert_int_eq(a->maximum, 500);
653 ck_assert_int_eq(a->fuzz, 10);
654 ck_assert_int_eq(a->flat, 20);
655 ck_assert_int_eq(a->resolution, 30);
656
657 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_Y), -500);
658 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_Y), 500);
659 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_Y), 10);
660 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_Y), 20);
661 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_Y), 30);
662 a = libevdev_get_abs_info(dev, ABS_MT_POSITION_Y);
663 ck_assert(a != NULL);
664 ck_assert_int_eq(a->minimum, -500);
665 ck_assert_int_eq(a->maximum, 500);
666 ck_assert_int_eq(a->fuzz, 10);
667 ck_assert_int_eq(a->flat, 20);
668 ck_assert_int_eq(a->resolution, 30);
669
670 uinput_device_free(uidev);
671 libevdev_free(dev);
672 }
673 END_TEST
674
START_TEST(test_device_set_abs)675 START_TEST(test_device_set_abs)
676 {
677 struct uinput_device* uidev;
678 struct libevdev *dev;
679 struct input_absinfo abs[2];
680 struct input_absinfo a;
681
682 memset(abs, 0, sizeof(abs));
683 abs[0].value = ABS_X;
684 abs[0].maximum = 1000;
685
686 abs[1].value = ABS_Y;
687 abs[1].maximum = 1000;
688
689 test_create_abs_device(&uidev, &dev,
690 2, abs,
691 EV_SYN,
692 -1);
693
694 libevdev_set_abs_minimum(dev, ABS_X, 1);
695 libevdev_set_abs_minimum(dev, ABS_Y, 5);
696 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 1);
697 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_Y), 5);
698
699 libevdev_set_abs_maximum(dev, ABS_X, 3000);
700 libevdev_set_abs_maximum(dev, ABS_Y, 5000);
701 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 3000);
702 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_Y), 5000);
703
704 libevdev_set_abs_fuzz(dev, ABS_X, 3);
705 libevdev_set_abs_fuzz(dev, ABS_Y, 5);
706 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 3);
707 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_Y), 5);
708
709 libevdev_set_abs_flat(dev, ABS_X, 8);
710 libevdev_set_abs_flat(dev, ABS_Y, 15);
711 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 8);
712 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_Y), 15);
713
714 libevdev_set_abs_resolution(dev, ABS_X, 80);
715 libevdev_set_abs_resolution(dev, ABS_Y, 150);
716 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 80);
717 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_Y), 150);
718
719 a.value = 0;
720 a.minimum = 10;
721 a.maximum = 100;
722 a.fuzz = 13;
723 a.flat = 1;
724 a.resolution = 16;
725
726 libevdev_set_abs_info(dev, ABS_X, &a);
727 ck_assert_int_eq(memcmp(&a, libevdev_get_abs_info(dev, ABS_X), sizeof(a)), 0);
728
729 libevdev_set_abs_minimum(dev, ABS_Z, 10);
730 ck_assert_int_eq(libevdev_has_event_code(dev, EV_ABS, ABS_Z), 0);
731
732 uinput_device_free(uidev);
733 libevdev_free(dev);
734 }
735 END_TEST
736
START_TEST(test_device_enable_bit)737 START_TEST(test_device_enable_bit)
738 {
739 struct uinput_device* uidev;
740 struct libevdev *dev, *dev2;
741 struct input_absinfo abs = { .value = ABS_X, .minimum = 0, .maximum = 2 };
742 int rc;
743
744 test_create_abs_device(&uidev, &dev, 1, &abs,
745 -1);
746
747 ck_assert(!libevdev_has_event_code(dev, EV_ABS, ABS_Y));
748 ck_assert(!libevdev_has_event_type(dev, EV_REL));
749 ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
750
751 abs.minimum = 0;
752 abs.maximum = 100;
753 abs.fuzz = 1;
754 abs.flat = 2;
755 abs.resolution = 3;
756
757 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &abs), 0);
758 ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_Y));
759
760 ck_assert_int_eq(libevdev_enable_event_type(dev, EV_REL), 0);
761 ck_assert(libevdev_has_event_type(dev, EV_REL));
762 ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
763
764 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REL, REL_X, NULL), 0);
765 ck_assert(libevdev_has_event_code(dev, EV_REL, REL_X));
766
767 /* make sure kernel device is unchanged */
768 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
769 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
770 ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_X));
771 ck_assert(!libevdev_has_event_code(dev2, EV_ABS, ABS_Y));
772 ck_assert(!libevdev_has_event_type(dev2, EV_REL));
773 ck_assert(!libevdev_has_event_code(dev2, EV_REL, REL_X));
774 libevdev_free(dev2);
775
776 uinput_device_free(uidev);
777 libevdev_free(dev);
778 }
779 END_TEST
780
START_TEST(test_device_enable_bit_invalid)781 START_TEST(test_device_enable_bit_invalid)
782 {
783 struct uinput_device* uidev;
784 struct libevdev *dev;
785 struct input_absinfo abs = { .value = ABS_X, .minimum = 0, .maximum = 1 };
786
787 test_create_abs_device(&uidev, &dev, 1, &abs,
788 -1);
789
790 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_MAX + 1, &abs), -1);
791 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_MAX + 1, ABS_MAX + 1, &abs), -1);
792 ck_assert_int_eq(libevdev_enable_event_type(dev, EV_MAX + 1), -1);
793 /* there's a gap between EV_SW and EV_LED */
794 ck_assert_int_eq(libevdev_enable_event_type(dev, EV_LED - 1), -1);
795 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_LED - 1, 0, NULL), -1);
796
797 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_ABS, ABS_Y, NULL), -1);
798 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REP, REP_DELAY, NULL), -1);
799 ck_assert_int_eq(libevdev_enable_event_code(dev, EV_REL, REL_X, &abs), -1);
800
801 uinput_device_free(uidev);
802 libevdev_free(dev);
803 }
804 END_TEST
805
START_TEST(test_device_disable_bit)806 START_TEST(test_device_disable_bit)
807 {
808 struct uinput_device* uidev;
809 struct libevdev *dev, *dev2;
810 int rc;
811 struct input_absinfo abs[2] = {
812 { .value = ABS_X, .minimum = 0, .maximum = 1 },
813 { .value = ABS_Y, .minimum = 0, .maximum = 1 },
814 };
815
816 test_create_abs_device(&uidev, &dev,
817 2, abs,
818 EV_REL, REL_X,
819 EV_REL, REL_Y,
820 -1);
821
822 ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_X));
823 ck_assert(libevdev_has_event_code(dev, EV_ABS, ABS_Y));
824 ck_assert(libevdev_has_event_type(dev, EV_REL));
825 ck_assert(libevdev_has_event_code(dev, EV_REL, REL_X));
826 ck_assert(libevdev_has_event_code(dev, EV_REL, REL_Y));
827
828 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_ABS, ABS_Y), 0);
829 ck_assert(!libevdev_has_event_code(dev, EV_ABS, ABS_Y));
830
831 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_REL, REL_X), 0);
832 ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
833 ck_assert(libevdev_has_event_code(dev, EV_REL, REL_Y));
834 ck_assert(libevdev_has_event_type(dev, EV_REL));
835
836 ck_assert_int_eq(libevdev_disable_event_type(dev, EV_REL), 0);
837 ck_assert(!libevdev_has_event_type(dev, EV_REL));
838 ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_X));
839 ck_assert(!libevdev_has_event_code(dev, EV_REL, REL_Y));
840
841 /* make sure kernel device is unchanged */
842 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
843 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
844 ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_X));
845 ck_assert(libevdev_has_event_code(dev2, EV_ABS, ABS_Y));
846 ck_assert(libevdev_has_event_type(dev2, EV_REL));
847 ck_assert(libevdev_has_event_code(dev2, EV_REL, REL_X));
848 ck_assert(libevdev_has_event_code(dev2, EV_REL, REL_Y));
849 libevdev_free(dev2);
850
851 uinput_device_free(uidev);
852 libevdev_free(dev);
853 }
854 END_TEST
855
START_TEST(test_device_disable_bit_invalid)856 START_TEST(test_device_disable_bit_invalid)
857 {
858 struct uinput_device* uidev;
859 struct libevdev *dev;
860 struct input_absinfo abs = { .value = ABS_X, .minimum = 0, .maximum = 1 };
861
862 test_create_abs_device(&uidev, &dev, 1, &abs, -1);
863
864 /* there's a gap between EV_SW and EV_LED */
865 ck_assert_int_eq(libevdev_disable_event_type(dev, EV_LED - 1), -1);
866 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_LED - 1, 0), -1);
867 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_ABS, ABS_MAX + 1), -1);
868 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_MAX + 1, ABS_MAX + 1), -1);
869 ck_assert_int_eq(libevdev_disable_event_type(dev, EV_MAX + 1), -1);
870 ck_assert_int_eq(libevdev_disable_event_type(dev, EV_SYN), -1);
871 ck_assert_int_eq(libevdev_disable_event_code(dev, EV_SYN, SYN_REPORT), -1);
872
873 uinput_device_free(uidev);
874 libevdev_free(dev);
875 }
876 END_TEST
877
START_TEST(test_device_kernel_change_axis)878 START_TEST(test_device_kernel_change_axis)
879 {
880 struct uinput_device* uidev;
881 struct libevdev *dev, *dev2;
882 struct input_absinfo abs;
883 int rc;
884
885 uidev = uinput_device_new(TEST_DEVICE_NAME);
886 ck_assert(uidev != NULL);
887
888 abs.minimum = 0;
889 abs.maximum = 1000;
890 abs.fuzz = 1;
891 abs.flat = 2;
892 abs.resolution = 3;
893 abs.value = 0;
894
895 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
896
897 rc = uinput_device_create(uidev);
898 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
899
900 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
901 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
902
903 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
904 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
905 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
906 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
907 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
908
909 abs.minimum = 500;
910 abs.maximum = 5000;
911 abs.fuzz = 10;
912 abs.flat = 20;
913 abs.resolution = 30;
914 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &abs);
915 ck_assert_int_eq(rc, 0);
916
917 ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 500);
918 ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 5000);
919 ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 10);
920 ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 20);
921 ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 30);
922
923 /* make sure kernel device is changed */
924 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
925 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
926 ck_assert_int_eq(libevdev_get_abs_minimum(dev2, ABS_X), 500);
927 ck_assert_int_eq(libevdev_get_abs_maximum(dev2, ABS_X), 5000);
928 ck_assert_int_eq(libevdev_get_abs_fuzz(dev2, ABS_X), 10);
929 ck_assert_int_eq(libevdev_get_abs_flat(dev2, ABS_X), 20);
930 ck_assert_int_eq(libevdev_get_abs_resolution(dev2, ABS_X), 30);
931 libevdev_free(dev2);
932
933 libevdev_free(dev);
934 uinput_device_free(uidev);
935 }
936 END_TEST
937
START_TEST(test_device_kernel_change_axis_invalid)938 START_TEST(test_device_kernel_change_axis_invalid)
939 {
940 struct uinput_device* uidev;
941 struct libevdev *dev;
942 struct input_absinfo abs;
943 int rc;
944
945 uidev = uinput_device_new(TEST_DEVICE_NAME);
946 ck_assert(uidev != NULL);
947
948 abs.minimum = 0;
949 abs.maximum = 1000;
950 abs.fuzz = 1;
951 abs.flat = 2;
952 abs.resolution = 3; /* FIXME: value is unused, we can't test resolution */
953 abs.value = 0;
954
955 uinput_device_set_abs_bit(uidev, ABS_X, &abs);
956
957 rc = uinput_device_create(uidev);
958 ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
959
960 rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
961 ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
962
963 rc = libevdev_kernel_set_abs_info(dev, ABS_MAX + 1, &abs);
964 ck_assert_int_eq(rc, -EINVAL);
965
966 libevdev_free(dev);
967 uinput_device_free(uidev);
968 }
969 END_TEST
970
START_TEST(test_device_kernel_set_abs_invalid_fd)971 START_TEST(test_device_kernel_set_abs_invalid_fd)
972 {
973 struct uinput_device* uidev;
974 struct libevdev *dev;
975 struct input_absinfo abs[2];
976 struct input_absinfo a;
977 int rc;
978
979 libevdev_set_log_function(test_logfunc_ignore_error, NULL);
980
981 memset(abs, 0, sizeof(abs));
982 abs[0].value = ABS_X;
983 abs[0].maximum = 1000;
984
985 abs[1].value = ABS_Y;
986 abs[1].maximum = 1000;
987
988 dev = libevdev_new();
989 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &a);
990 ck_assert_int_eq(rc, -EBADF);
991 libevdev_free(dev);
992
993 test_create_abs_device(&uidev, &dev,
994 2, abs,
995 EV_SYN,
996 -1);
997
998 libevdev_change_fd(dev, -2);
999 rc = libevdev_kernel_set_abs_info(dev, ABS_X, &a);
1000 ck_assert_int_eq(rc, -EBADF);
1001
1002 libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
1003
1004 uinput_device_free(uidev);
1005 libevdev_free(dev);
1006 }
1007 END_TEST
1008
START_TEST(test_led_valid)1009 START_TEST(test_led_valid)
1010 {
1011 struct uinput_device* uidev;
1012 struct libevdev *dev;
1013 int rc;
1014
1015 test_create_device(&uidev, &dev,
1016 EV_LED, LED_NUML,
1017 EV_LED, LED_CAPSL,
1018 EV_LED, LED_COMPOSE,
1019 -1);
1020
1021 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_ON);
1022 ck_assert_int_eq(rc, 0);
1023 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF);
1024 ck_assert_int_eq(rc, 0);
1025
1026 rc = libevdev_kernel_set_led_values(dev,
1027 LED_NUML, LIBEVDEV_LED_OFF,
1028 LED_CAPSL, LIBEVDEV_LED_ON,
1029 LED_COMPOSE, LIBEVDEV_LED_OFF,
1030 -1);
1031 ck_assert_int_eq(rc, 0);
1032 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1033 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1034 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1035
1036 rc = libevdev_kernel_set_led_values(dev,
1037 LED_NUML, LIBEVDEV_LED_ON,
1038 LED_CAPSL, LIBEVDEV_LED_OFF,
1039 LED_COMPOSE, LIBEVDEV_LED_ON,
1040 -1);
1041 ck_assert_int_eq(rc, 0);
1042 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1043 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1044 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1045
1046 /* make sure we ignore unset leds */
1047 rc = libevdev_kernel_set_led_values(dev,
1048 LED_NUML, LIBEVDEV_LED_ON,
1049 LED_CAPSL, LIBEVDEV_LED_OFF,
1050 LED_SCROLLL, LIBEVDEV_LED_OFF,
1051 LED_COMPOSE, LIBEVDEV_LED_ON,
1052 -1);
1053 ck_assert_int_eq(rc, 0);
1054 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1055 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1056 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1057
1058 libevdev_free(dev);
1059 uinput_device_free(uidev);
1060 }
1061 END_TEST
1062
START_TEST(test_led_invalid)1063 START_TEST(test_led_invalid)
1064 {
1065 struct uinput_device* uidev;
1066 struct libevdev *dev;
1067 int rc;
1068
1069 test_create_device(&uidev, &dev,
1070 EV_LED, LED_NUML,
1071 EV_LED, LED_CAPSL,
1072 EV_LED, LED_COMPOSE,
1073 -1);
1074
1075 rc = libevdev_kernel_set_led_value(dev, LED_MAX + 1, LIBEVDEV_LED_ON);
1076 ck_assert_int_eq(rc, -EINVAL);
1077
1078 rc = libevdev_kernel_set_led_value(dev, LED_NUML, LIBEVDEV_LED_OFF + 1);
1079 ck_assert_int_eq(rc, -EINVAL);
1080
1081 rc = libevdev_kernel_set_led_value(dev, LED_SCROLLL, LIBEVDEV_LED_ON);
1082 ck_assert_int_eq(rc, 0);
1083
1084 rc = libevdev_kernel_set_led_values(dev,
1085 LED_NUML, LIBEVDEV_LED_OFF + 1,
1086 -1);
1087 ck_assert_int_eq(rc, -EINVAL);
1088
1089 rc = libevdev_kernel_set_led_values(dev,
1090 LED_MAX + 1, LIBEVDEV_LED_ON,
1091 LED_NUML, LIBEVDEV_LED_OFF + 1,
1092 -1);
1093 ck_assert_int_eq(rc, -EINVAL);
1094
1095 rc = libevdev_kernel_set_led_values(dev,
1096 LED_SCROLLL, LIBEVDEV_LED_OFF,
1097 -1);
1098 ck_assert_int_eq(rc, 0);
1099
1100 libevdev_free(dev);
1101 uinput_device_free(uidev);
1102 }
1103 END_TEST
1104
START_TEST(test_led_same)1105 START_TEST(test_led_same)
1106 {
1107 struct uinput_device* uidev;
1108 struct libevdev *dev;
1109 int rc;
1110
1111 test_create_device(&uidev, &dev,
1112 EV_LED, LED_NUML,
1113 EV_LED, LED_CAPSL,
1114 EV_LED, LED_COMPOSE,
1115 -1);
1116
1117 rc = libevdev_kernel_set_led_values(dev,
1118 LED_NUML, LIBEVDEV_LED_OFF,
1119 LED_NUML, LIBEVDEV_LED_ON,
1120 LED_NUML, LIBEVDEV_LED_OFF,
1121 LED_NUML, LIBEVDEV_LED_ON,
1122 LED_NUML, LIBEVDEV_LED_OFF,
1123 LED_NUML, LIBEVDEV_LED_ON,
1124 LED_NUML, LIBEVDEV_LED_OFF,
1125 LED_NUML, LIBEVDEV_LED_ON,
1126 LED_NUML, LIBEVDEV_LED_OFF,
1127 LED_NUML, LIBEVDEV_LED_ON,
1128 LED_NUML, LIBEVDEV_LED_OFF,
1129 LED_NUML, LIBEVDEV_LED_ON,
1130 LED_NUML, LIBEVDEV_LED_OFF,
1131 LED_NUML, LIBEVDEV_LED_ON,
1132 LED_NUML, LIBEVDEV_LED_OFF,
1133 LED_NUML, LIBEVDEV_LED_ON,
1134 LED_NUML, LIBEVDEV_LED_OFF,
1135 LED_NUML, LIBEVDEV_LED_ON,
1136 LED_NUML, LIBEVDEV_LED_OFF,
1137 LED_NUML, LIBEVDEV_LED_ON,
1138 LED_NUML, LIBEVDEV_LED_OFF,
1139 LED_NUML, LIBEVDEV_LED_ON,
1140 LED_NUML, LIBEVDEV_LED_OFF,
1141 LED_NUML, LIBEVDEV_LED_ON,
1142 /* more than LED_CNT */
1143 -1);
1144 ck_assert_int_eq(rc, 0);
1145 ck_assert_int_eq(1, libevdev_get_event_value(dev, EV_LED, LED_NUML));
1146 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_CAPSL));
1147 ck_assert_int_eq(0, libevdev_get_event_value(dev, EV_LED, LED_COMPOSE));
1148
1149 libevdev_free(dev);
1150 uinput_device_free(uidev);
1151 }
1152 END_TEST
1153
TEST_SUITE_ROOT_PRIVILEGES(has_events)1154 TEST_SUITE_ROOT_PRIVILEGES(has_events)
1155 {
1156 Suite *s = suite_create("libevdev_has_event tests");
1157
1158 add_test(s, test_ev_bit_limits);
1159 add_test(s, test_has_ev_bit);
1160
1161 add_test(s, test_event_codes);
1162 add_test(s, test_event_code_limits);
1163
1164 add_test(s, test_ev_rep);
1165 add_test(s, test_ev_rep_values);
1166
1167 add_test(s, test_input_props);
1168 add_test(s, test_set_input_props);
1169
1170 add_test(s, test_no_slots);
1171 add_test(s, test_slot_number);
1172 add_test(s, test_slot_init_value);
1173 add_test(s, test_invalid_mt_device);
1174
1175 add_test(s, test_device_name);
1176 add_test(s, test_device_set_name);
1177 add_test(s, test_device_set_ids);
1178 add_test(s, test_device_get_abs_info);
1179
1180 add_test(s, test_device_set_abs);
1181 add_test(s, test_device_enable_bit);
1182 add_test(s, test_device_enable_bit_invalid);
1183 add_test(s, test_device_disable_bit);
1184 add_test(s, test_device_disable_bit_invalid);
1185 add_test(s, test_device_kernel_change_axis);
1186 add_test(s, test_device_kernel_change_axis_invalid);
1187 add_test(s, test_device_kernel_set_abs_invalid_fd);
1188
1189 add_test(s, test_led_valid);
1190 add_test(s, test_led_invalid);
1191 add_test(s, test_led_same);
1192
1193 return s;
1194 }
1195