1/* 2 * Copyright © 2014 Red Hat, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24#include <config.h> 25 26#include <check.h> 27#include <errno.h> 28#include <fcntl.h> 29#include <libinput.h> 30#include <unistd.h> 31 32#include "libinput-util.h" 33#include "litest.h" 34 35START_TEST(touchpad_button) 36{ 37 struct litest_device *dev = litest_current_device(); 38 struct libinput *li = dev->libinput; 39 40 if (!libevdev_has_event_code(dev->evdev, EV_KEY, BTN_LEFT)) 41 return; 42 43 litest_drain_events(li); 44 45 litest_button_click(dev, BTN_LEFT, true); 46 libinput_dispatch(li); 47 litest_assert_button_event(li, 48 BTN_LEFT, 49 LIBINPUT_BUTTON_STATE_PRESSED); 50 litest_button_click(dev, BTN_LEFT, false); 51 libinput_dispatch(li); 52 litest_assert_button_event(li, 53 BTN_LEFT, 54 LIBINPUT_BUTTON_STATE_RELEASED); 55} 56END_TEST 57 58START_TEST(touchpad_click_defaults_clickfinger) 59{ 60 struct litest_device *dev = litest_current_device(); 61 struct libinput_device *device = dev->libinput_device; 62 uint32_t methods, method; 63 enum libinput_config_status status; 64 65 /* call this test for apple touchpads */ 66 67 methods = libinput_device_config_click_get_methods(device); 68 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 69 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 70 71 method = libinput_device_config_click_get_method(device); 72 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 73 method = libinput_device_config_click_get_default_method(device); 74 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 75 76 status = libinput_device_config_click_set_method(device, 77 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 78 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 79 status = libinput_device_config_click_set_method(device, 80 LIBINPUT_CONFIG_CLICK_METHOD_NONE); 81 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 82} 83END_TEST 84 85START_TEST(touchpad_click_defaults_btnarea) 86{ 87 struct litest_device *dev = litest_current_device(); 88 struct libinput_device *device = dev->libinput_device; 89 uint32_t methods, method; 90 enum libinput_config_status status; 91 92 /* call this test for non-apple clickpads */ 93 94 methods = libinput_device_config_click_get_methods(device); 95 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 96 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 97 98 method = libinput_device_config_click_get_method(device); 99 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 100 method = libinput_device_config_click_get_default_method(device); 101 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 102 103 status = libinput_device_config_click_set_method(device, 104 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 105 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 106 status = libinput_device_config_click_set_method(device, 107 LIBINPUT_CONFIG_CLICK_METHOD_NONE); 108 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 109} 110END_TEST 111 112START_TEST(touchpad_click_defaults_none) 113{ 114 struct litest_device *dev = litest_current_device(); 115 struct libinput_device *device = dev->libinput_device; 116 uint32_t methods, method; 117 enum libinput_config_status status; 118 119 if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_APPLE && 120 libevdev_get_id_product(dev->evdev) == PRODUCT_ID_APPLE_APPLETOUCH) 121 return; 122 123 /* call this test for non-clickpads and non-touchpads */ 124 125 methods = libinput_device_config_click_get_methods(device); 126 ck_assert_int_eq(methods, 0); 127 128 method = libinput_device_config_click_get_method(device); 129 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE); 130 method = libinput_device_config_click_get_default_method(device); 131 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE); 132 133 status = libinput_device_config_click_set_method(device, 134 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 135 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED); 136 status = libinput_device_config_click_set_method(device, 137 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 138 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED); 139} 140END_TEST 141 142START_TEST(touchpad_1fg_clickfinger) 143{ 144 struct litest_device *dev = litest_current_device(); 145 struct libinput *li = dev->libinput; 146 147 litest_enable_clickfinger(dev); 148 149 litest_drain_events(li); 150 151 litest_touch_down(dev, 0, 50, 50); 152 litest_event(dev, EV_KEY, BTN_LEFT, 1); 153 litest_event(dev, EV_SYN, SYN_REPORT, 0); 154 litest_event(dev, EV_KEY, BTN_LEFT, 0); 155 litest_event(dev, EV_SYN, SYN_REPORT, 0); 156 litest_touch_up(dev, 0); 157 158 libinput_dispatch(li); 159 160 litest_assert_button_event(li, BTN_LEFT, 161 LIBINPUT_BUTTON_STATE_PRESSED); 162 litest_assert_button_event(li, BTN_LEFT, 163 LIBINPUT_BUTTON_STATE_RELEASED); 164} 165END_TEST 166 167START_TEST(touchpad_1fg_clickfinger_no_touch) 168{ 169 struct litest_device *dev = litest_current_device(); 170 struct libinput *li = dev->libinput; 171 172 if (dev->which == LITEST_SYNAPTICS_PHANTOMCLICKS) { 173 /* The XPS 15 9500 touchpad has the ModelTouchpadPhantomClicks 174 * quirk enabled and doesn't generate events without touches. */ 175 return; 176 } 177 178 litest_enable_clickfinger(dev); 179 180 litest_drain_events(li); 181 182 litest_event(dev, EV_KEY, BTN_LEFT, 1); 183 litest_event(dev, EV_SYN, SYN_REPORT, 0); 184 litest_event(dev, EV_KEY, BTN_LEFT, 0); 185 litest_event(dev, EV_SYN, SYN_REPORT, 0); 186 187 libinput_dispatch(li); 188 189 litest_assert_button_event(li, BTN_LEFT, 190 LIBINPUT_BUTTON_STATE_PRESSED); 191 litest_assert_button_event(li, BTN_LEFT, 192 LIBINPUT_BUTTON_STATE_RELEASED); 193} 194END_TEST 195 196START_TEST(touchpad_1fg_clickfinger_no_touch_phantomclicks) 197{ 198 struct litest_device *dev = litest_current_device(); 199 struct libinput *li = dev->libinput; 200 201 litest_enable_clickfinger(dev); 202 203 litest_drain_events(li); 204 205 litest_event(dev, EV_KEY, BTN_LEFT, 1); 206 litest_event(dev, EV_SYN, SYN_REPORT, 0); 207 litest_event(dev, EV_KEY, BTN_LEFT, 0); 208 litest_event(dev, EV_SYN, SYN_REPORT, 0); 209 210 libinput_dispatch(li); 211 212 litest_assert_empty_queue(li); 213} 214END_TEST 215 216START_TEST(touchpad_2fg_clickfinger) 217{ 218 struct litest_device *dev = litest_current_device(); 219 struct libinput *li = dev->libinput; 220 221 litest_enable_clickfinger(dev); 222 223 litest_drain_events(li); 224 225 litest_touch_down(dev, 0, 50, 50); 226 litest_touch_down(dev, 1, 70, 70); 227 litest_event(dev, EV_KEY, BTN_LEFT, 1); 228 litest_event(dev, EV_SYN, SYN_REPORT, 0); 229 litest_event(dev, EV_KEY, BTN_LEFT, 0); 230 litest_event(dev, EV_SYN, SYN_REPORT, 0); 231 litest_touch_up(dev, 0); 232 litest_touch_up(dev, 1); 233 234 libinput_dispatch(li); 235 236 litest_assert_button_event(li, BTN_RIGHT, 237 LIBINPUT_BUTTON_STATE_PRESSED); 238 litest_assert_button_event(li, BTN_RIGHT, 239 LIBINPUT_BUTTON_STATE_RELEASED); 240} 241END_TEST 242 243START_TEST(touchpad_3fg_clickfinger) 244{ 245 struct litest_device *dev = litest_current_device(); 246 struct libinput *li = dev->libinput; 247 248 if (litest_slot_count(dev) < 3) 249 return; 250 251 litest_enable_clickfinger(dev); 252 253 litest_drain_events(li); 254 255 litest_touch_down(dev, 0, 50, 50); 256 litest_touch_down(dev, 1, 60, 70); 257 litest_touch_down(dev, 2, 70, 70); 258 litest_event(dev, EV_KEY, BTN_LEFT, 1); 259 litest_event(dev, EV_SYN, SYN_REPORT, 0); 260 litest_event(dev, EV_KEY, BTN_LEFT, 0); 261 litest_event(dev, EV_SYN, SYN_REPORT, 0); 262 litest_touch_up(dev, 0); 263 litest_touch_up(dev, 1); 264 litest_touch_up(dev, 2); 265 266 libinput_dispatch(li); 267 268 litest_assert_button_event(li, 269 BTN_MIDDLE, 270 LIBINPUT_BUTTON_STATE_PRESSED); 271 litest_assert_button_event(li, 272 BTN_MIDDLE, 273 LIBINPUT_BUTTON_STATE_RELEASED); 274} 275END_TEST 276 277START_TEST(touchpad_3fg_clickfinger_btntool) 278{ 279 struct litest_device *dev = litest_current_device(); 280 struct libinput *li = dev->libinput; 281 282 if (litest_slot_count(dev) >= 3 || 283 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP)) 284 return; 285 286 litest_enable_clickfinger(dev); 287 288 litest_drain_events(li); 289 290 litest_touch_down(dev, 0, 50, 50); 291 litest_touch_down(dev, 1, 60, 70); 292 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 293 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1); 294 litest_event(dev, EV_SYN, SYN_REPORT, 0); 295 litest_event(dev, EV_KEY, BTN_LEFT, 1); 296 litest_event(dev, EV_SYN, SYN_REPORT, 0); 297 litest_event(dev, EV_KEY, BTN_LEFT, 0); 298 litest_event(dev, EV_SYN, SYN_REPORT, 0); 299 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1); 300 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0); 301 litest_event(dev, EV_SYN, SYN_REPORT, 0); 302 litest_touch_up(dev, 0); 303 litest_touch_up(dev, 1); 304 305 libinput_dispatch(li); 306 307 litest_assert_button_event(li, 308 BTN_MIDDLE, 309 LIBINPUT_BUTTON_STATE_PRESSED); 310 litest_assert_button_event(li, 311 BTN_MIDDLE, 312 LIBINPUT_BUTTON_STATE_RELEASED); 313} 314END_TEST 315 316START_TEST(touchpad_4fg_clickfinger) 317{ 318 struct litest_device *dev = litest_current_device(); 319 struct libinput *li = dev->libinput; 320 321 if (litest_slot_count(dev) < 4) 322 return; 323 324 litest_enable_clickfinger(dev); 325 326 litest_drain_events(li); 327 328 litest_touch_down(dev, 0, 50, 50); 329 litest_touch_down(dev, 1, 60, 70); 330 litest_touch_down(dev, 2, 70, 70); 331 litest_touch_down(dev, 3, 80, 70); 332 litest_event(dev, EV_KEY, BTN_LEFT, 1); 333 litest_event(dev, EV_SYN, SYN_REPORT, 0); 334 litest_event(dev, EV_KEY, BTN_LEFT, 0); 335 litest_event(dev, EV_SYN, SYN_REPORT, 0); 336 litest_touch_up(dev, 0); 337 litest_touch_up(dev, 1); 338 litest_touch_up(dev, 2); 339 litest_touch_up(dev, 3); 340 341 libinput_dispatch(li); 342 343 litest_assert_empty_queue(li); 344} 345END_TEST 346 347START_TEST(touchpad_4fg_clickfinger_btntool_2slots) 348{ 349 struct litest_device *dev = litest_current_device(); 350 struct libinput *li = dev->libinput; 351 352 if (litest_slot_count(dev) >= 3 || 353 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_QUADTAP)) 354 return; 355 356 litest_enable_clickfinger(dev); 357 358 litest_drain_events(li); 359 360 litest_touch_down(dev, 0, 50, 50); 361 litest_touch_down(dev, 1, 60, 70); 362 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 363 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1); 364 litest_event(dev, EV_SYN, SYN_REPORT, 0); 365 litest_event(dev, EV_KEY, BTN_LEFT, 1); 366 litest_event(dev, EV_SYN, SYN_REPORT, 0); 367 litest_event(dev, EV_KEY, BTN_LEFT, 0); 368 litest_event(dev, EV_SYN, SYN_REPORT, 0); 369 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1); 370 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0); 371 litest_event(dev, EV_SYN, SYN_REPORT, 0); 372 litest_touch_up(dev, 0); 373 litest_touch_up(dev, 1); 374 375 litest_assert_empty_queue(li); 376} 377END_TEST 378 379START_TEST(touchpad_4fg_clickfinger_btntool_3slots) 380{ 381 struct litest_device *dev = litest_current_device(); 382 struct libinput *li = dev->libinput; 383 384 if (litest_slot_count(dev) != 3 || 385 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP)) 386 return; 387 388 litest_enable_clickfinger(dev); 389 390 litest_drain_events(li); 391 392 litest_touch_down(dev, 0, 50, 50); 393 litest_touch_down(dev, 1, 60, 70); 394 litest_touch_down(dev, 2, 70, 70); 395 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0); 396 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1); 397 litest_event(dev, EV_SYN, SYN_REPORT, 0); 398 litest_event(dev, EV_KEY, BTN_LEFT, 1); 399 litest_event(dev, EV_SYN, SYN_REPORT, 0); 400 litest_event(dev, EV_KEY, BTN_LEFT, 0); 401 litest_event(dev, EV_SYN, SYN_REPORT, 0); 402 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1); 403 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0); 404 litest_event(dev, EV_SYN, SYN_REPORT, 0); 405 litest_touch_up(dev, 0); 406 litest_touch_up(dev, 1); 407 litest_touch_up(dev, 2); 408 409 libinput_dispatch(li); 410 411 litest_assert_empty_queue(li); 412} 413END_TEST 414 415START_TEST(touchpad_2fg_clickfinger_distance) 416{ 417 struct litest_device *dev = litest_current_device(); 418 struct libinput *li = dev->libinput; 419 double w, h; 420 bool small_touchpad = false; 421 unsigned int expected_button; 422 423 if (libinput_device_get_size(dev->libinput_device, &w, &h) == 0 && 424 h < 50.0) 425 small_touchpad = true; 426 427 litest_enable_clickfinger(dev); 428 429 litest_drain_events(li); 430 431 litest_touch_down(dev, 0, 90, 50); 432 litest_touch_down(dev, 1, 10, 50); 433 litest_event(dev, EV_KEY, BTN_LEFT, 1); 434 litest_event(dev, EV_SYN, SYN_REPORT, 0); 435 litest_event(dev, EV_KEY, BTN_LEFT, 0); 436 litest_event(dev, EV_SYN, SYN_REPORT, 0); 437 litest_touch_up(dev, 0); 438 litest_touch_up(dev, 1); 439 440 litest_assert_button_event(li, 441 BTN_LEFT, 442 LIBINPUT_BUTTON_STATE_PRESSED); 443 litest_assert_button_event(li, 444 BTN_LEFT, 445 LIBINPUT_BUTTON_STATE_RELEASED); 446 447 litest_assert_empty_queue(li); 448 449 litest_touch_down(dev, 0, 50, 5); 450 litest_touch_down(dev, 1, 50, 95); 451 litest_event(dev, EV_KEY, BTN_LEFT, 1); 452 litest_event(dev, EV_SYN, SYN_REPORT, 0); 453 litest_event(dev, EV_KEY, BTN_LEFT, 0); 454 litest_event(dev, EV_SYN, SYN_REPORT, 0); 455 litest_touch_up(dev, 0); 456 litest_touch_up(dev, 1); 457 458 /* if the touchpad is small enough, we expect all fingers to count 459 * for clickfinger */ 460 if (small_touchpad) 461 expected_button = BTN_RIGHT; 462 else 463 expected_button = BTN_LEFT; 464 465 litest_assert_button_event(li, 466 expected_button, 467 LIBINPUT_BUTTON_STATE_PRESSED); 468 litest_assert_button_event(li, 469 expected_button, 470 LIBINPUT_BUTTON_STATE_RELEASED); 471} 472END_TEST 473 474START_TEST(touchpad_3fg_clickfinger_distance) 475{ 476 struct litest_device *dev = litest_current_device(); 477 struct libinput *li = dev->libinput; 478 479 if (litest_slot_count(dev) < 3) 480 return; 481 482 litest_enable_clickfinger(dev); 483 484 litest_drain_events(li); 485 486 litest_touch_down(dev, 0, 90, 20); 487 litest_touch_down(dev, 1, 10, 15); 488 litest_touch_down(dev, 2, 10, 15); 489 490 litest_event(dev, EV_KEY, BTN_LEFT, 1); 491 litest_event(dev, EV_SYN, SYN_REPORT, 0); 492 litest_event(dev, EV_KEY, BTN_LEFT, 0); 493 litest_event(dev, EV_SYN, SYN_REPORT, 0); 494 litest_touch_up(dev, 0); 495 litest_touch_up(dev, 1); 496 litest_touch_up(dev, 2); 497 498 litest_assert_button_event(li, 499 BTN_MIDDLE, 500 LIBINPUT_BUTTON_STATE_PRESSED); 501 litest_assert_button_event(li, 502 BTN_MIDDLE, 503 LIBINPUT_BUTTON_STATE_RELEASED); 504} 505END_TEST 506 507START_TEST(touchpad_3fg_clickfinger_distance_btntool) 508{ 509 struct litest_device *dev = litest_current_device(); 510 struct libinput *li = dev->libinput; 511 512 if (litest_slot_count(dev) > 2) 513 return; 514 515 litest_enable_clickfinger(dev); 516 517 litest_drain_events(li); 518 519 litest_touch_down(dev, 0, 90, 15); 520 litest_touch_down(dev, 1, 10, 15); 521 libinput_dispatch(li); 522 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 523 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1); 524 litest_event(dev, EV_SYN, SYN_REPORT, 0); 525 libinput_dispatch(li); 526 litest_event(dev, EV_KEY, BTN_LEFT, 1); 527 litest_event(dev, EV_SYN, SYN_REPORT, 0); 528 litest_event(dev, EV_KEY, BTN_LEFT, 0); 529 litest_event(dev, EV_SYN, SYN_REPORT, 0); 530 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1); 531 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0); 532 litest_event(dev, EV_SYN, SYN_REPORT, 0); 533 litest_touch_up(dev, 0); 534 litest_touch_up(dev, 1); 535 536 litest_assert_button_event(li, 537 BTN_MIDDLE, 538 LIBINPUT_BUTTON_STATE_PRESSED); 539 litest_assert_button_event(li, 540 BTN_MIDDLE, 541 LIBINPUT_BUTTON_STATE_RELEASED); 542} 543END_TEST 544 545START_TEST(touchpad_2fg_clickfinger_bottom) 546{ 547 struct litest_device *dev = litest_current_device(); 548 struct libinput *li = dev->libinput; 549 550 /* this test is run for the T440s touchpad only, makes getting the 551 * mm correct easier */ 552 553 libinput_device_config_click_set_method(dev->libinput_device, 554 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 555 litest_drain_events(li); 556 557 /* one above, one below the magic line, vert spread ca 27mm */ 558 litest_touch_down(dev, 0, 40, 60); 559 litest_touch_down(dev, 1, 60, 100); 560 litest_event(dev, EV_KEY, BTN_LEFT, 1); 561 litest_event(dev, EV_SYN, SYN_REPORT, 0); 562 litest_event(dev, EV_KEY, BTN_LEFT, 0); 563 litest_event(dev, EV_SYN, SYN_REPORT, 0); 564 litest_touch_up(dev, 0); 565 litest_touch_up(dev, 1); 566 567 litest_assert_button_event(li, 568 BTN_LEFT, 569 LIBINPUT_BUTTON_STATE_PRESSED); 570 litest_assert_button_event(li, 571 BTN_LEFT, 572 LIBINPUT_BUTTON_STATE_RELEASED); 573 574 litest_assert_empty_queue(li); 575 576 /* both below the magic line */ 577 litest_touch_down(dev, 0, 40, 100); 578 litest_touch_down(dev, 1, 60, 95); 579 litest_event(dev, EV_KEY, BTN_LEFT, 1); 580 litest_event(dev, EV_SYN, SYN_REPORT, 0); 581 litest_event(dev, EV_KEY, BTN_LEFT, 0); 582 litest_event(dev, EV_SYN, SYN_REPORT, 0); 583 litest_touch_up(dev, 0); 584 litest_touch_up(dev, 1); 585 586 litest_assert_button_event(li, 587 BTN_RIGHT, 588 LIBINPUT_BUTTON_STATE_PRESSED); 589 litest_assert_button_event(li, 590 BTN_RIGHT, 591 LIBINPUT_BUTTON_STATE_RELEASED); 592 593 /* one above, one below the magic line, vert spread 17mm */ 594 litest_touch_down(dev, 0, 50, 75); 595 litest_touch_down(dev, 1, 55, 100); 596 litest_event(dev, EV_KEY, BTN_LEFT, 1); 597 litest_event(dev, EV_SYN, SYN_REPORT, 0); 598 litest_event(dev, EV_KEY, BTN_LEFT, 0); 599 litest_event(dev, EV_SYN, SYN_REPORT, 0); 600 litest_touch_up(dev, 0); 601 litest_touch_up(dev, 1); 602 603 litest_assert_button_event(li, 604 BTN_RIGHT, 605 LIBINPUT_BUTTON_STATE_PRESSED); 606 litest_assert_button_event(li, 607 BTN_RIGHT, 608 LIBINPUT_BUTTON_STATE_RELEASED); 609} 610END_TEST 611 612START_TEST(touchpad_clickfinger_to_area_method) 613{ 614 struct litest_device *dev = litest_current_device(); 615 struct libinput *li = dev->libinput; 616 617 litest_drain_events(li); 618 619 litest_enable_buttonareas(dev); 620 621 litest_touch_down(dev, 0, 95, 95); 622 litest_event(dev, EV_KEY, BTN_LEFT, 1); 623 litest_event(dev, EV_SYN, SYN_REPORT, 0); 624 litest_event(dev, EV_KEY, BTN_LEFT, 0); 625 litest_event(dev, EV_SYN, SYN_REPORT, 0); 626 litest_touch_up(dev, 0); 627 libinput_dispatch(li); 628 629 litest_assert_button_event(li, BTN_RIGHT, 630 LIBINPUT_BUTTON_STATE_PRESSED); 631 litest_assert_button_event(li, BTN_RIGHT, 632 LIBINPUT_BUTTON_STATE_RELEASED); 633 634 litest_enable_clickfinger(dev); 635 636 litest_drain_events(li); 637 638 /* use bottom right corner to catch accidental softbutton right */ 639 litest_touch_down(dev, 0, 95, 95); 640 litest_event(dev, EV_KEY, BTN_LEFT, 1); 641 litest_event(dev, EV_SYN, SYN_REPORT, 0); 642 litest_event(dev, EV_KEY, BTN_LEFT, 0); 643 litest_event(dev, EV_SYN, SYN_REPORT, 0); 644 litest_touch_up(dev, 0); 645 libinput_dispatch(li); 646 647 litest_assert_button_event(li, BTN_LEFT, 648 LIBINPUT_BUTTON_STATE_PRESSED); 649 litest_assert_button_event(li, BTN_LEFT, 650 LIBINPUT_BUTTON_STATE_RELEASED); 651 652} 653END_TEST 654 655START_TEST(touchpad_clickfinger_to_area_method_while_down) 656{ 657 struct litest_device *dev = litest_current_device(); 658 struct libinput *li = dev->libinput; 659 660 litest_drain_events(li); 661 662 litest_enable_buttonareas(dev); 663 664 litest_touch_down(dev, 0, 95, 95); 665 litest_event(dev, EV_KEY, BTN_LEFT, 1); 666 litest_event(dev, EV_SYN, SYN_REPORT, 0); 667 libinput_dispatch(li); 668 litest_assert_button_event(li, BTN_RIGHT, 669 LIBINPUT_BUTTON_STATE_PRESSED); 670 671 litest_enable_clickfinger(dev); 672 673 litest_event(dev, EV_KEY, BTN_LEFT, 0); 674 litest_event(dev, EV_SYN, SYN_REPORT, 0); 675 litest_touch_up(dev, 0); 676 libinput_dispatch(li); 677 678 litest_assert_button_event(li, BTN_RIGHT, 679 LIBINPUT_BUTTON_STATE_RELEASED); 680 681 litest_drain_events(li); 682 683 /* use bottom right corner to catch accidental softbutton right */ 684 litest_touch_down(dev, 0, 95, 95); 685 litest_event(dev, EV_KEY, BTN_LEFT, 1); 686 litest_event(dev, EV_SYN, SYN_REPORT, 0); 687 litest_event(dev, EV_KEY, BTN_LEFT, 0); 688 litest_event(dev, EV_SYN, SYN_REPORT, 0); 689 litest_touch_up(dev, 0); 690 libinput_dispatch(li); 691 692 litest_assert_button_event(li, BTN_LEFT, 693 LIBINPUT_BUTTON_STATE_PRESSED); 694 litest_assert_button_event(li, BTN_LEFT, 695 LIBINPUT_BUTTON_STATE_RELEASED); 696 697} 698END_TEST 699 700START_TEST(touchpad_area_to_clickfinger_method) 701{ 702 struct litest_device *dev = litest_current_device(); 703 struct libinput *li = dev->libinput; 704 705 litest_enable_clickfinger(dev); 706 707 litest_drain_events(li); 708 709 /* use bottom right corner to catch accidental softbutton right */ 710 litest_touch_down(dev, 0, 95, 95); 711 litest_event(dev, EV_KEY, BTN_LEFT, 1); 712 litest_event(dev, EV_SYN, SYN_REPORT, 0); 713 litest_event(dev, EV_KEY, BTN_LEFT, 0); 714 litest_event(dev, EV_SYN, SYN_REPORT, 0); 715 litest_touch_up(dev, 0); 716 libinput_dispatch(li); 717 718 litest_assert_button_event(li, BTN_LEFT, 719 LIBINPUT_BUTTON_STATE_PRESSED); 720 litest_assert_button_event(li, BTN_LEFT, 721 LIBINPUT_BUTTON_STATE_RELEASED); 722 723 litest_enable_buttonareas(dev); 724 725 litest_touch_down(dev, 0, 95, 95); 726 litest_event(dev, EV_KEY, BTN_LEFT, 1); 727 litest_event(dev, EV_SYN, SYN_REPORT, 0); 728 litest_event(dev, EV_KEY, BTN_LEFT, 0); 729 litest_event(dev, EV_SYN, SYN_REPORT, 0); 730 litest_touch_up(dev, 0); 731 libinput_dispatch(li); 732 733 litest_assert_button_event(li, BTN_RIGHT, 734 LIBINPUT_BUTTON_STATE_PRESSED); 735 litest_assert_button_event(li, BTN_RIGHT, 736 LIBINPUT_BUTTON_STATE_RELEASED); 737 738} 739END_TEST 740 741START_TEST(touchpad_area_to_clickfinger_method_while_down) 742{ 743 struct litest_device *dev = litest_current_device(); 744 struct libinput *li = dev->libinput; 745 746 litest_enable_clickfinger(dev); 747 748 litest_drain_events(li); 749 750 /* use bottom right corner to catch accidental softbutton right */ 751 litest_touch_down(dev, 0, 95, 95); 752 litest_event(dev, EV_KEY, BTN_LEFT, 1); 753 litest_event(dev, EV_SYN, SYN_REPORT, 0); 754 litest_assert_button_event(li, BTN_LEFT, 755 LIBINPUT_BUTTON_STATE_PRESSED); 756 757 litest_enable_buttonareas(dev); 758 759 litest_event(dev, EV_KEY, BTN_LEFT, 0); 760 litest_event(dev, EV_SYN, SYN_REPORT, 0); 761 litest_touch_up(dev, 0); 762 libinput_dispatch(li); 763 764 litest_assert_button_event(li, BTN_LEFT, 765 LIBINPUT_BUTTON_STATE_RELEASED); 766 767 litest_touch_down(dev, 0, 95, 95); 768 litest_event(dev, EV_KEY, BTN_LEFT, 1); 769 litest_event(dev, EV_SYN, SYN_REPORT, 0); 770 litest_event(dev, EV_KEY, BTN_LEFT, 0); 771 litest_event(dev, EV_SYN, SYN_REPORT, 0); 772 litest_touch_up(dev, 0); 773 libinput_dispatch(li); 774 775 litest_assert_button_event(li, BTN_RIGHT, 776 LIBINPUT_BUTTON_STATE_PRESSED); 777 litest_assert_button_event(li, BTN_RIGHT, 778 LIBINPUT_BUTTON_STATE_RELEASED); 779 780} 781END_TEST 782 783START_TEST(touchpad_clickfinger_3fg_tool_position) 784{ 785 struct litest_device *dev = litest_current_device(); 786 struct libinput *li = dev->libinput; 787 788 litest_enable_clickfinger(dev); 789 litest_drain_events(li); 790 791 /* one in thumb area, one in normal area + TRIPLETAP. spread is wide 792 * but any non-palm 3fg touch+click counts as middle */ 793 litest_touch_down(dev, 0, 20, 99); 794 litest_touch_down(dev, 1, 90, 15); 795 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 796 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1); 797 litest_event(dev, EV_SYN, SYN_REPORT, 0); 798 libinput_dispatch(li); 799 800 litest_event(dev, EV_KEY, BTN_LEFT, 1); 801 litest_event(dev, EV_SYN, SYN_REPORT, 0); 802 litest_event(dev, EV_KEY, BTN_LEFT, 0); 803 litest_event(dev, EV_SYN, SYN_REPORT, 0); 804 libinput_dispatch(li); 805 806 litest_assert_button_event(li, BTN_RIGHT, 807 LIBINPUT_BUTTON_STATE_PRESSED); 808 litest_assert_button_event(li, BTN_RIGHT, 809 LIBINPUT_BUTTON_STATE_RELEASED); 810} 811END_TEST 812 813START_TEST(touchpad_clickfinger_4fg_tool_position) 814{ 815 struct litest_device *dev = litest_current_device(); 816 struct libinput *li = dev->libinput; 817 818 litest_enable_clickfinger(dev); 819 litest_drain_events(li); 820 821 litest_touch_down(dev, 0, 5, 99); 822 litest_touch_down(dev, 1, 90, 15); 823 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 824 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1); 825 litest_event(dev, EV_SYN, SYN_REPORT, 0); 826 libinput_dispatch(li); 827 828 litest_event(dev, EV_KEY, BTN_LEFT, 1); 829 litest_event(dev, EV_SYN, SYN_REPORT, 0); 830 litest_event(dev, EV_KEY, BTN_LEFT, 0); 831 litest_event(dev, EV_SYN, SYN_REPORT, 0); 832 libinput_dispatch(li); 833 834 litest_assert_button_event(li, 835 BTN_MIDDLE, 836 LIBINPUT_BUTTON_STATE_PRESSED); 837 litest_assert_button_event(li, 838 BTN_MIDDLE, 839 LIBINPUT_BUTTON_STATE_RELEASED); 840} 841END_TEST 842 843START_TEST(touchpad_clickfinger_appletouch_config) 844{ 845 struct litest_device *dev = litest_current_device(); 846 struct libinput_device *device = dev->libinput_device; 847 uint32_t methods, method; 848 enum libinput_config_status status; 849 850 methods = libinput_device_config_click_get_methods(device); 851 ck_assert(!(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS)); 852 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 853 854 method = libinput_device_config_click_get_method(device); 855 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 856 857 status = libinput_device_config_click_set_method(device, 858 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 859 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED); 860 status = libinput_device_config_click_set_method(device, 861 LIBINPUT_CONFIG_CLICK_METHOD_NONE); 862 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 863} 864END_TEST 865 866START_TEST(touchpad_clickfinger_appletouch_1fg) 867{ 868 struct litest_device *dev = litest_current_device(); 869 struct libinput *li = dev->libinput; 870 871 litest_enable_clickfinger(dev); 872 873 litest_drain_events(li); 874 875 litest_touch_down(dev, 0, 50, 50); 876 litest_event(dev, EV_KEY, BTN_LEFT, 1); 877 litest_event(dev, EV_SYN, SYN_REPORT, 0); 878 litest_event(dev, EV_KEY, BTN_LEFT, 0); 879 litest_event(dev, EV_SYN, SYN_REPORT, 0); 880 litest_touch_up(dev, 0); 881 882 libinput_dispatch(li); 883 884 litest_assert_button_event(li, BTN_LEFT, 885 LIBINPUT_BUTTON_STATE_PRESSED); 886 litest_assert_button_event(li, BTN_LEFT, 887 LIBINPUT_BUTTON_STATE_RELEASED); 888} 889END_TEST 890 891START_TEST(touchpad_clickfinger_appletouch_2fg) 892{ 893 struct litest_device *dev = litest_current_device(); 894 struct libinput *li = dev->libinput; 895 896 litest_enable_clickfinger(dev); 897 898 litest_drain_events(li); 899 900 litest_touch_down(dev, 0, 50, 50); 901 litest_touch_down(dev, 1, 50, 50); 902 litest_event(dev, EV_KEY, BTN_LEFT, 1); 903 litest_event(dev, EV_SYN, SYN_REPORT, 0); 904 litest_event(dev, EV_KEY, BTN_LEFT, 0); 905 litest_event(dev, EV_SYN, SYN_REPORT, 0); 906 litest_touch_up(dev, 0); 907 litest_touch_up(dev, 1); 908 909 libinput_dispatch(li); 910 911 litest_assert_button_event(li, BTN_RIGHT, 912 LIBINPUT_BUTTON_STATE_PRESSED); 913 litest_assert_button_event(li, BTN_RIGHT, 914 LIBINPUT_BUTTON_STATE_RELEASED); 915} 916END_TEST 917 918START_TEST(touchpad_clickfinger_appletouch_3fg) 919{ 920 struct litest_device *dev = litest_current_device(); 921 struct libinput *li = dev->libinput; 922 923 litest_enable_clickfinger(dev); 924 925 litest_drain_events(li); 926 927 litest_touch_down(dev, 0, 50, 50); 928 litest_touch_down(dev, 1, 50, 50); 929 litest_touch_down(dev, 2, 50, 50); 930 litest_event(dev, EV_KEY, BTN_LEFT, 1); 931 litest_event(dev, EV_SYN, SYN_REPORT, 0); 932 litest_event(dev, EV_KEY, BTN_LEFT, 0); 933 litest_event(dev, EV_SYN, SYN_REPORT, 0); 934 litest_touch_up(dev, 0); 935 litest_touch_up(dev, 1); 936 litest_touch_up(dev, 2); 937 938 libinput_dispatch(li); 939 940 litest_assert_button_event(li, BTN_MIDDLE, 941 LIBINPUT_BUTTON_STATE_PRESSED); 942 litest_assert_button_event(li, BTN_MIDDLE, 943 LIBINPUT_BUTTON_STATE_RELEASED); 944} 945END_TEST 946 947START_TEST(touchpad_clickfinger_click_drag) 948{ 949 struct litest_device *dev = litest_current_device(); 950 struct libinput *li = dev->libinput; 951 int nfingers = _i; /* ranged test */ 952 unsigned int button; 953 int nslots = litest_slot_count(dev); 954 955 litest_enable_clickfinger(dev); 956 litest_drain_events(li); 957 958 litest_touch_down(dev, 0, 40, 50); 959 button = BTN_LEFT; 960 961 if (nfingers > 1) { 962 if (nslots > 1) { 963 litest_touch_down(dev, 1, 50, 50); 964 } else { 965 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1); 966 } 967 button = BTN_RIGHT; 968 } 969 970 if (nfingers > 2) { 971 if (nslots > 2) { 972 litest_touch_down(dev, 2, 60, 50); 973 } else { 974 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 975 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1); 976 } 977 button = BTN_MIDDLE; 978 } 979 980 litest_button_click(dev, BTN_LEFT, true); 981 982 libinput_dispatch(li); 983 litest_assert_button_event(li, button, 984 LIBINPUT_BUTTON_STATE_PRESSED); 985 986 for (int i = 0; i < 20; i++) { 987 litest_push_event_frame(dev); 988 switch (nfingers) { 989 case 3: 990 if (nslots >= nfingers) 991 litest_touch_move(dev, 2, 60, 50 + i); 992 _fallthrough_; 993 case 2: 994 if (nslots >= nfingers) 995 litest_touch_move(dev, 1, 50, 50 + i); 996 _fallthrough_; 997 case 1: 998 litest_touch_move(dev, 0, 40, 50 + i); 999 break; 1000 } 1001 litest_pop_event_frame(dev); 1002 libinput_dispatch(li); 1003 } 1004 1005 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION); 1006 1007 litest_button_click(dev, BTN_LEFT, false); 1008 litest_assert_button_event(li, button, 1009 LIBINPUT_BUTTON_STATE_RELEASED); 1010 1011 if (nfingers > 3) { 1012 if (nslots > 3) { 1013 litest_touch_up(dev, 2); 1014 } else { 1015 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1); 1016 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0); 1017 } 1018 } 1019 1020 if (nfingers > 2) { 1021 if (nslots > 2) { 1022 litest_touch_up(dev, 1); 1023 } else { 1024 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0); 1025 } 1026 } 1027 1028 litest_touch_up(dev, 0); 1029 1030 1031 libinput_dispatch(li); 1032 litest_assert_empty_queue(li); 1033} 1034END_TEST 1035 1036START_TEST(touchpad_btn_left) 1037{ 1038 struct litest_device *dev = litest_current_device(); 1039 struct libinput *li = dev->libinput; 1040 1041 litest_drain_events(li); 1042 1043 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1044 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1045 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1046 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1047 1048 libinput_dispatch(li); 1049 1050 litest_assert_button_event(li, BTN_LEFT, 1051 LIBINPUT_BUTTON_STATE_PRESSED); 1052 litest_assert_button_event(li, BTN_LEFT, 1053 LIBINPUT_BUTTON_STATE_RELEASED); 1054} 1055END_TEST 1056 1057START_TEST(clickpad_btn_left) 1058{ 1059 struct litest_device *dev = litest_current_device(); 1060 struct libinput *li = dev->libinput; 1061 1062 litest_enable_buttonareas(dev); 1063 1064 litest_drain_events(li); 1065 1066 /* A clickpad always needs a finger down to tell where the 1067 click happens */ 1068 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1069 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1070 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1071 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1072 1073 libinput_dispatch(li); 1074 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE); 1075} 1076END_TEST 1077 1078START_TEST(clickpad_click_n_drag) 1079{ 1080 struct litest_device *dev = litest_current_device(); 1081 struct libinput *li = dev->libinput; 1082 1083 litest_drain_events(li); 1084 1085 litest_touch_down(dev, 0, 50, 50); 1086 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1087 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1088 1089 libinput_dispatch(li); 1090 litest_assert_button_event(li, BTN_LEFT, 1091 LIBINPUT_BUTTON_STATE_PRESSED); 1092 1093 libinput_dispatch(li); 1094 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE); 1095 1096 /* now put a second finger down */ 1097 litest_touch_down(dev, 1, 70, 70); 1098 litest_touch_move_to(dev, 1, 70, 70, 80, 50, 5); 1099 litest_touch_up(dev, 1); 1100 1101 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION); 1102 1103 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1104 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1105 litest_touch_up(dev, 0); 1106 1107 litest_assert_button_event(li, BTN_LEFT, 1108 LIBINPUT_BUTTON_STATE_RELEASED); 1109} 1110END_TEST 1111 1112START_TEST(clickpad_finger_pin) 1113{ 1114 struct litest_device *dev = litest_current_device(); 1115 struct libinput *li = dev->libinput; 1116 struct libevdev *evdev = dev->evdev; 1117 const struct input_absinfo *abs; 1118 double w, h; 1119 double dist; 1120 1121 abs = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X); 1122 ck_assert_notnull(abs); 1123 if (abs->resolution == 0) 1124 return; 1125 1126 if (libinput_device_get_size(dev->libinput_device, &w, &h) != 0) 1127 return; 1128 1129 dist = 100.0/max(w, h); 1130 1131 litest_drain_events(li); 1132 1133 /* make sure the movement generates pointer events when 1134 not pinned */ 1135 litest_touch_down(dev, 0, 50, 50); 1136 litest_touch_move_to(dev, 0, 50, 50, 54, 54, 10); 1137 litest_touch_move_to(dev, 0, 54, 54, 46, 46, 10); 1138 litest_touch_move_to(dev, 0, 46, 46, 50, 50, 10); 1139 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION); 1140 1141 litest_button_click(dev, BTN_LEFT, true); 1142 litest_drain_events(li); 1143 1144 litest_touch_move_to(dev, 0, 50, 50, 50 + dist, 50 + dist, 10); 1145 litest_touch_move_to(dev, 0, 50 + dist, 50 + dist, 50, 50, 10); 1146 litest_touch_move_to(dev, 0, 50, 50, 50 - dist, 50 - dist, 10); 1147 1148 litest_assert_empty_queue(li); 1149 1150 litest_button_click(dev, BTN_LEFT, false); 1151 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON); 1152 1153 /* still pinned after release */ 1154 litest_touch_move_to(dev, 0, 50, 50, 50 + dist, 50 + dist, 10); 1155 litest_touch_move_to(dev, 0, 50 + dist, 50 + dist, 50, 50, 10); 1156 litest_touch_move_to(dev, 0, 50, 50, 50 - dist, 50 - dist, 10); 1157 1158 litest_assert_empty_queue(li); 1159 1160 /* move to unpin */ 1161 litest_touch_move_to(dev, 0, 50, 50, 70, 70, 10); 1162 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION); 1163} 1164END_TEST 1165 1166START_TEST(clickpad_softbutton_left) 1167{ 1168 struct litest_device *dev = litest_current_device(); 1169 struct libinput *li = dev->libinput; 1170 1171 litest_drain_events(li); 1172 1173 litest_touch_down(dev, 0, 10, 90); 1174 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1175 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1176 1177 litest_assert_button_event(li, 1178 BTN_LEFT, 1179 LIBINPUT_BUTTON_STATE_PRESSED); 1180 1181 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1182 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1183 litest_touch_up(dev, 0); 1184 1185 litest_assert_button_event(li, 1186 BTN_LEFT, 1187 LIBINPUT_BUTTON_STATE_RELEASED); 1188 1189 libinput_dispatch(li); 1190 1191 litest_assert_empty_queue(li); 1192} 1193END_TEST 1194 1195START_TEST(clickpad_softbutton_middle) 1196{ 1197 struct litest_device *dev = litest_current_device(); 1198 struct libinput *li = dev->libinput; 1199 1200 litest_drain_events(li); 1201 1202 litest_touch_down(dev, 0, 50, 90); 1203 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1204 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1205 1206 litest_assert_button_event(li, 1207 BTN_MIDDLE, 1208 LIBINPUT_BUTTON_STATE_PRESSED); 1209 1210 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1211 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1212 litest_touch_up(dev, 0); 1213 1214 litest_assert_button_event(li, 1215 BTN_MIDDLE, 1216 LIBINPUT_BUTTON_STATE_RELEASED); 1217 1218 libinput_dispatch(li); 1219 1220 litest_assert_empty_queue(li); 1221} 1222END_TEST 1223 1224START_TEST(clickpad_softbutton_right) 1225{ 1226 struct litest_device *dev = litest_current_device(); 1227 struct libinput *li = dev->libinput; 1228 1229 litest_drain_events(li); 1230 1231 litest_touch_down(dev, 0, 90, 90); 1232 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1233 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1234 1235 litest_assert_button_event(li, 1236 BTN_RIGHT, 1237 LIBINPUT_BUTTON_STATE_PRESSED); 1238 1239 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1240 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1241 litest_touch_up(dev, 0); 1242 1243 litest_assert_button_event(li, 1244 BTN_RIGHT, 1245 LIBINPUT_BUTTON_STATE_RELEASED); 1246 1247 libinput_dispatch(li); 1248 1249 litest_assert_empty_queue(li); 1250} 1251END_TEST 1252 1253START_TEST(clickpad_softbutton_left_tap_n_drag) 1254{ 1255 struct litest_device *dev = litest_current_device(); 1256 struct libinput *li = dev->libinput; 1257 1258 litest_enable_tap(dev->libinput_device); 1259 1260 litest_drain_events(li); 1261 1262 /* Tap in left button area, then finger down, button click 1263 -> expect left button press/release and left button press 1264 Release button, finger up 1265 -> expect right button release 1266 */ 1267 litest_touch_down(dev, 0, 20, 90); 1268 litest_touch_up(dev, 0); 1269 litest_touch_down(dev, 0, 20, 90); 1270 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1271 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1272 1273 litest_assert_button_event(li, 1274 BTN_LEFT, 1275 LIBINPUT_BUTTON_STATE_PRESSED); 1276 litest_assert_button_event(li, 1277 BTN_LEFT, 1278 LIBINPUT_BUTTON_STATE_RELEASED); 1279 litest_assert_button_event(li, 1280 BTN_LEFT, 1281 LIBINPUT_BUTTON_STATE_PRESSED); 1282 litest_assert_empty_queue(li); 1283 1284 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1285 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1286 litest_touch_up(dev, 0); 1287 1288 litest_assert_button_event(li, 1289 BTN_LEFT, 1290 LIBINPUT_BUTTON_STATE_RELEASED); 1291 litest_assert_empty_queue(li); 1292} 1293END_TEST 1294 1295START_TEST(clickpad_softbutton_right_tap_n_drag) 1296{ 1297 struct litest_device *dev = litest_current_device(); 1298 struct libinput *li = dev->libinput; 1299 1300 litest_enable_tap(dev->libinput_device); 1301 1302 litest_drain_events(li); 1303 1304 /* Tap in right button area, then finger down, button click 1305 -> expect left button press/release and right button press 1306 Release button, finger up 1307 -> expect right button release 1308 */ 1309 litest_touch_down(dev, 0, 90, 90); 1310 litest_touch_up(dev, 0); 1311 litest_touch_down(dev, 0, 90, 90); 1312 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1313 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1314 1315 litest_assert_button_event(li, 1316 BTN_LEFT, 1317 LIBINPUT_BUTTON_STATE_PRESSED); 1318 litest_assert_button_event(li, 1319 BTN_LEFT, 1320 LIBINPUT_BUTTON_STATE_RELEASED); 1321 litest_assert_button_event(li, 1322 BTN_RIGHT, 1323 LIBINPUT_BUTTON_STATE_PRESSED); 1324 litest_assert_empty_queue(li); 1325 1326 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1327 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1328 litest_touch_up(dev, 0); 1329 1330 litest_assert_button_event(li, 1331 BTN_RIGHT, 1332 LIBINPUT_BUTTON_STATE_RELEASED); 1333 litest_assert_empty_queue(li); 1334} 1335END_TEST 1336 1337START_TEST(clickpad_softbutton_left_1st_fg_move) 1338{ 1339 struct litest_device *dev = litest_current_device(); 1340 struct libinput *li = dev->libinput; 1341 struct libinput_event *event; 1342 double x = 0, y = 0; 1343 int nevents = 0; 1344 1345 litest_drain_events(li); 1346 1347 /* One finger down in the left button area, button press 1348 -> expect a button event 1349 Move finger up out of the area, wait for timeout 1350 Move finger around diagonally down left 1351 -> expect motion events down left 1352 Release finger 1353 -> expect a button event */ 1354 1355 /* finger down, press in left button */ 1356 litest_touch_down(dev, 0, 20, 90); 1357 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1358 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1359 1360 litest_assert_button_event(li, 1361 BTN_LEFT, 1362 LIBINPUT_BUTTON_STATE_PRESSED); 1363 litest_assert_empty_queue(li); 1364 1365 /* move out of the area, then wait for softbutton timer */ 1366 litest_touch_move_to(dev, 0, 20, 90, 50, 50, 20); 1367 libinput_dispatch(li); 1368 litest_timeout_softbuttons(); 1369 libinput_dispatch(li); 1370 litest_drain_events(li); 1371 1372 /* move down left, expect motion */ 1373 litest_touch_move_to(dev, 0, 50, 50, 20, 90, 20); 1374 1375 libinput_dispatch(li); 1376 event = libinput_get_event(li); 1377 ck_assert_notnull(event); 1378 while (event) { 1379 struct libinput_event_pointer *p; 1380 1381 ck_assert_int_eq(libinput_event_get_type(event), 1382 LIBINPUT_EVENT_POINTER_MOTION); 1383 p = libinput_event_get_pointer_event(event); 1384 1385 /* we moved up/right, now down/left so the pointer accel 1386 code may lag behind with the dx/dy vectors. Hence, add up 1387 the x/y movements and expect that on average we moved 1388 left and down */ 1389 x += libinput_event_pointer_get_dx(p); 1390 y += libinput_event_pointer_get_dy(p); 1391 nevents++; 1392 1393 libinput_event_destroy(event); 1394 libinput_dispatch(li); 1395 event = libinput_get_event(li); 1396 } 1397 1398 ck_assert(x/nevents < 0); 1399 ck_assert(y/nevents > 0); 1400 1401 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1402 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1403 litest_touch_up(dev, 0); 1404 1405 litest_assert_button_event(li, 1406 BTN_LEFT, 1407 LIBINPUT_BUTTON_STATE_RELEASED); 1408 1409 litest_assert_empty_queue(li); 1410} 1411END_TEST 1412 1413START_TEST(clickpad_softbutton_left_2nd_fg_move) 1414{ 1415 struct litest_device *dev = litest_current_device(); 1416 struct libinput *li = dev->libinput; 1417 struct libinput_event *event; 1418 1419 litest_drain_events(li); 1420 1421 /* One finger down in the left button area, button press 1422 -> expect a button event 1423 Put a second finger down in the area, move it right, release 1424 -> expect motion events right 1425 Put a second finger down in the area, move it down, release 1426 -> expect motion events down 1427 Release second finger, release first finger 1428 -> expect a button event */ 1429 litest_touch_down(dev, 0, 20, 90); 1430 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1431 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1432 1433 litest_assert_button_event(li, 1434 BTN_LEFT, 1435 LIBINPUT_BUTTON_STATE_PRESSED); 1436 litest_assert_empty_queue(li); 1437 1438 litest_touch_down(dev, 1, 20, 20); 1439 litest_touch_move_to(dev, 1, 20, 20, 80, 20, 15); 1440 1441 libinput_dispatch(li); 1442 event = libinput_get_event(li); 1443 ck_assert_notnull(event); 1444 while (event) { 1445 struct libinput_event_pointer *p; 1446 double x, y; 1447 1448 ck_assert_int_eq(libinput_event_get_type(event), 1449 LIBINPUT_EVENT_POINTER_MOTION); 1450 p = libinput_event_get_pointer_event(event); 1451 1452 x = libinput_event_pointer_get_dx(p); 1453 y = libinput_event_pointer_get_dy(p); 1454 1455 /* Ignore events only containing an unaccelerated motion 1456 * vector. */ 1457 if (x != 0 || y != 0) { 1458 ck_assert(x > 0); 1459 ck_assert(y == 0); 1460 } 1461 1462 libinput_event_destroy(event); 1463 libinput_dispatch(li); 1464 event = libinput_get_event(li); 1465 } 1466 litest_touch_up(dev, 1); 1467 1468 /* second finger down */ 1469 litest_touch_down(dev, 1, 20, 20); 1470 litest_touch_move_to(dev, 1, 20, 20, 20, 80, 15); 1471 1472 libinput_dispatch(li); 1473 event = libinput_get_event(li); 1474 ck_assert_notnull(event); 1475 while (event) { 1476 struct libinput_event_pointer *p; 1477 double x, y; 1478 1479 ck_assert_int_eq(libinput_event_get_type(event), 1480 LIBINPUT_EVENT_POINTER_MOTION); 1481 p = libinput_event_get_pointer_event(event); 1482 1483 x = libinput_event_pointer_get_dx(p); 1484 y = libinput_event_pointer_get_dy(p); 1485 1486 ck_assert(x == 0); 1487 ck_assert(y > 0); 1488 1489 libinput_event_destroy(event); 1490 libinput_dispatch(li); 1491 event = libinput_get_event(li); 1492 } 1493 1494 litest_touch_up(dev, 1); 1495 1496 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1497 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1498 litest_touch_up(dev, 0); 1499 1500 litest_assert_button_event(li, 1501 BTN_LEFT, 1502 LIBINPUT_BUTTON_STATE_RELEASED); 1503 1504 litest_assert_empty_queue(li); 1505} 1506END_TEST 1507 1508START_TEST(clickpad_softbutton_left_to_right) 1509{ 1510 struct litest_device *dev = litest_current_device(); 1511 struct libinput *li = dev->libinput; 1512 1513 litest_drain_events(li); 1514 1515 /* One finger down in left software button area, 1516 move to right button area immediately, click 1517 -> expect right button event 1518 */ 1519 1520 litest_touch_down(dev, 0, 30, 90); 1521 litest_touch_move_to(dev, 0, 30, 90, 90, 90, 15); 1522 litest_drain_events(li); 1523 1524 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1525 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1526 1527 litest_assert_button_event(li, 1528 BTN_RIGHT, 1529 LIBINPUT_BUTTON_STATE_PRESSED); 1530 litest_assert_empty_queue(li); 1531 1532 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1533 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1534 litest_touch_up(dev, 0); 1535 1536 litest_assert_button_event(li, 1537 BTN_RIGHT, 1538 LIBINPUT_BUTTON_STATE_RELEASED); 1539 1540 litest_assert_empty_queue(li); 1541} 1542END_TEST 1543 1544START_TEST(clickpad_softbutton_right_to_left) 1545{ 1546 struct litest_device *dev = litest_current_device(); 1547 struct libinput *li = dev->libinput; 1548 1549 litest_drain_events(li); 1550 1551 /* One finger down in right software button area, 1552 move to left button area immediately, click 1553 -> expect left button event 1554 */ 1555 1556 litest_touch_down(dev, 0, 80, 90); 1557 litest_touch_move_to(dev, 0, 80, 90, 30, 90, 15); 1558 litest_drain_events(li); 1559 1560 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1561 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1562 1563 litest_assert_button_event(li, 1564 BTN_LEFT, 1565 LIBINPUT_BUTTON_STATE_PRESSED); 1566 litest_assert_empty_queue(li); 1567 1568 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1569 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1570 litest_touch_up(dev, 0); 1571 1572 litest_assert_button_event(li, 1573 BTN_LEFT, 1574 LIBINPUT_BUTTON_STATE_RELEASED); 1575 1576 litest_assert_empty_queue(li); 1577} 1578END_TEST 1579 1580START_TEST(clickpad_softbutton_hover_into_buttons) 1581{ 1582 struct litest_device *dev = litest_current_device(); 1583 struct libinput *li = dev->libinput; 1584 1585 litest_drain_events(li); 1586 1587 litest_hover_start(dev, 0, 50, 50); 1588 libinput_dispatch(li); 1589 litest_hover_move_to(dev, 0, 50, 50, 90, 90, 10); 1590 libinput_dispatch(li); 1591 1592 litest_touch_move_to(dev, 0, 90, 90, 91, 91, 1); 1593 1594 litest_button_click(dev, BTN_LEFT, true); 1595 libinput_dispatch(li); 1596 1597 litest_assert_button_event(li, 1598 BTN_RIGHT, 1599 LIBINPUT_BUTTON_STATE_PRESSED); 1600 litest_assert_empty_queue(li); 1601 1602 litest_button_click(dev, BTN_LEFT, false); 1603 litest_touch_up(dev, 0); 1604 1605 litest_assert_button_event(li, 1606 BTN_RIGHT, 1607 LIBINPUT_BUTTON_STATE_RELEASED); 1608} 1609END_TEST 1610 1611START_TEST(clickpad_topsoftbuttons_left) 1612{ 1613 struct litest_device *dev = litest_current_device(); 1614 struct libinput *li = dev->libinput; 1615 1616 litest_drain_events(li); 1617 1618 litest_touch_down(dev, 0, 10, 5); 1619 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1620 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1621 1622 litest_assert_button_event(li, 1623 BTN_LEFT, 1624 LIBINPUT_BUTTON_STATE_PRESSED); 1625 litest_assert_empty_queue(li); 1626 1627 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1628 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1629 litest_touch_up(dev, 0); 1630 1631 litest_assert_button_event(li, 1632 BTN_LEFT, 1633 LIBINPUT_BUTTON_STATE_RELEASED); 1634 1635 litest_assert_empty_queue(li); 1636} 1637END_TEST 1638 1639START_TEST(clickpad_topsoftbuttons_right) 1640{ 1641 struct litest_device *dev = litest_current_device(); 1642 struct libinput *li = dev->libinput; 1643 1644 litest_drain_events(li); 1645 1646 litest_touch_down(dev, 0, 90, 5); 1647 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1648 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1649 1650 litest_assert_button_event(li, 1651 BTN_RIGHT, 1652 LIBINPUT_BUTTON_STATE_PRESSED); 1653 litest_assert_empty_queue(li); 1654 1655 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1656 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1657 litest_touch_up(dev, 0); 1658 1659 litest_assert_button_event(li, 1660 BTN_RIGHT, 1661 LIBINPUT_BUTTON_STATE_RELEASED); 1662 1663 litest_assert_empty_queue(li); 1664} 1665END_TEST 1666 1667START_TEST(clickpad_topsoftbuttons_middle) 1668{ 1669 struct litest_device *dev = litest_current_device(); 1670 struct libinput *li = dev->libinput; 1671 1672 litest_drain_events(li); 1673 1674 litest_touch_down(dev, 0, 50, 5); 1675 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1676 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1677 1678 litest_assert_button_event(li, 1679 BTN_MIDDLE, 1680 LIBINPUT_BUTTON_STATE_PRESSED); 1681 litest_assert_empty_queue(li); 1682 1683 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1684 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1685 litest_touch_up(dev, 0); 1686 1687 litest_assert_button_event(li, 1688 BTN_MIDDLE, 1689 LIBINPUT_BUTTON_STATE_RELEASED); 1690 1691 litest_assert_empty_queue(li); 1692} 1693END_TEST 1694 1695START_TEST(clickpad_topsoftbuttons_move_out_leftclick_before_timeout) 1696{ 1697 struct litest_device *dev = litest_current_device(); 1698 struct libinput *li = dev->libinput; 1699 1700 /* Finger down in top right button area, wait past enter timeout 1701 Move into main area, wait past leave timeout 1702 Click 1703 -> expect left click 1704 */ 1705 1706 litest_drain_events(li); 1707 1708 litest_touch_down(dev, 0, 80, 5); 1709 libinput_dispatch(li); 1710 litest_timeout_softbuttons(); 1711 libinput_dispatch(li); 1712 litest_assert_empty_queue(li); 1713 1714 litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20); 1715 libinput_dispatch(li); 1716 1717 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1718 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1719 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1720 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1721 1722 litest_touch_up(dev, 0); 1723 1724 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED); 1725 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED); 1726} 1727END_TEST 1728 1729START_TEST(clickpad_topsoftbuttons_move_out_leftclick) 1730{ 1731 struct litest_device *dev = litest_current_device(); 1732 struct libinput *li = dev->libinput; 1733 1734 /* Finger down in top right button area, wait past enter timeout 1735 Move into main area, wait past leave timeout 1736 Click 1737 -> expect left click 1738 */ 1739 1740 litest_drain_events(li); 1741 1742 litest_touch_down(dev, 0, 80, 5); 1743 libinput_dispatch(li); 1744 litest_timeout_softbuttons(); 1745 libinput_dispatch(li); 1746 litest_assert_empty_queue(li); 1747 1748 litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20); 1749 libinput_dispatch(li); 1750 litest_timeout_softbuttons(); 1751 libinput_dispatch(li); 1752 1753 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1754 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1755 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1756 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1757 1758 litest_touch_up(dev, 0); 1759 1760 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED); 1761 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED); 1762} 1763END_TEST 1764 1765START_TEST(clickpad_topsoftbuttons_clickfinger) 1766{ 1767 struct litest_device *dev = litest_current_device(); 1768 struct libinput *li = dev->libinput; 1769 1770 litest_enable_clickfinger(dev); 1771 1772 litest_drain_events(li); 1773 1774 litest_touch_down(dev, 0, 90, 5); 1775 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1776 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1777 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1778 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1779 litest_touch_up(dev, 0); 1780 1781 litest_assert_button_event(li, 1782 BTN_LEFT, 1783 LIBINPUT_BUTTON_STATE_PRESSED); 1784 litest_assert_button_event(li, 1785 BTN_LEFT, 1786 LIBINPUT_BUTTON_STATE_RELEASED); 1787 1788 litest_assert_empty_queue(li); 1789 1790 litest_touch_down(dev, 0, 90, 5); 1791 litest_touch_down(dev, 1, 80, 5); 1792 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1793 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1794 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1795 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1796 litest_touch_up(dev, 0); 1797 litest_touch_up(dev, 1); 1798 1799 litest_assert_button_event(li, 1800 BTN_RIGHT, 1801 LIBINPUT_BUTTON_STATE_PRESSED); 1802 litest_assert_button_event(li, 1803 BTN_RIGHT, 1804 LIBINPUT_BUTTON_STATE_RELEASED); 1805} 1806END_TEST 1807 1808START_TEST(clickpad_topsoftbuttons_clickfinger_dev_disabled) 1809{ 1810 struct litest_device *dev = litest_current_device(); 1811 struct libinput *li = dev->libinput; 1812 struct litest_device *trackpoint = litest_add_device(li, 1813 LITEST_TRACKPOINT); 1814 1815 libinput_device_config_send_events_set_mode(dev->libinput_device, 1816 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED); 1817 litest_enable_clickfinger(dev); 1818 litest_drain_events(li); 1819 1820 litest_touch_down(dev, 0, 90, 5); 1821 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1822 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1823 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1824 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1825 litest_touch_up(dev, 0); 1826 1827 litest_assert_button_event(li, 1828 BTN_RIGHT, 1829 LIBINPUT_BUTTON_STATE_PRESSED); 1830 litest_assert_button_event(li, 1831 BTN_RIGHT, 1832 LIBINPUT_BUTTON_STATE_RELEASED); 1833 1834 litest_assert_empty_queue(li); 1835 1836 litest_touch_down(dev, 0, 90, 5); 1837 litest_touch_down(dev, 1, 10, 5); 1838 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1839 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1840 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1841 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1842 litest_touch_up(dev, 0); 1843 litest_touch_up(dev, 1); 1844 1845 litest_assert_button_event(li, 1846 BTN_MIDDLE, 1847 LIBINPUT_BUTTON_STATE_PRESSED); 1848 litest_assert_button_event(li, 1849 BTN_MIDDLE, 1850 LIBINPUT_BUTTON_STATE_RELEASED); 1851 1852 litest_delete_device(trackpoint); 1853} 1854END_TEST 1855 1856START_TEST(clickpad_middleemulation_config_delayed) 1857{ 1858 struct litest_device *dev = litest_current_device(); 1859 struct libinput_device *device = dev->libinput_device; 1860 struct libinput *li = dev->libinput; 1861 enum libinput_config_status status; 1862 int enabled; 1863 1864 enabled = libinput_device_config_middle_emulation_get_enabled(device); 1865 ck_assert(!enabled); 1866 1867 litest_touch_down(dev, 0, 30, 95); 1868 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1869 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1870 libinput_dispatch(li); 1871 1872 /* actual config is delayed, but status is immediate */ 1873 status = libinput_device_config_middle_emulation_set_enabled(device, 1874 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED); 1875 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 1876 1877 enabled = libinput_device_config_middle_emulation_get_enabled(device); 1878 ck_assert(enabled); 1879 1880 status = libinput_device_config_middle_emulation_set_enabled(device, 1881 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED); 1882 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS); 1883 enabled = libinput_device_config_middle_emulation_get_enabled(device); 1884 ck_assert(!enabled); 1885} 1886END_TEST 1887 1888START_TEST(clickpad_middleemulation_click) 1889{ 1890 struct litest_device *dev = litest_current_device(); 1891 struct libinput *li = dev->libinput; 1892 1893 litest_enable_buttonareas(dev); 1894 litest_enable_middleemu(dev); 1895 litest_drain_events(li); 1896 1897 litest_touch_down(dev, 0, 30, 95); 1898 litest_touch_down(dev, 1, 80, 95); 1899 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1900 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1901 1902 litest_assert_button_event(li, 1903 BTN_MIDDLE, 1904 LIBINPUT_BUTTON_STATE_PRESSED); 1905 1906 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1907 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1908 litest_touch_up(dev, 0); 1909 litest_touch_up(dev, 1); 1910 1911 litest_assert_button_event(li, 1912 BTN_MIDDLE, 1913 LIBINPUT_BUTTON_STATE_RELEASED); 1914 1915 libinput_dispatch(li); 1916 1917 litest_assert_empty_queue(li); 1918} 1919END_TEST 1920 1921START_TEST(clickpad_middleemulation_click_middle_left) 1922{ 1923 struct litest_device *dev = litest_current_device(); 1924 struct libinput *li = dev->libinput; 1925 1926 litest_enable_buttonareas(dev); 1927 litest_enable_middleemu(dev); 1928 litest_drain_events(li); 1929 1930 litest_touch_down(dev, 0, 49, 95); 1931 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1932 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1933 1934 litest_assert_button_event(li, 1935 BTN_LEFT, 1936 LIBINPUT_BUTTON_STATE_PRESSED); 1937 1938 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1939 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1940 litest_touch_up(dev, 0); 1941 1942 litest_assert_button_event(li, 1943 BTN_LEFT, 1944 LIBINPUT_BUTTON_STATE_RELEASED); 1945 1946 libinput_dispatch(li); 1947 1948 litest_assert_empty_queue(li); 1949} 1950END_TEST 1951 1952START_TEST(clickpad_middleemulation_click_middle_right) 1953{ 1954 struct litest_device *dev = litest_current_device(); 1955 struct libinput *li = dev->libinput; 1956 1957 litest_enable_buttonareas(dev); 1958 litest_enable_middleemu(dev); 1959 litest_drain_events(li); 1960 1961 litest_touch_down(dev, 0, 51, 95); 1962 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1963 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1964 1965 litest_assert_button_event(li, 1966 BTN_RIGHT, 1967 LIBINPUT_BUTTON_STATE_PRESSED); 1968 1969 litest_event(dev, EV_KEY, BTN_LEFT, 0); 1970 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1971 litest_touch_up(dev, 0); 1972 1973 litest_assert_button_event(li, 1974 BTN_RIGHT, 1975 LIBINPUT_BUTTON_STATE_RELEASED); 1976 1977 libinput_dispatch(li); 1978 1979 litest_assert_empty_queue(li); 1980} 1981END_TEST 1982 1983START_TEST(clickpad_middleemulation_click_enable_while_down) 1984{ 1985 struct litest_device *dev = litest_current_device(); 1986 struct libinput *li = dev->libinput; 1987 1988 litest_enable_buttonareas(dev); 1989 litest_drain_events(li); 1990 1991 litest_touch_down(dev, 0, 49, 95); 1992 litest_event(dev, EV_KEY, BTN_LEFT, 1); 1993 litest_event(dev, EV_SYN, SYN_REPORT, 0); 1994 1995 litest_assert_button_event(li, 1996 BTN_MIDDLE, 1997 LIBINPUT_BUTTON_STATE_PRESSED); 1998 1999 litest_enable_middleemu(dev); 2000 2001 litest_event(dev, EV_KEY, BTN_LEFT, 0); 2002 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2003 litest_touch_up(dev, 0); 2004 2005 litest_assert_button_event(li, 2006 BTN_MIDDLE, 2007 LIBINPUT_BUTTON_STATE_RELEASED); 2008 2009 libinput_dispatch(li); 2010 2011 litest_assert_empty_queue(li); 2012 2013 litest_touch_down(dev, 0, 49, 95); 2014 litest_event(dev, EV_KEY, BTN_LEFT, 1); 2015 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2016 litest_event(dev, EV_KEY, BTN_LEFT, 0); 2017 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2018 litest_touch_up(dev, 0); 2019 2020 litest_assert_button_event(li, 2021 BTN_LEFT, 2022 LIBINPUT_BUTTON_STATE_PRESSED); 2023 litest_assert_button_event(li, 2024 BTN_LEFT, 2025 LIBINPUT_BUTTON_STATE_RELEASED); 2026 2027 libinput_dispatch(li); 2028} 2029END_TEST 2030 2031START_TEST(clickpad_middleemulation_click_disable_while_down) 2032{ 2033 struct litest_device *dev = litest_current_device(); 2034 struct libinput *li = dev->libinput; 2035 2036 litest_enable_buttonareas(dev); 2037 litest_enable_middleemu(dev); 2038 2039 litest_drain_events(li); 2040 2041 litest_touch_down(dev, 0, 30, 95); 2042 litest_touch_down(dev, 1, 70, 95); 2043 litest_event(dev, EV_KEY, BTN_LEFT, 1); 2044 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2045 2046 litest_assert_button_event(li, 2047 BTN_MIDDLE, 2048 LIBINPUT_BUTTON_STATE_PRESSED); 2049 2050 litest_disable_middleemu(dev); 2051 2052 litest_event(dev, EV_KEY, BTN_LEFT, 0); 2053 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2054 litest_touch_up(dev, 0); 2055 litest_touch_up(dev, 1); 2056 2057 litest_assert_button_event(li, 2058 BTN_MIDDLE, 2059 LIBINPUT_BUTTON_STATE_RELEASED); 2060 libinput_dispatch(li); 2061 2062 litest_assert_empty_queue(li); 2063 2064 litest_touch_down(dev, 0, 49, 95); 2065 litest_event(dev, EV_KEY, BTN_LEFT, 1); 2066 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2067 litest_event(dev, EV_KEY, BTN_LEFT, 0); 2068 litest_event(dev, EV_SYN, SYN_REPORT, 0); 2069 litest_touch_up(dev, 0); 2070 2071 litest_assert_button_event(li, 2072 BTN_MIDDLE, 2073 LIBINPUT_BUTTON_STATE_PRESSED); 2074 litest_assert_button_event(li, 2075 BTN_MIDDLE, 2076 LIBINPUT_BUTTON_STATE_RELEASED); 2077 2078 libinput_dispatch(li); 2079} 2080END_TEST 2081 2082START_TEST(touchpad_non_clickpad_detection) 2083{ 2084 struct libinput *li; 2085 struct libinput_device *device; 2086 struct libevdev_uinput *uinput; 2087 static struct input_absinfo absinfo[] = { 2088 { ABS_X, 1472, 5472, 0, 0, 75 }, 2089 { ABS_Y, 1408, 4448, 0, 0, 129 }, 2090 { ABS_PRESSURE, 0, 255, 0, 0, 0 }, 2091 { ABS_TOOL_WIDTH, 0, 15, 0, 0, 0 }, 2092 { ABS_MT_SLOT, 0, 1, 0, 0, 0 }, 2093 { ABS_MT_POSITION_X, 1472, 5472, 0, 0, 75 }, 2094 { ABS_MT_POSITION_Y, 1408, 4448, 0, 0, 129 }, 2095 { ABS_MT_TRACKING_ID, 0, 65535, 0, 0, 0 }, 2096 { ABS_MT_PRESSURE, 0, 255, 0, 0, 0 }, 2097 { .value = -1 } 2098 }; 2099 uint32_t methods; 2100 2101 /* Create a touchpad with only a left button but missing 2102 * INPUT_PROP_BUTTONPAD. We should treat this as clickpad. 2103 */ 2104 uinput = litest_create_uinput_abs_device("litest NonClickpad", 2105 NULL, 2106 absinfo, 2107 EV_KEY, BTN_LEFT, 2108 EV_KEY, BTN_TOOL_FINGER, 2109 EV_KEY, BTN_TOUCH, 2110 -1); 2111 2112 li = litest_create_context(); 2113 device = libinput_path_add_device(li, 2114 libevdev_uinput_get_devnode(uinput)); 2115 2116 methods = libinput_device_config_click_get_methods(device); 2117 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS); 2118 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER); 2119 2120 2121 libinput_path_remove_device(device); 2122 libevdev_uinput_destroy(uinput); 2123 litest_destroy_context(li); 2124} 2125END_TEST 2126 2127TEST_COLLECTION(touchpad_buttons) 2128{ 2129 struct range finger_count = {1, 4}; 2130 2131 litest_add(touchpad_button, LITEST_TOUCHPAD, LITEST_CLICKPAD); 2132 2133 litest_add(touchpad_1fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY); 2134 litest_add(touchpad_1fg_clickfinger_no_touch, LITEST_CLICKPAD, LITEST_ANY); 2135 litest_add(touchpad_2fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY); 2136 litest_add(touchpad_3fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY); 2137 litest_add(touchpad_3fg_clickfinger_btntool, LITEST_CLICKPAD, LITEST_ANY); 2138 litest_add(touchpad_4fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY); 2139 litest_add(touchpad_4fg_clickfinger_btntool_2slots, LITEST_CLICKPAD, LITEST_ANY); 2140 litest_add(touchpad_4fg_clickfinger_btntool_3slots, LITEST_CLICKPAD, LITEST_ANY); 2141 litest_add(touchpad_2fg_clickfinger_distance, LITEST_CLICKPAD, LITEST_ANY); 2142 litest_add(touchpad_3fg_clickfinger_distance, LITEST_CLICKPAD, LITEST_ANY); 2143 litest_add(touchpad_3fg_clickfinger_distance_btntool, LITEST_CLICKPAD, LITEST_ANY); 2144 litest_add_for_device(touchpad_2fg_clickfinger_bottom, LITEST_SYNAPTICS_TOPBUTTONPAD); 2145 litest_add(touchpad_clickfinger_to_area_method, LITEST_CLICKPAD, LITEST_ANY); 2146 litest_add(touchpad_clickfinger_to_area_method_while_down, LITEST_CLICKPAD, LITEST_ANY); 2147 litest_add(touchpad_area_to_clickfinger_method, LITEST_CLICKPAD, LITEST_ANY); 2148 litest_add(touchpad_area_to_clickfinger_method_while_down, LITEST_CLICKPAD, LITEST_ANY); 2149 /* run those two for the T440 one only so we don't have to worry 2150 * about small touchpads messing with thumb detection expectations */ 2151 litest_add_for_device(touchpad_clickfinger_3fg_tool_position, LITEST_SYNAPTICS_TOPBUTTONPAD); 2152 litest_add_for_device(touchpad_clickfinger_4fg_tool_position, LITEST_SYNAPTICS_TOPBUTTONPAD); 2153 2154 litest_add_for_device(touchpad_clickfinger_appletouch_config, LITEST_APPLETOUCH); 2155 litest_add_for_device(touchpad_clickfinger_appletouch_1fg, LITEST_APPLETOUCH); 2156 litest_add_for_device(touchpad_clickfinger_appletouch_2fg, LITEST_APPLETOUCH); 2157 litest_add_for_device(touchpad_clickfinger_appletouch_3fg, LITEST_APPLETOUCH); 2158 2159 litest_add_for_device(touchpad_1fg_clickfinger_no_touch_phantomclicks, LITEST_SYNAPTICS_PHANTOMCLICKS); 2160 2161 litest_add_ranged(touchpad_clickfinger_click_drag, LITEST_CLICKPAD, LITEST_ANY, &finger_count); 2162 2163 litest_add(touchpad_click_defaults_clickfinger, LITEST_APPLE_CLICKPAD, LITEST_ANY); 2164 litest_add(touchpad_click_defaults_btnarea, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2165 litest_add(touchpad_click_defaults_none, LITEST_TOUCHPAD, LITEST_CLICKPAD); 2166 litest_add(touchpad_click_defaults_none, LITEST_ANY, LITEST_TOUCHPAD); 2167 2168 litest_add(touchpad_btn_left, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_CLICKPAD); 2169 litest_add(clickpad_btn_left, LITEST_CLICKPAD, LITEST_ANY); 2170 litest_add(clickpad_click_n_drag, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH); 2171 litest_add(clickpad_finger_pin, LITEST_CLICKPAD, LITEST_ANY); 2172 2173 litest_add(clickpad_softbutton_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2174 litest_add(clickpad_softbutton_middle, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2175 litest_add(clickpad_softbutton_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2176 litest_add(clickpad_softbutton_left_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2177 litest_add(clickpad_softbutton_right_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2178 litest_add(clickpad_softbutton_left_1st_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2179 litest_add(clickpad_softbutton_left_2nd_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2180 litest_add(clickpad_softbutton_left_to_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2181 litest_add(clickpad_softbutton_right_to_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD); 2182 litest_add(clickpad_softbutton_hover_into_buttons, LITEST_CLICKPAD|LITEST_HOVER, LITEST_APPLE_CLICKPAD); 2183 2184 litest_add(clickpad_topsoftbuttons_left, LITEST_TOPBUTTONPAD, LITEST_ANY); 2185 litest_add(clickpad_topsoftbuttons_right, LITEST_TOPBUTTONPAD, LITEST_ANY); 2186 litest_add(clickpad_topsoftbuttons_middle, LITEST_TOPBUTTONPAD, LITEST_ANY); 2187 litest_add(clickpad_topsoftbuttons_move_out_leftclick, LITEST_TOPBUTTONPAD, LITEST_ANY); 2188 litest_add(clickpad_topsoftbuttons_move_out_leftclick_before_timeout, LITEST_TOPBUTTONPAD, LITEST_ANY); 2189 litest_add(clickpad_topsoftbuttons_clickfinger, LITEST_TOPBUTTONPAD, LITEST_ANY); 2190 litest_add(clickpad_topsoftbuttons_clickfinger_dev_disabled, LITEST_TOPBUTTONPAD, LITEST_ANY); 2191 2192 litest_add(clickpad_middleemulation_config_delayed, LITEST_CLICKPAD, LITEST_ANY); 2193 litest_add(clickpad_middleemulation_click, LITEST_CLICKPAD, LITEST_ANY); 2194 litest_add(clickpad_middleemulation_click_middle_left, LITEST_CLICKPAD, LITEST_ANY); 2195 litest_add(clickpad_middleemulation_click_middle_right, LITEST_CLICKPAD, LITEST_ANY); 2196 litest_add(clickpad_middleemulation_click_enable_while_down, LITEST_CLICKPAD, LITEST_ANY); 2197 litest_add(clickpad_middleemulation_click_disable_while_down, LITEST_CLICKPAD, LITEST_ANY); 2198 2199 litest_add_no_device(touchpad_non_clickpad_detection); 2200} 2201