test/state.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   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  * Author: Daniel Stone <daniel@fooishbar.org>
  24  */
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31
  32 #include "evdev-scancodes.h"
  33 #include "test.h"
  34
  35 /* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
  36  * keycode set (where ESC is 9). */
  37 #define EVDEV_OFFSET 8
  38
  39 static void
  40 print_state(struct xkb_state *state)
  41 {
  42     struct xkb_keymap *keymap;
  43     xkb_layout_index_t group;
  44     xkb_mod_index_t mod;
  45     xkb_led_index_t led;
  46
  47     group = xkb_state_serialize_layout(state, XKB_STATE_LAYOUT_EFFECTIVE);
  48     mod = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
  49     /* led = xkb_state_serialize_leds(state, XKB_STATE_LEDS); */
  50     if (!group && !mod /* && !led */) {
  51         fprintf(stderr, "\tno state\n");
  52         return;
  53     }
  54
  55     keymap = xkb_state_get_keymap(state);
  56
  57     for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
  58         if (xkb_state_layout_index_is_active(state, group,
  59                                              XKB_STATE_LAYOUT_EFFECTIVE |
  60                                              XKB_STATE_LAYOUT_DEPRESSED |
  61                                              XKB_STATE_LAYOUT_LATCHED |
  62                                              XKB_STATE_LAYOUT_LOCKED) <= 0)
  63             continue;
  64         fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
  65                 xkb_keymap_layout_get_name(keymap, group),
  66                 group,
  67                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_EFFECTIVE) > 0 ?
  68                     "effective " : "",
  69                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_DEPRESSED) > 0 ?
  70                     "depressed " : "",
  71                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LATCHED) > 0 ?
  72                     "latched " : "",
  73                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LOCKED) > 0 ?
  74                     "locked " : "");
  75     }
  76
  77     for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
  78         if (xkb_state_mod_index_is_active(state, mod,
  79                                           XKB_STATE_MODS_EFFECTIVE |
  80                                           XKB_STATE_MODS_DEPRESSED |
  81                                           XKB_STATE_MODS_LATCHED |
  82                                           XKB_STATE_MODS_LOCKED) <= 0)
  83             continue;
  84         fprintf(stderr, "\tmod %s (%d): %s%s%s%s\n",
  85                 xkb_keymap_mod_get_name(keymap, mod),
  86                 mod,
  87                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_EFFECTIVE) > 0 ?
  88                     "effective " : "",
  89                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_DEPRESSED) > 0 ?
  90                     "depressed " : "",
  91                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LATCHED) > 0 ?
  92                     "latched " : "",
  93                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LOCKED) > 0 ?
  94                     "locked " : "");
  95     }
  96
  97     for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
  98         if (xkb_state_led_index_is_active(state, led) <= 0)
  99             continue;
 100         fprintf(stderr, "\tled %s (%d): active\n",
 101                 xkb_keymap_led_get_name(keymap, led),
 102                 led);
 103     }
 104 }
 105
 106 static void
 107 test_update_key(struct xkb_keymap *keymap)
 108 {
 109     struct xkb_state *state = xkb_state_new(keymap);
 110     const xkb_keysym_t *syms;
 111     xkb_keysym_t one_sym;
 112     int num_syms;
 113
 114     assert(state);
 115
 116     /* LCtrl down */
 117     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 118     fprintf(stderr, "dumping state for LCtrl down:\n");
 119     print_state(state);
 120     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 121                                         XKB_STATE_MODS_DEPRESSED) > 0);
 122
 123     /* LCtrl + RAlt down */
 124     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 125     fprintf(stderr, "dumping state for LCtrl + RAlt down:\n");
 126     print_state(state);
 127     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 128                                         XKB_STATE_MODS_DEPRESSED) > 0);
 129     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 130                                         XKB_STATE_MODS_DEPRESSED) > 0);
 131     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
 132                                           XKB_STATE_MATCH_ALL,
 133                                           XKB_MOD_NAME_CTRL,
 134                                           XKB_MOD_NAME_ALT,
 135                                           NULL) > 0);
 136     assert(xkb_state_mod_indices_are_active(state, XKB_STATE_MODS_DEPRESSED,
 137                                             XKB_STATE_MATCH_ALL,
 138                                             xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
 139                                             xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT),
 140                                             XKB_MOD_INVALID) > 0);
 141     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
 142                                           XKB_STATE_MATCH_ALL,
 143                                           XKB_MOD_NAME_ALT,
 144                                           NULL) == 0);
 145     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
 146                                           XKB_STATE_MATCH_ALL |
 147                                           XKB_STATE_MATCH_NON_EXCLUSIVE,
 148                                           XKB_MOD_NAME_ALT,
 149                                           NULL) > 0);
 150     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
 151                                           (XKB_STATE_MATCH_ANY |
 152                                            XKB_STATE_MATCH_NON_EXCLUSIVE),
 153                                           XKB_MOD_NAME_ALT,
 154                                           NULL) > 0);
 155
 156     /* RAlt down */
 157     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 158     fprintf(stderr, "dumping state for RAlt down:\n");
 159     print_state(state);
 160     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 161                                         XKB_STATE_MODS_EFFECTIVE) == 0);
 162     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 163                                         XKB_STATE_MODS_DEPRESSED) > 0);
 164     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
 165                                           XKB_STATE_MATCH_ANY,
 166                                           XKB_MOD_NAME_CTRL,
 167                                           XKB_MOD_NAME_ALT,
 168                                           NULL) > 0);
 169     assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_LATCHED,
 170                                           XKB_STATE_MATCH_ANY,
 171                                           XKB_MOD_NAME_CTRL,
 172                                           XKB_MOD_NAME_ALT,
 173                                           NULL) == 0);
 174
 175     /* none down */
 176     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
 177     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 178                                         XKB_STATE_MODS_EFFECTIVE) == 0);
 179
 180     /* Caps locked */
 181     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 182     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 183                                         XKB_STATE_MODS_DEPRESSED) > 0);
 184     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 185     fprintf(stderr, "dumping state for Caps Lock:\n");
 186     print_state(state);
 187     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 188                                         XKB_STATE_MODS_DEPRESSED) == 0);
 189     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 190                                         XKB_STATE_MODS_LOCKED) > 0);
 191     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
 192     num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 193     assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
 194
 195     /* Num Lock locked */
 196     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 197     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 198     fprintf(stderr, "dumping state for Caps Lock + Num Lock:\n");
 199     print_state(state);
 200     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 201                                         XKB_STATE_MODS_LOCKED) > 0);
 202     assert(xkb_state_mod_name_is_active(state, "Mod2",
 203                                         XKB_STATE_MODS_LOCKED) > 0);
 204     num_syms = xkb_state_key_get_syms(state, KEY_KP1 + EVDEV_OFFSET, &syms);
 205     assert(num_syms == 1 && syms[0] == XKB_KEY_KP_1);
 206     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) > 0);
 207
 208     /* Num Lock unlocked */
 209     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 210     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 211
 212     /* Switch to group 2 */
 213     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 214     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 215     assert(xkb_state_led_name_is_active(state, "Group 2") > 0);
 216     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) == 0);
 217
 218     /* Switch back to group 1. */
 219     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 220     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 221
 222     /* Caps unlocked */
 223     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 224     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 225     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 226                                         XKB_STATE_MODS_EFFECTIVE) == 0);
 227     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) == 0);
 228     num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 229     assert(num_syms == 1 && syms[0] == XKB_KEY_q);
 230
 231     /* Multiple symbols */
 232     num_syms = xkb_state_key_get_syms(state, KEY_6 + EVDEV_OFFSET, &syms);
 233     assert(num_syms == 5 &&
 234            syms[0] == XKB_KEY_H && syms[1] == XKB_KEY_E &&
 235            syms[2] == XKB_KEY_L && syms[3] == XKB_KEY_L &&
 236            syms[4] == XKB_KEY_O);
 237     one_sym = xkb_state_key_get_one_sym(state, KEY_6 + EVDEV_OFFSET);
 238     assert(one_sym == XKB_KEY_NoSymbol);
 239     xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_DOWN);
 240     xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_UP);
 241
 242     one_sym = xkb_state_key_get_one_sym(state, KEY_5 + EVDEV_OFFSET);
 243     assert(one_sym == XKB_KEY_5);
 244
 245     xkb_state_unref(state);
 246 }
 247
 248 static void
 249 test_serialisation(struct xkb_keymap *keymap)
 250 {
 251     struct xkb_state *state = xkb_state_new(keymap);
 252     xkb_mod_mask_t base_mods;
 253     xkb_mod_mask_t latched_mods;
 254     xkb_mod_mask_t locked_mods;
 255     xkb_mod_mask_t effective_mods;
 256     xkb_mod_index_t caps, shift, ctrl;
 257     xkb_layout_index_t base_group = 0;
 258     xkb_layout_index_t latched_group = 0;
 259     xkb_layout_index_t locked_group = 0;
 260
 261     assert(state);
 262
 263     caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 264     assert(caps != XKB_MOD_INVALID);
 265     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 266     assert(shift != XKB_MOD_INVALID);
 267     ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
 268     assert(ctrl != XKB_MOD_INVALID);
 269
 270     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 271     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 272     base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
 273     assert(base_mods == 0);
 274     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
 275     assert(latched_mods == 0);
 276     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
 277     assert(locked_mods == (1U << caps));
 278     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
 279     assert(effective_mods == locked_mods);
 280
 281     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 282     base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
 283     assert(base_mods == (1U << shift));
 284     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
 285     assert(latched_mods == 0);
 286     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
 287     assert(locked_mods == (1U << caps));
 288     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
 289     assert(effective_mods == (base_mods | locked_mods));
 290
 291     base_mods |= (1U << ctrl);
 292     xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
 293                           base_group, latched_group, locked_group);
 294
 295     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_DEPRESSED) > 0);
 296     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
 297
 298     xkb_state_unref(state);
 299 }
 300
 301 static void
 302 test_update_mask_mods(struct xkb_keymap *keymap)
 303 {
 304     struct xkb_state *state = xkb_state_new(keymap);
 305     xkb_mod_index_t caps, shift, num, alt, mod1, mod2;
 306     enum xkb_state_component changed;
 307
 308     assert(state);
 309
 310     caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 311     assert(caps != XKB_MOD_INVALID);
 312     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 313     assert(shift != XKB_MOD_INVALID);
 314     num = xkb_keymap_mod_get_index(keymap, "NumLock");
 315     assert(num != XKB_MOD_INVALID);
 316     alt = xkb_keymap_mod_get_index(keymap, "Alt");
 317     assert(alt != XKB_MOD_INVALID);
 318     mod1 = xkb_keymap_mod_get_index(keymap, "Mod1");
 319     assert(mod1 != XKB_MOD_INVALID);
 320     mod2 = xkb_keymap_mod_get_index(keymap, "Mod2");
 321     assert(mod2 != XKB_MOD_INVALID);
 322
 323     changed = xkb_state_update_mask(state, 1 << caps, 0, 0, 0, 0, 0);
 324     assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_EFFECTIVE));
 325     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
 326            (1u << caps));
 327
 328     changed = xkb_state_update_mask(state, (1 << caps), 0, (1 << shift), 0, 0, 0);
 329     assert(changed == (XKB_STATE_MODS_LOCKED | XKB_STATE_MODS_EFFECTIVE |
 330                        XKB_STATE_LEDS));
 331     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
 332            ((1u << caps) | (1u << shift)));
 333     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED) ==
 334            (1u << caps));
 335     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED) == 0);
 336     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED) ==
 337            (1u << shift));
 338
 339     changed = xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
 340     assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
 341                        XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
 342     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) == 0);
 343
 344     changed = xkb_state_update_mask(state, (1 << alt), 0, 0, 0, 0, 0);
 345     assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_EFFECTIVE));
 346     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
 347            ((1u << alt) | (1u << mod1)));
 348
 349     changed = xkb_state_update_mask(state, 0, 0, (1 << num), 0, 0, 0);
 350     assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
 351                        XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
 352     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
 353            ((1u << num) | (1u << mod2)));
 354
 355     xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
 356
 357     changed = xkb_state_update_mask(state, (1 << mod2), 0, (1 << num), 0, 0, 0);
 358     assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
 359                        XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
 360     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
 361            ((1u << mod2) | (1u << num)));
 362     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED) ==
 363            (1u << mod2));
 364     assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED) ==
 365            ((1u << num) | (1u << mod2)));
 366
 367     xkb_state_unref(state);
 368 }
 369
 370 static void
 371 test_repeat(struct xkb_keymap *keymap)
 372 {
 373     assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + 8));
 374     assert(xkb_keymap_key_repeats(keymap, KEY_A + 8));
 375     assert(xkb_keymap_key_repeats(keymap, KEY_8 + 8));
 376     assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + 8));
 377     assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
 378 }
 379
 380 static void
 381 test_consume(struct xkb_keymap *keymap)
 382 {
 383     struct xkb_state *state;
 384     xkb_mod_index_t alt, shift, caps, ctrl, mod5;
 385     xkb_mod_mask_t mask;
 386
 387     state = xkb_state_new(keymap);
 388     assert(state);
 389
 390     alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
 391     assert(alt != XKB_MOD_INVALID);
 392     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 393     assert(shift != XKB_MOD_INVALID);
 394     caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 395     assert(caps != XKB_MOD_INVALID);
 396     ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
 397     assert(ctrl != XKB_MOD_INVALID);
 398     mod5 = xkb_keymap_mod_get_index(keymap, "Mod5");
 399     assert(mod5 != XKB_MOD_INVALID);
 400
 401     /* Test remove_consumed() */
 402     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 403     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 404     xkb_state_update_key(state, KEY_EQUAL + EVDEV_OFFSET, XKB_KEY_DOWN);
 405
 406     fprintf(stderr, "dumping state for Alt-Shift-+\n");
 407     print_state(state);
 408
 409     mask = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
 410     assert(mask == ((1U << alt) | (1U << shift)));
 411     mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
 412                                               mask);
 413     assert(mask == (1U << alt));
 414
 415     /* Test get_consumed_mods() */
 416     mask = xkb_state_key_get_consumed_mods(state, KEY_EQUAL + EVDEV_OFFSET);
 417     assert(mask == (1U << shift));
 418
 419     mask = xkb_state_key_get_consumed_mods(state, KEY_ESC + EVDEV_OFFSET);
 420     assert(mask == 0);
 421
 422     xkb_state_unref(state);
 423
 424     /* Test is_consumed() - simple ALPHABETIC type. */
 425     state = xkb_state_new(keymap);
 426     assert(state);
 427
 428     mask = xkb_state_key_get_consumed_mods(state, KEY_A + EVDEV_OFFSET);
 429     assert(mask == ((1U << shift) | (1U << caps)));
 430
 431     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
 432     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
 433     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 434     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 435     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
 436     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
 437     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 438     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
 439     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
 440     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
 441     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 442     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 443     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
 444     assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
 445
 446     xkb_state_unref(state);
 447
 448     /* More complicated - CTRL+ALT */
 449     state = xkb_state_new(keymap);
 450     assert(state);
 451
 452     mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
 453     assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
 454
 455     /* Shift is preserved. */
 456     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 457     mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
 458     assert(mask == ((1U << alt) | (1U << ctrl) | (1U << mod5)));
 459     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
 460
 461     mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
 462     assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
 463
 464     xkb_state_unref(state);
 465
 466     /* Test XKB_CONSUMED_MODE_GTK, CTRL+ALT */
 467     state = xkb_state_new(keymap);
 468     assert(state);
 469
 470     mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
 471                                             XKB_CONSUMED_MODE_GTK);
 472     assert(mask == 0);
 473
 474     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 475     mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
 476                                             XKB_CONSUMED_MODE_GTK);
 477     assert(mask == 0);
 478
 479     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 480     mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
 481                                             XKB_CONSUMED_MODE_GTK);
 482     assert(mask == ((1U << alt) | (1U << ctrl)));
 483
 484     xkb_state_unref(state);
 485
 486     /* Test XKB_CONSUMED_MODE_GTK, Simple Shift */
 487     state = xkb_state_new(keymap);
 488     assert(state);
 489
 490     mask = xkb_state_key_get_consumed_mods2(state, KEY_A + EVDEV_OFFSET,
 491                                             XKB_CONSUMED_MODE_GTK);
 492     assert(mask == ((1U << shift) | (1U << caps)));
 493
 494     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 495     mask = xkb_state_key_get_consumed_mods2(state, KEY_A + EVDEV_OFFSET,
 496                                             XKB_CONSUMED_MODE_GTK);
 497     assert(mask == ((1U << shift) | (1U << caps)));
 498
 499     xkb_state_unref(state);
 500 }
 501
 502 static void
 503 key_iter(struct xkb_keymap *keymap, xkb_keycode_t key, void *data)
 504 {
 505     xkb_keycode_t *counter = data;
 506
 507     assert(*counter == key);
 508     (*counter)++;
 509 }
 510
 511 static void
 512 test_range(struct xkb_keymap *keymap)
 513 {
 514     xkb_keycode_t counter;
 515
 516     assert(xkb_keymap_min_keycode(keymap) == 9);
 517     assert(xkb_keymap_max_keycode(keymap) == 569);
 518
 519     counter = xkb_keymap_min_keycode(keymap);
 520     xkb_keymap_key_for_each(keymap, key_iter, &counter);
 521     assert(counter == xkb_keymap_max_keycode(keymap) + 1);
 522 }
 523
 524 static void
 525 test_caps_keysym_transformation(struct xkb_keymap *keymap)
 526 {
 527     struct xkb_state *state = xkb_state_new(keymap);
 528     xkb_mod_index_t caps, shift;
 529     int nsyms;
 530     xkb_keysym_t sym;
 531     const xkb_keysym_t *syms;
 532
 533     assert(state);
 534
 535     /* See xkb_state_key_get_one_sym() for what's this all about. */
 536
 537     caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 538     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 539     assert(caps != XKB_MOD_INVALID && shift != XKB_MOD_INVALID);
 540
 541     assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
 542     assert(xkb_state_key_get_layout(state, KEY_SEMICOLON + 8) == 0);
 543
 544     /* Without caps, no transformation. */
 545     assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
 546     assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
 547     assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 0);
 548     sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
 549     assert(sym == XKB_KEY_a);
 550     assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
 551     sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
 552     assert(sym == XKB_KEY_eacute);
 553     nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
 554     assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
 555
 556     /* With shift, no transformation (only different level). */
 557     xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_DOWN);
 558     assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
 559     assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) > 0);
 560     assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
 561     sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
 562     assert(sym == XKB_KEY_A);
 563     sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
 564     assert(sym == XKB_KEY_odiaeresis);
 565     nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
 566     assert(nsyms == 1 && syms[0] == XKB_KEY_odiaeresis);
 567     xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
 568     assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
 569
 570     /* With caps, transform in same level, only with _get_one_sym(). */
 571     xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
 572     xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
 573     assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0);
 574     assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
 575     assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
 576     sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
 577     assert(sym == XKB_KEY_A);
 578     assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
 579     sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
 580     assert(sym == XKB_KEY_Eacute);
 581     nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
 582     assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
 583     xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
 584     assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
 585     xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
 586     xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
 587
 588     xkb_state_unref(state);
 589 }
 590
 591 static void
 592 test_get_utf8_utf32(struct xkb_keymap *keymap)
 593 {
 594     char buf[256];
 595     struct xkb_state *state = xkb_state_new(keymap);
 596     assert(state);
 597
 598 #define TEST_KEY(key, expected_utf8, expected_utf32) do { \
 599     assert(xkb_state_key_get_utf8(state, key + 8, NULL, 0) == strlen(expected_utf8)); \
 600     assert(xkb_state_key_get_utf8(state, key + 8, buf, sizeof(buf)) == strlen(expected_utf8)); \
 601     assert(memcmp(buf, expected_utf8, sizeof(expected_utf8)) == 0); \
 602     assert(xkb_state_key_get_utf32(state, key + 8) == expected_utf32); \
 603 } while (0)
 604
 605     /* Simple ASCII. */
 606     TEST_KEY(KEY_A, "a", 0x61);
 607     TEST_KEY(KEY_ESC, "\x1B", 0x1B);
 608     TEST_KEY(KEY_1, "1", 0x31);
 609
 610     /* Invalid. */
 611     TEST_KEY(XKB_KEYCODE_INVALID - 8, "", 0);
 612     TEST_KEY(300, "", 0);
 613
 614     /* No string. */
 615     TEST_KEY(KEY_LEFTCTRL, "", 0);
 616     TEST_KEY(KEY_NUMLOCK, "", 0);
 617
 618     /* Multiple keysyms. */
 619     TEST_KEY(KEY_6, "HELLO", 0);
 620     TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
 621
 622     /* Check truncation. */
 623     memset(buf, 'X', sizeof(buf));
 624     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 0) == strlen("HELLO"));
 625     assert(memcmp(buf, "X", 1) == 0);
 626     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 1) == strlen("HELLO"));
 627     assert(memcmp(buf, "", 1) == 0);
 628     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 2) == strlen("HELLO"));
 629     assert(memcmp(buf, "H", 2) == 0);
 630     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 3) == strlen("HELLO"));
 631     assert(memcmp(buf, "HE", 3) == 0);
 632     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 5) == strlen("HELLO"));
 633     assert(memcmp(buf, "HELL", 5) == 0);
 634     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 6) == strlen("HELLO"));
 635     assert(memcmp(buf, "HELLO", 6) == 0);
 636     assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 7) == strlen("HELLO"));
 637     assert(memcmp(buf, "HELLO\0X", 7) == 0);
 638
 639     /* Switch to ru layout */
 640     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 641     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 642     assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
 643
 644     /* Non ASCII. */
 645     TEST_KEY(KEY_ESC, "\x1B", 0x1B);
 646     TEST_KEY(KEY_A, "ф", 0x0444);
 647     TEST_KEY(KEY_Z, "я", 0x044F);
 648
 649     /* Switch back to us layout */
 650     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 651     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 652     assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
 653
 654     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 655     TEST_KEY(KEY_A, "A", 0x41);
 656     TEST_KEY(KEY_ESC, "\x1B", 0x1B);
 657     TEST_KEY(KEY_1, "!", 0x21);
 658     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
 659
 660     TEST_KEY(KEY_6, "HELLO", 0);
 661     TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
 662
 663     xkb_state_unref(state);
 664 }
 665
 666 static void
 667 test_ctrl_string_transformation(struct xkb_keymap *keymap)
 668 {
 669     char buf[256];
 670     struct xkb_state *state = xkb_state_new(keymap);
 671     xkb_mod_index_t ctrl;
 672
 673     assert(state);
 674
 675     /* See xkb_state_key_get_utf8() for what's this all about. */
 676
 677     ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
 678     assert(ctrl != XKB_MOD_INVALID);
 679
 680     /* First without. */
 681     TEST_KEY(KEY_A, "a", 0x61);
 682     TEST_KEY(KEY_B, "b", 0x62);
 683     TEST_KEY(KEY_C, "c", 0x63);
 684     TEST_KEY(KEY_ESC, "\x1B", 0x1B);
 685     TEST_KEY(KEY_1, "1", 0x31);
 686
 687     /* And with. */
 688     xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 689     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
 690     TEST_KEY(KEY_A, "\x01", 0x01);
 691     TEST_KEY(KEY_B, "\x02", 0x02);
 692     TEST_KEY(KEY_C, "\x03", 0x03);
 693     TEST_KEY(KEY_ESC, "\x1B", 0x1B);
 694     TEST_KEY(KEY_1, "1", 0x31);
 695     xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 696
 697     /* Switch to ru layout */
 698     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 699     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 700     assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
 701
 702     /* Non ASCII. */
 703     xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 704     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
 705     TEST_KEY(KEY_A, "\x01", 0x01);
 706     TEST_KEY(KEY_B, "\x02", 0x02);
 707     xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 708
 709     xkb_state_unref(state);
 710 }
 711
 712 int
 713 main(void)
 714 {
 715     struct xkb_context *context = test_get_context(0);
 716     struct xkb_keymap *keymap;
 717
 718     assert(context);
 719
 720     /* Make sure these are allowed. */
 721     xkb_context_unref(NULL);
 722     xkb_keymap_unref(NULL);
 723     xkb_state_unref(NULL);
 724
 725     keymap = test_compile_rules(context, "evdev", "pc104", "us,ru", NULL, "grp:menu_toggle");
 726     assert(keymap);
 727
 728     test_update_key(keymap);
 729     test_serialisation(keymap);
 730     test_update_mask_mods(keymap);
 731     test_repeat(keymap);
 732     test_consume(keymap);
 733     test_range(keymap);
 734     test_get_utf8_utf32(keymap);
 735     test_ctrl_string_transformation(keymap);
 736
 737     xkb_keymap_unref(keymap);
 738     keymap = test_compile_rules(context, "evdev", NULL, "ch", "fr", NULL);
 739     assert(keymap);
 740
 741     test_caps_keysym_transformation(keymap);
 742
 743     xkb_keymap_unref(keymap);
 744     xkb_context_unref(context);
 745 }