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