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
START_TESTnull35 START_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 }
56 END_TEST
57
START_TESTnull58 START_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 }
83 END_TEST
84
START_TESTnull85 START_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 }
110 END_TEST
111
START_TESTnull112 START_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 }
140 END_TEST
141
START_TESTnull142 START_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 }
165 END_TEST
166
START_TESTnull167 START_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 }
194 END_TEST
195
START_TESTnull196 START_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 }
214 END_TEST
215
START_TESTnull216 START_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 }
241 END_TEST
242
START_TESTnull243 START_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 }
275 END_TEST
276
START_TESTnull277 START_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 }
314 END_TEST
315
START_TESTnull316 START_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 }
345 END_TEST
346
START_TESTnull347 START_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 }
377 END_TEST
378
START_TESTnull379 START_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 }
413 END_TEST
414
START_TESTnull415 START_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 }
472 END_TEST
473
START_TESTnull474 START_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 }
505 END_TEST
506
START_TESTnull507 START_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 }
543 END_TEST
544
START_TESTnull545 START_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 }
610 END_TEST
611
START_TESTnull612 START_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 }
653 END_TEST
654
START_TESTnull655 START_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 }
698 END_TEST
699
START_TESTnull700 START_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 }
739 END_TEST
740
START_TESTnull741 START_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 }
781 END_TEST
782
START_TESTnull783 START_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 }
811 END_TEST
812
START_TESTnull813 START_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 }
841 END_TEST
842
START_TESTnull843 START_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 }
864 END_TEST
865
START_TESTnull866 START_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 }
889 END_TEST
890
START_TESTnull891 START_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 }
916 END_TEST
917
START_TESTnull918 START_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 }
945 END_TEST
946
START_TESTnull947 START_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 }
1034 END_TEST
1035
START_TESTnull1036 START_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 }
1055 END_TEST
1056
START_TESTnull1057 START_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 }
1076 END_TEST
1077
START_TESTnull1078 START_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 }
1110 END_TEST
1111
START_TESTnull1112 START_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 }
1164 END_TEST
1165
START_TESTnull1166 START_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 }
1193 END_TEST
1194
START_TESTnull1195 START_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 }
1222 END_TEST
1223
START_TESTnull1224 START_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 }
1251 END_TEST
1252
START_TESTnull1253 START_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 }
1293 END_TEST
1294
START_TESTnull1295 START_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 }
1335 END_TEST
1336
START_TESTnull1337 START_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 }
1411 END_TEST
1412
START_TESTnull1413 START_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 }
1506 END_TEST
1507
START_TESTnull1508 START_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 }
1542 END_TEST
1543
START_TESTnull1544 START_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 }
1578 END_TEST
1579
START_TESTnull1580 START_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 }
1609 END_TEST
1610
START_TESTnull1611 START_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 }
1637 END_TEST
1638
START_TESTnull1639 START_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 }
1665 END_TEST
1666
START_TESTnull1667 START_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 }
1693 END_TEST
1694
START_TESTnull1695 START_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 }
1727 END_TEST
1728
START_TESTnull1729 START_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 }
1763 END_TEST
1764
START_TESTnull1765 START_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 }
1806 END_TEST
1807
START_TESTnull1808 START_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 }
1854 END_TEST
1855
START_TESTnull1856 START_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 }
1886 END_TEST
1887
START_TESTnull1888 START_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 }
1919 END_TEST
1920
START_TESTnull1921 START_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 }
1950 END_TEST
1951
START_TESTnull1952 START_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 }
1981 END_TEST
1982
START_TESTnull1983 START_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 }
2029 END_TEST
2030
START_TESTnull2031 START_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 }
2080 END_TEST
2081
START_TESTnull2082 START_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 }
2125 END_TEST
2126
TEST_COLLECTIONnull2127 TEST_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