2 * Copyright © 2012 Ran Benita <ran234@gmail.com>
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:
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
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.
24 #include <linux/input.h>
37 #define EVDEV_OFFSET 8
40 * Test a sequence of keysyms, resulting from a sequence of key presses,
41 * against the keysyms they're supposed to generate.
43 * - Each test runs with a clean state.
44 * - Each line in the test is made up of:
45 * + A keycode, given as a KEY_* from linux/input.h.
46 * + A direction - DOWN for press, UP for release, BOTH for
47 * immediate press + release, REPEAT to just get the syms.
48 * + A sequence of keysyms that should result from this keypress.
50 * The vararg format is:
51 * <KEY_*> <DOWN | UP | BOTH> <XKB_KEY_* (zero or more)> <NEXT | FINISH>
53 * See below for examples.
56 test_key_seq(struct xkb_keymap *keymap, ...)
58 struct xkb_state *state;
65 const xkb_keysym_t *syms;
66 unsigned int nsyms, i;
69 fprintf(stderr, "----\n");
71 state = xkb_state_new(keymap);
77 kc = va_arg(ap, int) + EVDEV_OFFSET;
80 nsyms = xkb_state_key_get_syms(state, kc, &syms);
81 fprintf(stderr, "got %d syms for key 0x%x: [", nsyms, kc);
83 if (op == DOWN || op == BOTH)
84 xkb_state_update_key(state, kc, XKB_KEY_DOWN);
85 if (op == UP || op == BOTH)
86 xkb_state_update_key(state, kc, XKB_KEY_UP);
88 for (i = 0; i < nsyms; i++) {
89 keysym = va_arg(ap, int);
90 xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
91 fprintf(stderr, "%s%s", (i != 0) ? ", " : "", ksbuf);
93 if (keysym == FINISH || keysym == NEXT) {
94 xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
95 fprintf(stderr, "Did not expect keysym: %s.\n", ksbuf);
99 if (keysym != syms[i]) {
100 xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
101 fprintf(stderr, "Expected keysym: %s. ", ksbuf);;
102 xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
103 fprintf(stderr, "Got keysym: %s.\n", ksbuf);;
108 fprintf(stderr, "]\n");
110 keysym = va_arg(ap, int);
113 if (keysym == FINISH)
116 xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
117 fprintf(stderr, "Expected keysym: %s. Didn't get it.\n", ksbuf);
122 xkb_state_unref(state);
127 xkb_state_unref(state);
134 struct xkb_context *ctx = test_get_context();
135 struct xkb_keymap *keymap;
138 keymap = test_compile_rules(ctx, "evdev", "evdev",
139 "us,il,ru,de", ",,phonetic,neo",
140 "grp:alt_shift_toggle,grp:menu_toggle");
143 assert(test_key_seq(keymap,
144 KEY_H, BOTH, XKB_KEY_h, NEXT,
145 KEY_E, BOTH, XKB_KEY_e, NEXT,
146 KEY_L, BOTH, XKB_KEY_l, NEXT,
147 KEY_L, BOTH, XKB_KEY_l, NEXT,
148 KEY_O, BOTH, XKB_KEY_o, FINISH));
150 /* Simple shifted level. */
151 assert(test_key_seq(keymap,
152 KEY_H, BOTH, XKB_KEY_h, NEXT,
153 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
154 KEY_E, BOTH, XKB_KEY_E, NEXT,
155 KEY_L, BOTH, XKB_KEY_L, NEXT,
156 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
157 KEY_L, BOTH, XKB_KEY_l, NEXT,
158 KEY_O, BOTH, XKB_KEY_o, FINISH));
160 /* Key repeat shifted and unshifted in the middle. */
161 assert(test_key_seq(keymap,
162 KEY_H, DOWN, XKB_KEY_h, NEXT,
163 KEY_H, REPEAT, XKB_KEY_h, NEXT,
164 KEY_H, REPEAT, XKB_KEY_h, NEXT,
165 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
166 KEY_H, REPEAT, XKB_KEY_H, NEXT,
167 KEY_H, REPEAT, XKB_KEY_H, NEXT,
168 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
169 KEY_H, REPEAT, XKB_KEY_h, NEXT,
170 KEY_H, REPEAT, XKB_KEY_h, NEXT,
171 KEY_H, UP, XKB_KEY_h, NEXT,
172 KEY_H, BOTH, XKB_KEY_h, FINISH));
174 /* Base modifier cleared on key release... */
175 assert(test_key_seq(keymap,
176 KEY_H, BOTH, XKB_KEY_h, NEXT,
177 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
178 KEY_E, BOTH, XKB_KEY_E, NEXT,
179 KEY_L, BOTH, XKB_KEY_L, NEXT,
180 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
181 KEY_L, BOTH, XKB_KEY_L, NEXT,
182 KEY_O, BOTH, XKB_KEY_O, FINISH));
184 /* ... But only by the keycode that set it. */
185 assert(test_key_seq(keymap,
186 KEY_H, BOTH, XKB_KEY_h, NEXT,
187 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
188 KEY_E, BOTH, XKB_KEY_E, NEXT,
189 KEY_L, BOTH, XKB_KEY_L, NEXT,
190 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
191 KEY_L, BOTH, XKB_KEY_L, NEXT,
192 KEY_O, BOTH, XKB_KEY_O, FINISH));
195 * A base modifier should only be cleared when no other key affecting
196 * the modifier is down.
198 assert(test_key_seq(keymap,
199 KEY_H, BOTH, XKB_KEY_h, NEXT,
200 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
201 KEY_E, BOTH, XKB_KEY_E, NEXT,
202 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
203 KEY_L, BOTH, XKB_KEY_L, NEXT,
204 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
205 KEY_L, BOTH, XKB_KEY_L, NEXT,
206 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
207 KEY_O, BOTH, XKB_KEY_o, FINISH));
210 * Two key presses from the same key (e.g. if two keyboards use the
211 * same xkb_state) should only be released after two releases.
213 assert(test_key_seq(keymap,
214 KEY_H, BOTH, XKB_KEY_h, NEXT,
215 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
216 KEY_H, BOTH, XKB_KEY_H, NEXT,
217 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
218 KEY_H, BOTH, XKB_KEY_H, NEXT,
219 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
220 KEY_H, BOTH, XKB_KEY_H, NEXT,
221 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
222 KEY_H, BOTH, XKB_KEY_h, FINISH));
224 /* Same as above with locked modifiers. */
225 assert(test_key_seq(keymap,
226 KEY_H, BOTH, XKB_KEY_h, NEXT,
227 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
228 KEY_H, BOTH, XKB_KEY_H, NEXT,
229 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
230 KEY_H, BOTH, XKB_KEY_H, NEXT,
231 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
232 KEY_H, BOTH, XKB_KEY_H, NEXT,
233 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
234 KEY_H, BOTH, XKB_KEY_H, NEXT,
235 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
236 KEY_H, BOTH, XKB_KEY_h, FINISH));
238 /* Group switching / locking. */
239 assert(test_key_seq(keymap,
240 KEY_H, BOTH, XKB_KEY_h, NEXT,
241 KEY_E, BOTH, XKB_KEY_e, NEXT,
242 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
243 KEY_K, BOTH, XKB_KEY_hebrew_lamed, NEXT,
244 KEY_F, BOTH, XKB_KEY_hebrew_kaph, NEXT,
245 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
246 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
247 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
248 KEY_O, BOTH, XKB_KEY_o, FINISH));
250 assert(test_key_seq(keymap,
251 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
252 KEY_LEFTALT, DOWN, XKB_KEY_ISO_Next_Group, NEXT,
253 KEY_LEFTALT, UP, XKB_KEY_ISO_Next_Group, NEXT,
254 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, FINISH));
256 assert(test_key_seq(keymap,
257 KEY_LEFTALT, DOWN, XKB_KEY_Alt_L, NEXT,
258 KEY_LEFTSHIFT, DOWN, XKB_KEY_ISO_Next_Group, NEXT,
259 KEY_LEFTSHIFT, UP, XKB_KEY_ISO_Next_Group, NEXT,
260 KEY_LEFTALT, UP, XKB_KEY_Alt_L, FINISH));
262 /* Locked modifiers. */
263 assert(test_key_seq(keymap,
264 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
265 KEY_H, BOTH, XKB_KEY_H, NEXT,
266 KEY_E, BOTH, XKB_KEY_E, NEXT,
267 KEY_L, BOTH, XKB_KEY_L, NEXT,
268 KEY_L, BOTH, XKB_KEY_L, NEXT,
269 KEY_O, BOTH, XKB_KEY_O, FINISH));
271 assert(test_key_seq(keymap,
272 KEY_H, BOTH, XKB_KEY_h, NEXT,
273 KEY_E, BOTH, XKB_KEY_e, NEXT,
274 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
275 KEY_L, BOTH, XKB_KEY_L, NEXT,
276 KEY_L, BOTH, XKB_KEY_L, NEXT,
277 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
278 KEY_O, BOTH, XKB_KEY_o, FINISH));
280 assert(test_key_seq(keymap,
281 KEY_H, BOTH, XKB_KEY_h, NEXT,
282 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
283 KEY_E, BOTH, XKB_KEY_E, NEXT,
284 KEY_L, BOTH, XKB_KEY_L, NEXT,
285 KEY_L, BOTH, XKB_KEY_L, NEXT,
286 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
287 KEY_O, BOTH, XKB_KEY_O, FINISH));
289 assert(test_key_seq(keymap,
290 KEY_H, BOTH, XKB_KEY_h, NEXT,
291 KEY_E, BOTH, XKB_KEY_e, NEXT,
292 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
293 KEY_L, BOTH, XKB_KEY_l, NEXT,
294 KEY_L, BOTH, XKB_KEY_l, NEXT,
295 KEY_O, BOTH, XKB_KEY_o, FINISH));
298 * A key release affecting a locked modifier should clear it
299 * regardless of the key press.
301 /* assert(test_key_seq(keymap, */
302 /* KEY_H, BOTH, XKB_KEY_h, NEXT, */
303 /* KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT, */
304 /* KEY_E, BOTH, XKB_KEY_E, NEXT, */
305 /* KEY_L, BOTH, XKB_KEY_L, NEXT, */
306 /* KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT, */
307 /* KEY_L, BOTH, XKB_KEY_L, NEXT, */
308 /* KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT, */
309 /* KEY_O, BOTH, XKB_KEY_o, FINISH)); */
311 /* Simple Num Lock sanity check. */
312 assert(test_key_seq(keymap,
313 KEY_KP1, BOTH, XKB_KEY_KP_End, NEXT,
314 KEY_NUMLOCK, BOTH, XKB_KEY_Num_Lock, NEXT,
315 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
316 KEY_KP2, BOTH, XKB_KEY_KP_2, NEXT,
317 KEY_NUMLOCK, BOTH, XKB_KEY_Num_Lock, NEXT,
318 KEY_KP2, BOTH, XKB_KEY_KP_Down, FINISH));
320 /* Test that the aliases in the ru(phonetic) symbols map work. */
321 assert(test_key_seq(keymap,
322 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
323 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
324 KEY_1, BOTH, XKB_KEY_1, NEXT,
325 KEY_Q, BOTH, XKB_KEY_Cyrillic_ya, NEXT,
326 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
327 KEY_1, BOTH, XKB_KEY_exclam, NEXT,
328 KEY_Q, BOTH, XKB_KEY_Cyrillic_YA, NEXT,
329 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
330 KEY_V, BOTH, XKB_KEY_Cyrillic_zhe, NEXT,
331 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
332 KEY_1, BOTH, XKB_KEY_1, NEXT,
333 KEY_V, BOTH, XKB_KEY_Cyrillic_ZHE, NEXT,
334 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
335 KEY_V, BOTH, XKB_KEY_Cyrillic_zhe, NEXT,
336 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
337 KEY_V, BOTH, XKB_KEY_Cyrillic_ZHE, FINISH));
339 #define KS(name) xkb_keysym_from_name(name, 0)
341 /* Test that levels (1-5) in de(neo) symbols map work. */
342 assert(test_key_seq(keymap,
343 /* Switch to the group. */
344 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
345 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
346 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
349 KEY_1, BOTH, XKB_KEY_1, NEXT,
350 KEY_Q, BOTH, XKB_KEY_x, NEXT,
351 KEY_KP7, BOTH, XKB_KEY_KP_7, NEXT,
352 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
354 /* Level 2 with Shift. */
355 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
356 KEY_1, BOTH, XKB_KEY_degree, NEXT,
357 KEY_Q, BOTH, XKB_KEY_X, NEXT,
358 KEY_KP7, BOTH, KS("U2714"), NEXT,
359 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
361 * XXX: de(neo) uses shift(both_capslock) which causes
362 * the interesting result in the next line. Since it's
363 * a key release, it doesn't actually lock the modifier,
364 * and applications by-and-large ignore the keysym on
365 * release(?). Is this a problem?
367 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
369 /* Level 2 with the Lock modifier. */
370 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
371 KEY_RIGHTSHIFT, BOTH, XKB_KEY_Caps_Lock, NEXT,
372 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
373 KEY_6, BOTH, XKB_KEY_6, NEXT,
374 KEY_H, BOTH, XKB_KEY_S, NEXT,
375 KEY_KP3, BOTH, XKB_KEY_KP_3, NEXT,
376 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
377 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
378 KEY_RIGHTSHIFT, BOTH, XKB_KEY_Caps_Lock, NEXT,
379 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
382 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
383 KEY_6, BOTH, XKB_KEY_cent, NEXT,
384 KEY_Q, BOTH, XKB_KEY_ellipsis, NEXT,
385 KEY_KP7, BOTH, KS("U2195"), NEXT,
386 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
387 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
390 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
391 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
392 KEY_5, BOTH, XKB_KEY_malesymbol, NEXT,
393 KEY_E, BOTH, XKB_KEY_Greek_lambda, NEXT,
394 KEY_SPACE, BOTH, XKB_KEY_nobreakspace, NEXT,
395 KEY_KP8, BOTH, XKB_KEY_intersection, NEXT,
396 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
397 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
398 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
401 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
402 KEY_5, BOTH, XKB_KEY_periodcentered, NEXT,
403 KEY_E, BOTH, XKB_KEY_Up, NEXT,
404 KEY_SPACE, BOTH, XKB_KEY_KP_0, NEXT,
405 KEY_KP8, BOTH, XKB_KEY_KP_Up, NEXT,
406 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
407 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Shift, NEXT,
409 KEY_V, BOTH, XKB_KEY_p, FINISH));
411 xkb_keymap_unref(keymap);
413 keymap = test_compile_rules(ctx, "evdev", "", "us,il,ru", "",
414 "grp:alt_shift_toggle_bidir,grp:menu_toggle");
417 assert(test_key_seq(keymap,
418 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
419 KEY_LEFTALT, DOWN, XKB_KEY_ISO_Prev_Group, NEXT,
420 KEY_LEFTALT, UP, XKB_KEY_ISO_Prev_Group, NEXT,
421 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, FINISH));
423 assert(test_key_seq(keymap,
424 KEY_LEFTALT, DOWN, XKB_KEY_Alt_L, NEXT,
425 KEY_LEFTSHIFT, DOWN, XKB_KEY_ISO_Prev_Group, NEXT,
426 KEY_LEFTSHIFT, UP, XKB_KEY_ISO_Prev_Group, NEXT,
427 KEY_LEFTALT, UP, XKB_KEY_Alt_L, FINISH));
429 /* Check backwards (negative) group switching and wrapping. */
430 assert(test_key_seq(keymap,
431 KEY_H, BOTH, XKB_KEY_h, NEXT,
432 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
433 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
434 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
435 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
436 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
437 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
438 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
439 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
440 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
441 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
442 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
443 KEY_H, BOTH, XKB_KEY_h, NEXT,
444 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
445 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
446 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
447 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
448 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
449 KEY_H, BOTH, XKB_KEY_h, FINISH));
451 xkb_keymap_unref(keymap);
452 keymap = test_compile_rules(ctx, "evdev", "", "us,il,ru", "",
453 "grp:switch,grp:lswitch,grp:menu_toggle");
456 /* Test depressed group works (Mode_switch). */
457 assert(test_key_seq(keymap,
458 KEY_H, BOTH, XKB_KEY_h, NEXT,
459 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
460 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
461 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
462 KEY_H, BOTH, XKB_KEY_h, NEXT,
463 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
464 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
465 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
466 KEY_H, BOTH, XKB_KEY_h, FINISH));
468 /* Test locked+depressed group works, with wrapping and accumulation. */
469 assert(test_key_seq(keymap,
470 KEY_H, BOTH, XKB_KEY_h, NEXT,
471 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
472 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
473 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
474 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
475 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
476 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
477 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
478 /* Should wrap back to first group. */
479 KEY_H, BOTH, XKB_KEY_h, NEXT,
480 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
481 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
482 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
483 KEY_H, BOTH, XKB_KEY_h, NEXT,
484 /* Two SetGroup(+1)'s should add up. */
485 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
486 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
487 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
488 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
489 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
490 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
491 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
492 KEY_H, BOTH, XKB_KEY_h, FINISH));
494 xkb_keymap_unref(keymap);
495 keymap = test_compile_file(ctx, "keymaps/unbound-vmod.xkb");
498 assert(test_key_seq(keymap,
499 KEY_H, BOTH, XKB_KEY_h, NEXT,
500 KEY_Z, BOTH, XKB_KEY_y, NEXT,
501 KEY_MINUS, BOTH, XKB_KEY_ssharp, NEXT,
502 KEY_Z, BOTH, XKB_KEY_y, FINISH));
504 xkb_keymap_unref(keymap);
505 xkb_context_unref(ctx);