2 * Copyright © 2014 Red Hat, Inc.
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
31 #include "libinput-util.h"
34 START_TEST(touchpad_1fg_motion)
36 struct litest_device *dev = litest_current_device();
37 struct libinput *li = dev->libinput;
38 struct libinput_event *event;
39 struct libinput_event_pointer *ptrev;
41 litest_drain_events(li);
43 litest_touch_down(dev, 0, 50, 50);
44 litest_touch_move_to(dev, 0, 50, 50, 80, 50, 5);
45 litest_touch_up(dev, 0);
47 libinput_dispatch(li);
49 event = libinput_get_event(li);
50 ck_assert(event != NULL);
53 ck_assert_int_eq(libinput_event_get_type(event),
54 LIBINPUT_EVENT_POINTER_MOTION);
56 ptrev = libinput_event_get_pointer_event(event);
57 ck_assert_int_ge(libinput_event_pointer_get_dx(ptrev), 0);
58 ck_assert_int_eq(libinput_event_pointer_get_dy(ptrev), 0);
59 libinput_event_destroy(event);
60 event = libinput_get_event(li);
65 START_TEST(touchpad_2fg_no_motion)
67 struct litest_device *dev = litest_current_device();
68 struct libinput *li = dev->libinput;
69 struct libinput_event *event;
71 litest_drain_events(li);
73 litest_touch_down(dev, 0, 20, 20);
74 litest_touch_down(dev, 1, 70, 20);
75 litest_touch_move_to(dev, 0, 20, 20, 80, 80, 5);
76 litest_touch_move_to(dev, 1, 70, 20, 80, 50, 5);
77 litest_touch_up(dev, 1);
78 litest_touch_up(dev, 0);
80 libinput_dispatch(li);
82 event = libinput_get_event(li);
84 ck_assert_int_ne(libinput_event_get_type(event),
85 LIBINPUT_EVENT_POINTER_MOTION);
86 libinput_event_destroy(event);
87 event = libinput_get_event(li);
93 assert_button_event(struct libinput *li, int button,
94 enum libinput_button_state state)
96 struct libinput_event *event;
97 struct libinput_event_pointer *ptrev;
99 libinput_dispatch(li);
100 event = libinput_get_event(li);
102 ck_assert(event != NULL);
103 ck_assert_int_eq(libinput_event_get_type(event),
104 LIBINPUT_EVENT_POINTER_BUTTON);
105 ptrev = libinput_event_get_pointer_event(event);
106 ck_assert_int_eq(libinput_event_pointer_get_button(ptrev),
108 ck_assert_int_eq(libinput_event_pointer_get_button_state(ptrev),
110 libinput_event_destroy(event);
113 START_TEST(touchpad_1fg_tap)
115 struct litest_device *dev = litest_current_device();
116 struct libinput *li = dev->libinput;
117 struct libinput_event *event;
119 litest_drain_events(li);
121 litest_touch_down(dev, 0, 50, 50);
122 litest_touch_up(dev, 0);
124 libinput_dispatch(li);
126 assert_button_event(li, BTN_LEFT,
127 LIBINPUT_BUTTON_STATE_PRESSED);
128 usleep(300000); /* tap-n-drag timeout */
129 assert_button_event(li, BTN_LEFT,
130 LIBINPUT_BUTTON_STATE_RELEASED);
132 libinput_dispatch(li);
133 event = libinput_get_event(li);
134 ck_assert(event == NULL);
138 START_TEST(touchpad_1fg_tap_n_drag)
140 struct litest_device *dev = litest_current_device();
141 struct libinput *li = dev->libinput;
142 struct libinput_event *event;
144 litest_drain_events(li);
146 litest_touch_down(dev, 0, 50, 50);
147 litest_touch_up(dev, 0);
148 litest_touch_down(dev, 0, 50, 50);
149 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 5);
150 litest_touch_up(dev, 0);
152 libinput_dispatch(li);
154 assert_button_event(li, BTN_LEFT,
155 LIBINPUT_BUTTON_STATE_PRESSED);
157 libinput_dispatch(li);
158 while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION) {
159 event = libinput_get_event(li);
160 libinput_event_destroy(event);
161 libinput_dispatch(li);
164 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
166 /* lift finger, set down again, should continue dragging */
167 litest_touch_down(dev, 0, 50, 50);
168 litest_touch_move_to(dev, 0, 50, 50, 80, 80, 5);
169 litest_touch_up(dev, 0);
171 libinput_dispatch(li);
172 while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION) {
173 event = libinput_get_event(li);
174 libinput_event_destroy(event);
175 libinput_dispatch(li);
178 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
180 usleep(300000); /* tap-n-drag timeout */
182 assert_button_event(li, BTN_LEFT,
183 LIBINPUT_BUTTON_STATE_RELEASED);
185 litest_assert_empty_queue(li);
189 START_TEST(touchpad_2fg_tap)
191 struct litest_device *dev = litest_current_device();
192 struct libinput *li = dev->libinput;
194 litest_drain_events(dev->libinput);
196 litest_touch_down(dev, 0, 50, 50);
197 litest_touch_down(dev, 1, 70, 70);
198 litest_touch_up(dev, 0);
199 litest_touch_up(dev, 1);
201 libinput_dispatch(li);
203 assert_button_event(li, BTN_RIGHT,
204 LIBINPUT_BUTTON_STATE_PRESSED);
205 usleep(300000); /* tap-n-drag timeout */
206 assert_button_event(li, BTN_RIGHT,
207 LIBINPUT_BUTTON_STATE_RELEASED);
209 litest_assert_empty_queue(li);
213 START_TEST(touchpad_1fg_clickfinger)
215 struct litest_device *dev = litest_create_device(LITEST_BCM5974);
216 struct libinput *li = dev->libinput;
218 litest_drain_events(li);
220 litest_touch_down(dev, 0, 50, 50);
221 litest_event(dev, EV_KEY, BTN_LEFT, 1);
222 litest_event(dev, EV_SYN, SYN_REPORT, 0);
223 litest_event(dev, EV_KEY, BTN_LEFT, 0);
224 litest_event(dev, EV_SYN, SYN_REPORT, 0);
225 litest_touch_up(dev, 0);
227 libinput_dispatch(li);
229 assert_button_event(li, BTN_LEFT,
230 LIBINPUT_BUTTON_STATE_PRESSED);
231 assert_button_event(li, BTN_LEFT,
232 LIBINPUT_BUTTON_STATE_RELEASED);
234 litest_delete_device(dev);
238 START_TEST(touchpad_2fg_clickfinger)
240 struct litest_device *dev = litest_create_device(LITEST_BCM5974);
241 struct libinput *li = dev->libinput;
243 litest_drain_events(li);
245 litest_touch_down(dev, 0, 50, 50);
246 litest_touch_down(dev, 1, 70, 70);
247 litest_event(dev, EV_KEY, BTN_LEFT, 1);
248 litest_event(dev, EV_SYN, SYN_REPORT, 0);
249 litest_event(dev, EV_KEY, BTN_LEFT, 0);
250 litest_event(dev, EV_SYN, SYN_REPORT, 0);
251 litest_touch_up(dev, 0);
252 litest_touch_up(dev, 1);
254 libinput_dispatch(li);
256 assert_button_event(li, BTN_RIGHT,
257 LIBINPUT_BUTTON_STATE_PRESSED);
258 assert_button_event(li, BTN_RIGHT,
259 LIBINPUT_BUTTON_STATE_RELEASED);
261 litest_delete_device(dev);
265 START_TEST(touchpad_btn_left)
267 struct litest_device *dev = litest_current_device();
268 struct libinput *li = dev->libinput;
270 litest_drain_events(li);
272 litest_event(dev, EV_KEY, BTN_LEFT, 1);
273 litest_event(dev, EV_SYN, SYN_REPORT, 0);
274 litest_event(dev, EV_KEY, BTN_LEFT, 0);
275 litest_event(dev, EV_SYN, SYN_REPORT, 0);
277 libinput_dispatch(li);
279 assert_button_event(li, BTN_LEFT,
280 LIBINPUT_BUTTON_STATE_PRESSED);
281 assert_button_event(li, BTN_LEFT,
282 LIBINPUT_BUTTON_STATE_RELEASED);
286 START_TEST(clickpad_btn_left)
288 struct litest_device *dev = litest_current_device();
289 struct libinput *li = dev->libinput;
291 litest_drain_events(li);
293 /* A clickpad always needs a finger down to tell where the
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);
300 libinput_dispatch(li);
301 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
305 START_TEST(clickpad_click_n_drag)
307 struct litest_device *dev = litest_current_device();
308 struct libinput *li = dev->libinput;
309 struct libinput_event *event;
311 litest_drain_events(li);
313 litest_touch_down(dev, 0, 50, 50);
314 litest_event(dev, EV_KEY, BTN_LEFT, 1);
315 litest_event(dev, EV_SYN, SYN_REPORT, 0);
317 libinput_dispatch(li);
318 assert_button_event(li, BTN_LEFT,
319 LIBINPUT_BUTTON_STATE_PRESSED);
321 libinput_dispatch(li);
322 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
324 /* now put a second finger down */
325 litest_touch_down(dev, 1, 70, 70);
326 litest_touch_move_to(dev, 1, 70, 70, 80, 50, 5);
327 litest_touch_up(dev, 1);
329 libinput_dispatch(li);
330 ck_assert_int_eq(libinput_next_event_type(li),
331 LIBINPUT_EVENT_POINTER_MOTION);
333 event = libinput_get_event(li);
334 libinput_event_destroy(event);
335 libinput_dispatch(li);
336 } while (libinput_next_event_type(li) == LIBINPUT_EVENT_POINTER_MOTION);
338 litest_event(dev, EV_KEY, BTN_LEFT, 0);
339 litest_event(dev, EV_SYN, SYN_REPORT, 0);
340 litest_touch_up(dev, 0);
342 assert_button_event(li, BTN_LEFT,
343 LIBINPUT_BUTTON_STATE_RELEASED);
347 int main(int argc, char **argv) {
349 litest_add("touchpad:motion", touchpad_1fg_motion, LITEST_TOUCHPAD, LITEST_ANY);
350 litest_add("touchpad:motion", touchpad_2fg_no_motion, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
352 litest_add("touchpad:tap", touchpad_1fg_tap, LITEST_TOUCHPAD, LITEST_ANY);
353 litest_add("touchpad:tap", touchpad_1fg_tap_n_drag, LITEST_TOUCHPAD, LITEST_ANY);
354 litest_add("touchpad:tap", touchpad_2fg_tap, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
356 litest_add_no_device("touchpad:clickfinger", touchpad_1fg_clickfinger);
357 litest_add_no_device("touchpad:clickfinger", touchpad_2fg_clickfinger);
359 litest_add("touchpad:click", touchpad_btn_left, LITEST_TOUCHPAD, LITEST_CLICKPAD);
360 litest_add("touchpad:click", clickpad_btn_left, LITEST_CLICKPAD, LITEST_ANY);
361 litest_add("touchpad:click", clickpad_click_n_drag, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
363 return litest_run(argc, argv);