1 /*
2 * Copyright © 2012 Ran Benita <[email protected]>
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 "evdev-scancodes.h"
27 #include "test.h"
28
29 int
main(void)30 main(void)
31 {
32 struct xkb_context *ctx = test_get_context(0);
33 struct xkb_keymap *keymap;
34
35 assert(ctx);
36 keymap = test_compile_rules(ctx, "evdev", "evdev",
37 "us,il,ru,de", ",,phonetic,neo",
38 "grp:alt_shift_toggle,grp:menu_toggle");
39 assert(keymap);
40
41 assert(test_key_seq(keymap,
42 KEY_H, BOTH, XKB_KEY_h, NEXT,
43 KEY_E, BOTH, XKB_KEY_e, NEXT,
44 KEY_L, BOTH, XKB_KEY_l, NEXT,
45 KEY_L, BOTH, XKB_KEY_l, NEXT,
46 KEY_O, BOTH, XKB_KEY_o, FINISH));
47
48 /* Simple shifted level. */
49 assert(test_key_seq(keymap,
50 KEY_H, BOTH, XKB_KEY_h, NEXT,
51 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
52 KEY_E, BOTH, XKB_KEY_E, NEXT,
53 KEY_L, BOTH, XKB_KEY_L, NEXT,
54 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
55 KEY_L, BOTH, XKB_KEY_l, NEXT,
56 KEY_O, BOTH, XKB_KEY_o, FINISH));
57
58 /* Key repeat shifted and unshifted in the middle. */
59 assert(test_key_seq(keymap,
60 KEY_H, DOWN, XKB_KEY_h, NEXT,
61 KEY_H, REPEAT, XKB_KEY_h, NEXT,
62 KEY_H, REPEAT, XKB_KEY_h, NEXT,
63 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
64 KEY_H, REPEAT, XKB_KEY_H, NEXT,
65 KEY_H, REPEAT, XKB_KEY_H, NEXT,
66 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
67 KEY_H, REPEAT, XKB_KEY_h, NEXT,
68 KEY_H, REPEAT, XKB_KEY_h, NEXT,
69 KEY_H, UP, XKB_KEY_h, NEXT,
70 KEY_H, BOTH, XKB_KEY_h, FINISH));
71
72 /* Base modifier cleared on key release... */
73 assert(test_key_seq(keymap,
74 KEY_H, BOTH, XKB_KEY_h, NEXT,
75 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
76 KEY_E, BOTH, XKB_KEY_E, NEXT,
77 KEY_L, BOTH, XKB_KEY_L, NEXT,
78 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
79 KEY_L, BOTH, XKB_KEY_L, NEXT,
80 KEY_O, BOTH, XKB_KEY_O, FINISH));
81
82 /* ... But only by the keycode that set it. */
83 assert(test_key_seq(keymap,
84 KEY_H, BOTH, XKB_KEY_h, NEXT,
85 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
86 KEY_E, BOTH, XKB_KEY_E, NEXT,
87 KEY_L, BOTH, XKB_KEY_L, NEXT,
88 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
89 KEY_L, BOTH, XKB_KEY_L, NEXT,
90 KEY_O, BOTH, XKB_KEY_O, FINISH));
91
92 /*
93 * A base modifier should only be cleared when no other key affecting
94 * the modifier is down.
95 */
96 assert(test_key_seq(keymap,
97 KEY_H, BOTH, XKB_KEY_h, NEXT,
98 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
99 KEY_E, BOTH, XKB_KEY_E, NEXT,
100 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
101 KEY_L, BOTH, XKB_KEY_L, NEXT,
102 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
103 KEY_L, BOTH, XKB_KEY_L, NEXT,
104 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
105 KEY_O, BOTH, XKB_KEY_o, FINISH));
106
107 /*
108 * Two key presses from the same key (e.g. if two keyboards use the
109 * same xkb_state) should only be released after two releases.
110 */
111 assert(test_key_seq(keymap,
112 KEY_H, BOTH, XKB_KEY_h, NEXT,
113 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
114 KEY_H, BOTH, XKB_KEY_H, NEXT,
115 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
116 KEY_H, BOTH, XKB_KEY_H, NEXT,
117 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
118 KEY_H, BOTH, XKB_KEY_H, NEXT,
119 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
120 KEY_H, BOTH, XKB_KEY_h, FINISH));
121
122 /* Same as above with locked modifiers. */
123 assert(test_key_seq(keymap,
124 KEY_H, BOTH, XKB_KEY_h, NEXT,
125 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
126 KEY_H, BOTH, XKB_KEY_H, NEXT,
127 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
128 KEY_H, BOTH, XKB_KEY_H, NEXT,
129 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
130 KEY_H, BOTH, XKB_KEY_H, NEXT,
131 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
132 KEY_H, BOTH, XKB_KEY_H, NEXT,
133 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
134 KEY_H, BOTH, XKB_KEY_h, FINISH));
135
136 /* Group switching / locking. */
137 assert(test_key_seq(keymap,
138 KEY_H, BOTH, XKB_KEY_h, NEXT,
139 KEY_E, BOTH, XKB_KEY_e, NEXT,
140 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
141 KEY_K, BOTH, XKB_KEY_hebrew_lamed, NEXT,
142 KEY_F, BOTH, XKB_KEY_hebrew_kaph, NEXT,
143 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
144 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
145 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
146 KEY_O, BOTH, XKB_KEY_o, FINISH));
147
148 assert(test_key_seq(keymap,
149 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
150 KEY_LEFTALT, DOWN, XKB_KEY_ISO_Next_Group, NEXT,
151 KEY_LEFTALT, UP, XKB_KEY_ISO_Next_Group, NEXT,
152 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, FINISH));
153
154 assert(test_key_seq(keymap,
155 KEY_LEFTALT, DOWN, XKB_KEY_Alt_L, NEXT,
156 KEY_LEFTSHIFT, DOWN, XKB_KEY_ISO_Next_Group, NEXT,
157 KEY_LEFTSHIFT, UP, XKB_KEY_ISO_Next_Group, NEXT,
158 KEY_LEFTALT, UP, XKB_KEY_Alt_L, FINISH));
159
160 /* Locked modifiers. */
161 assert(test_key_seq(keymap,
162 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
163 KEY_H, BOTH, XKB_KEY_H, NEXT,
164 KEY_E, BOTH, XKB_KEY_E, NEXT,
165 KEY_L, BOTH, XKB_KEY_L, NEXT,
166 KEY_L, BOTH, XKB_KEY_L, NEXT,
167 KEY_O, BOTH, XKB_KEY_O, FINISH));
168
169 assert(test_key_seq(keymap,
170 KEY_H, BOTH, XKB_KEY_h, NEXT,
171 KEY_E, BOTH, XKB_KEY_e, NEXT,
172 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
173 KEY_L, BOTH, XKB_KEY_L, NEXT,
174 KEY_L, BOTH, XKB_KEY_L, NEXT,
175 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
176 KEY_O, BOTH, XKB_KEY_o, FINISH));
177
178 assert(test_key_seq(keymap,
179 KEY_H, BOTH, XKB_KEY_h, NEXT,
180 KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT,
181 KEY_E, BOTH, XKB_KEY_E, NEXT,
182 KEY_L, BOTH, XKB_KEY_L, NEXT,
183 KEY_L, BOTH, XKB_KEY_L, NEXT,
184 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
185 KEY_O, BOTH, XKB_KEY_O, FINISH));
186
187 assert(test_key_seq(keymap,
188 KEY_H, BOTH, XKB_KEY_h, NEXT,
189 KEY_E, BOTH, XKB_KEY_e, NEXT,
190 KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT,
191 KEY_L, BOTH, XKB_KEY_l, NEXT,
192 KEY_L, BOTH, XKB_KEY_l, NEXT,
193 KEY_O, BOTH, XKB_KEY_o, FINISH));
194
195 /*
196 * A key release affecting a locked modifier should clear it
197 * regardless of the key press.
198 */
199 /* assert(test_key_seq(keymap, */
200 /* KEY_H, BOTH, XKB_KEY_h, NEXT, */
201 /* KEY_CAPSLOCK, DOWN, XKB_KEY_Caps_Lock, NEXT, */
202 /* KEY_E, BOTH, XKB_KEY_E, NEXT, */
203 /* KEY_L, BOTH, XKB_KEY_L, NEXT, */
204 /* KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT, */
205 /* KEY_L, BOTH, XKB_KEY_L, NEXT, */
206 /* KEY_CAPSLOCK, UP, XKB_KEY_Caps_Lock, NEXT, */
207 /* KEY_O, BOTH, XKB_KEY_o, FINISH)); */
208
209 /* Simple Num Lock sanity check. */
210 assert(test_key_seq(keymap,
211 KEY_KP1, BOTH, XKB_KEY_KP_End, NEXT,
212 KEY_NUMLOCK, BOTH, XKB_KEY_Num_Lock, NEXT,
213 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
214 KEY_KP2, BOTH, XKB_KEY_KP_2, NEXT,
215 KEY_NUMLOCK, BOTH, XKB_KEY_Num_Lock, NEXT,
216 KEY_KP2, BOTH, XKB_KEY_KP_Down, FINISH));
217
218 /* Test that the aliases in the ru(phonetic) symbols map work. */
219 assert(test_key_seq(keymap,
220 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
221 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
222 KEY_1, BOTH, XKB_KEY_1, NEXT,
223 KEY_Q, BOTH, XKB_KEY_Cyrillic_ya, NEXT,
224 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
225 KEY_1, BOTH, XKB_KEY_exclam, NEXT,
226 KEY_Q, BOTH, XKB_KEY_Cyrillic_YA, NEXT,
227 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
228 KEY_V, BOTH, XKB_KEY_Cyrillic_zhe, NEXT,
229 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
230 KEY_1, BOTH, XKB_KEY_1, NEXT,
231 KEY_V, BOTH, XKB_KEY_Cyrillic_ZHE, NEXT,
232 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
233 KEY_V, BOTH, XKB_KEY_Cyrillic_zhe, NEXT,
234 KEY_RIGHTSHIFT, UP, XKB_KEY_Shift_R, NEXT,
235 KEY_V, BOTH, XKB_KEY_Cyrillic_ZHE, FINISH));
236
237 #define KS(name) xkb_keysym_from_name(name, 0)
238
239 /* Test that levels (1-5) in de(neo) symbols map work. */
240 assert(test_key_seq(keymap,
241 /* Switch to the group. */
242 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
243 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
244 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
245
246 /* Level 1. */
247 KEY_1, BOTH, XKB_KEY_1, NEXT,
248 KEY_Q, BOTH, XKB_KEY_x, NEXT,
249 KEY_KP7, BOTH, XKB_KEY_KP_7, NEXT,
250 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
251
252 /* Level 2 with Shift. */
253 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
254 KEY_1, BOTH, XKB_KEY_degree, NEXT,
255 KEY_Q, BOTH, XKB_KEY_X, NEXT,
256 KEY_KP7, BOTH, KS("U2714"), NEXT,
257 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
258 /*
259 * XXX: de(neo) uses shift(both_capslock) which causes
260 * the interesting result in the next line. Since it's
261 * a key release, it doesn't actually lock the modifier,
262 * and applications by-and-large ignore the keysym on
263 * release(?). Is this a problem?
264 */
265 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
266
267 /* Level 2 with the Lock modifier. */
268 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
269 KEY_RIGHTSHIFT, BOTH, XKB_KEY_Caps_Lock, NEXT,
270 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
271 KEY_6, BOTH, XKB_KEY_6, NEXT,
272 KEY_H, BOTH, XKB_KEY_S, NEXT,
273 KEY_KP3, BOTH, XKB_KEY_KP_3, NEXT,
274 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
275 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
276 KEY_RIGHTSHIFT, BOTH, XKB_KEY_Caps_Lock, NEXT,
277 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
278
279 /* Level 3. */
280 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
281 KEY_6, BOTH, XKB_KEY_cent, NEXT,
282 KEY_Q, BOTH, XKB_KEY_ellipsis, NEXT,
283 KEY_KP7, BOTH, KS("U2195"), NEXT,
284 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
285 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
286
287 /* Level 4. */
288 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
289 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
290 KEY_5, BOTH, XKB_KEY_malesymbol, NEXT,
291 KEY_E, BOTH, XKB_KEY_Greek_lambda, NEXT,
292 KEY_SPACE, BOTH, XKB_KEY_nobreakspace, NEXT,
293 KEY_KP8, BOTH, XKB_KEY_intersection, NEXT,
294 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
295 KEY_LEFTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
296 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
297
298 /* Level 5. */
299 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
300 /* XXX: xkeyboard-config is borked when de(neo) is
301 * not the first group - not our fault. We test
302 * Level5 seprately below with only de(neo). */
303 /* KEY_5, BOTH, XKB_KEY_periodcentered, NEXT, */
304 /* KEY_E, BOTH, XKB_KEY_Up, NEXT, */
305 /* KEY_SPACE, BOTH, XKB_KEY_KP_0, NEXT, */
306 /* KEY_KP8, BOTH, XKB_KEY_KP_Up, NEXT, */
307 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
308 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Shift, NEXT,
309
310 KEY_V, BOTH, XKB_KEY_p, FINISH));
311
312 xkb_keymap_unref(keymap);
313 keymap = test_compile_rules(ctx, "evdev", "", "de", "neo", "");
314 assert(keymap);
315 assert(test_key_seq(keymap,
316 /* Level 5. */
317 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
318 KEY_5, BOTH, XKB_KEY_periodcentered, NEXT,
319 KEY_E, BOTH, XKB_KEY_Up, NEXT,
320 KEY_SPACE, BOTH, XKB_KEY_KP_0, NEXT,
321 KEY_KP8, BOTH, XKB_KEY_KP_Up, NEXT,
322 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
323 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Lock, NEXT,
324
325 /* Level 6. */
326 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
327 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
328 KEY_5, BOTH, XKB_KEY_NoSymbol, NEXT,
329 KEY_8, BOTH, XKB_KEY_ISO_Left_Tab, NEXT,
330 KEY_E, BOTH, XKB_KEY_Up, NEXT,
331 KEY_SPACE, BOTH, XKB_KEY_KP_0, NEXT,
332 KEY_KP8, BOTH, XKB_KEY_KP_Up, NEXT,
333 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
334 KEY_RIGHTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
335 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Lock, NEXT,
336
337 /* Level 7. */
338 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
339 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
340 KEY_5, BOTH, KS("U2221"), NEXT,
341 KEY_E, BOTH, XKB_KEY_Greek_LAMBDA, NEXT,
342 KEY_SPACE, BOTH, KS("U202F"), NEXT,
343 KEY_KP8, BOTH, KS("U22C2"), NEXT,
344 KEY_ESC, BOTH, XKB_KEY_Escape, NEXT,
345 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
346 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Lock, NEXT,
347
348 /* Level 8. */
349 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level5_Shift, NEXT,
350 KEY_CAPSLOCK, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
351 KEY_RIGHTSHIFT, DOWN, XKB_KEY_Shift_R, NEXT,
352 KEY_TAB, BOTH, XKB_KEY_ISO_Level5_Lock, NEXT,
353 KEY_V, BOTH, XKB_KEY_Greek_pi, NEXT,
354 KEY_RIGHTSHIFT, UP, XKB_KEY_Caps_Lock, NEXT,
355 KEY_V, BOTH, XKB_KEY_asciitilde, NEXT,
356 KEY_CAPSLOCK, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
357 KEY_V, BOTH, XKB_KEY_p, NEXT,
358 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level5_Lock, NEXT,
359 /* Locks Level 5. */
360
361 KEY_V, BOTH, XKB_KEY_Return, FINISH));
362
363
364 xkb_keymap_unref(keymap);
365 keymap = test_compile_rules(ctx, "evdev", "", "us,il,ru", "",
366 "grp:alt_shift_toggle_bidir,grp:menu_toggle");
367 assert(keymap);
368
369 assert(test_key_seq(keymap,
370 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
371 KEY_LEFTALT, DOWN, XKB_KEY_ISO_Prev_Group, NEXT,
372 KEY_LEFTALT, UP, XKB_KEY_ISO_Prev_Group, NEXT,
373 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, FINISH));
374
375 assert(test_key_seq(keymap,
376 KEY_LEFTALT, DOWN, XKB_KEY_Alt_L, NEXT,
377 KEY_LEFTSHIFT, DOWN, XKB_KEY_ISO_Prev_Group, NEXT,
378 KEY_LEFTSHIFT, UP, XKB_KEY_ISO_Prev_Group, NEXT,
379 KEY_LEFTALT, UP, XKB_KEY_Alt_L, FINISH));
380
381 /* Check backwards (negative) group switching and wrapping. */
382 assert(test_key_seq(keymap,
383 KEY_H, BOTH, XKB_KEY_h, NEXT,
384 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
385 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
386 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
387 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
388 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
389 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
390 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
391 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
392 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
393 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
394 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
395 KEY_H, BOTH, XKB_KEY_h, NEXT,
396 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
397 KEY_LEFTALT, BOTH, XKB_KEY_ISO_Prev_Group, NEXT,
398 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
399 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
400 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
401 KEY_H, BOTH, XKB_KEY_h, FINISH));
402
403 xkb_keymap_unref(keymap);
404 keymap = test_compile_rules(ctx, "evdev", "", "us,il,ru", "",
405 "grp:switch,grp:lswitch,grp:menu_toggle");
406 assert(keymap);
407
408 /* Test depressed group works (Mode_switch). */
409 assert(test_key_seq(keymap,
410 KEY_H, BOTH, XKB_KEY_h, NEXT,
411 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
412 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
413 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
414 KEY_H, BOTH, XKB_KEY_h, NEXT,
415 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
416 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
417 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
418 KEY_H, BOTH, XKB_KEY_h, FINISH));
419
420 /* Test locked+depressed group works, with wrapping and accumulation. */
421 assert(test_key_seq(keymap,
422 KEY_H, BOTH, XKB_KEY_h, NEXT,
423 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
424 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
425 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
426 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
427 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
428 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
429 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
430 /* Should wrap back to first group. */
431 KEY_H, BOTH, XKB_KEY_h, NEXT,
432 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
433 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
434 KEY_COMPOSE, BOTH, XKB_KEY_ISO_Next_Group, NEXT,
435 KEY_H, BOTH, XKB_KEY_h, NEXT,
436 /* Two SetGroup(+1)'s should add up. */
437 KEY_RIGHTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
438 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
439 KEY_LEFTALT, DOWN, XKB_KEY_Mode_switch, NEXT,
440 KEY_H, BOTH, XKB_KEY_Cyrillic_er, NEXT,
441 KEY_LEFTALT, UP, XKB_KEY_Mode_switch, NEXT,
442 KEY_H, BOTH, XKB_KEY_hebrew_yod, NEXT,
443 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, NEXT,
444 KEY_H, BOTH, XKB_KEY_h, FINISH));
445
446 xkb_keymap_unref(keymap);
447 keymap = test_compile_rules(ctx, "evdev", "", "us", "euro", "");
448 assert(keymap);
449
450 assert(test_key_seq(keymap,
451 KEY_5, BOTH, XKB_KEY_5, NEXT,
452 KEY_RIGHTALT, DOWN, XKB_KEY_ISO_Level3_Shift, NEXT,
453 KEY_5, BOTH, XKB_KEY_EuroSign, NEXT,
454 KEY_RIGHTALT, UP, XKB_KEY_ISO_Level3_Shift, FINISH));
455
456 xkb_keymap_unref(keymap);
457 keymap = test_compile_file(ctx, "keymaps/unbound-vmod.xkb");
458 assert(keymap);
459
460 assert(test_key_seq(keymap,
461 KEY_H, BOTH, XKB_KEY_h, NEXT,
462 KEY_Z, BOTH, XKB_KEY_y, NEXT,
463 KEY_MINUS, BOTH, XKB_KEY_ssharp, NEXT,
464 KEY_Z, BOTH, XKB_KEY_y, FINISH));
465
466 xkb_keymap_unref(keymap);
467 keymap = test_compile_rules(ctx, "evdev", "applealu_ansi", "us", "",
468 "terminate:ctrl_alt_bksp");
469 assert(keymap);
470
471 assert(test_key_seq(keymap,
472 KEY_5, BOTH, XKB_KEY_5, NEXT,
473 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
474 KEY_NUMLOCK, BOTH, XKB_KEY_Clear, NEXT,
475 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
476 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
477 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
478 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
479 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
480 KEY_LEFTSHIFT, DOWN, XKB_KEY_Shift_L, NEXT,
481 KEY_KP1, BOTH, XKB_KEY_KP_1, NEXT,
482 KEY_LEFTSHIFT, UP, XKB_KEY_Shift_L, NEXT,
483 KEY_CAPSLOCK, BOTH, XKB_KEY_Caps_Lock, NEXT,
484 KEY_A, BOTH, XKB_KEY_a, FINISH));
485
486 xkb_keymap_unref(keymap);
487 xkb_context_unref(ctx);
488 return 0;
489 }
490