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 16START_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} 42END_TEST 43 44START_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} 79END_TEST 80 81START_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} 109END_TEST 110 111START_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} 168END_TEST 169 170START_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} 202END_TEST 203 204START_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} 240END_TEST 241 242START_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} 279END_TEST 280 281START_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} 296END_TEST 297 298START_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} 346END_TEST 347 348START_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} 397END_TEST 398 399START_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} 481END_TEST 482 483START_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} 560END_TEST 561 562START_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} 606END_TEST 607 608START_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} 652END_TEST 653 654START_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} 808END_TEST 809 810START_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} 1009END_TEST 1010 1011START_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} 1226END_TEST 1227 1228START_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} 1308END_TEST 1309 1310START_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} 1347END_TEST 1348 1349START_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} 1390END_TEST 1391 1392START_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} 1416END_TEST 1417 1418START_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} 1480END_TEST 1481 1482START_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} 1519END_TEST 1520 1521START_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} 1585END_TEST 1586 1587START_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} 1617END_TEST 1618 1619START_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} 1686END_TEST 1687 1688START_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} 1744END_TEST 1745 1746START_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} 1812END_TEST 1813 1814START_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} 1838END_TEST 1839 1840START_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} 1897END_TEST 1898 1899START_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} 1928END_TEST 1929 1930START_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} 1964END_TEST 1965 1966START_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} 1995END_TEST 1996 1997START_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} 2038END_TEST 2039 2040TEST_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