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 <assert.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <linux/input.h>
  30
  31 #include "test.h"
  32
  33 /* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
  34  * keycode set (where ESC is 9). */
  35 #define EVDEV_OFFSET 8
  36
  37 static void
  38 print_state(struct xkb_state *state)
  39 {
  40     struct xkb_keymap *keymap;
  41     xkb_layout_index_t group;
  42     xkb_mod_index_t mod;
  43     xkb_led_index_t led;
  44
  45     group = xkb_state_serialize_layout(state, XKB_STATE_EFFECTIVE);
  46     mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
  47     /* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
  48     if (!group && !mod /* && !led */) {
  49         fprintf(stderr, "\tno state\n");
  50         return;
  51     }
  52
  53     keymap = xkb_state_get_keymap(state);
  54
  55     for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
  56         if (xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
  57             continue;
  58         fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
  59                 xkb_keymap_layout_get_name(keymap, group),
  60                 group,
  61                 xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
  62                     "effective " : "",
  63                 xkb_state_layout_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
  64                     "depressed " : "",
  65                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
  66                     "latched " : "",
  67                 xkb_state_layout_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
  68                     "locked " : "");
  69     }
  70
  71     for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
  72         if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
  73             continue;
  74         fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
  75                 xkb_keymap_mod_get_name(keymap, mod),
  76                 mod,
  77                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) > 0 ?
  78                     "depressed " : "",
  79                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LATCHED) > 0 ?
  80                     "latched " : "",
  81                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LOCKED) > 0 ?
  82                     "locked " : "");
  83     }
  84
  85     for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
  86         if (xkb_state_led_index_is_active(state, led) <= 0)
  87             continue;
  88         fprintf(stderr, "\tled %s (%d): active\n",
  89                 xkb_keymap_led_get_name(keymap, led),
  90                 led);
  91     }
  92 }
  93
  94 static void
  95 test_update_key(struct xkb_keymap *keymap)
  96 {
  97     struct xkb_state *state = xkb_state_new(keymap);
  98     const xkb_keysym_t *syms;
  99     xkb_keysym_t one_sym;
 100     int num_syms;
 101
 102     assert(state);
 103
 104     /* LCtrl down */
 105     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 106     fprintf(stderr, "dumping state for LCtrl down:\n");
 107     print_state(state);
 108     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 109                                         XKB_STATE_DEPRESSED) > 0);
 110
 111     /* LCtrl + RAlt down */
 112     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 113     fprintf(stderr, "dumping state for LCtrl + RAlt down:\n");
 114     print_state(state);
 115     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 116                                         XKB_STATE_DEPRESSED) > 0);
 117     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 118                                         XKB_STATE_DEPRESSED) > 0);
 119     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 120                                           XKB_STATE_MATCH_ALL,
 121                                           XKB_MOD_NAME_CTRL,
 122                                           XKB_MOD_NAME_ALT,
 123                                           NULL) > 0);
 124     assert(xkb_state_mod_indices_are_active(state, XKB_STATE_DEPRESSED,
 125                                           XKB_STATE_MATCH_ALL,
 126                                           xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
 127                                           xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT),
 128                                           XKB_MOD_INVALID) > 0);
 129     assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 130                                            XKB_STATE_MATCH_ALL,
 131                                            XKB_MOD_NAME_ALT,
 132                                            NULL) > 0);
 133     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 134                                           (XKB_STATE_MATCH_ANY |
 135                                            XKB_STATE_MATCH_NON_EXCLUSIVE),
 136                                           XKB_MOD_NAME_ALT,
 137                                           NULL));
 138
 139     /* RAlt down */
 140     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 141     fprintf(stderr, "dumping state for RAlt down:\n");
 142     print_state(state);
 143     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 144                                          XKB_STATE_EFFECTIVE) > 0);
 145     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 146                                         XKB_STATE_DEPRESSED) > 0);
 147     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 148                                           XKB_STATE_MATCH_ANY,
 149                                           XKB_MOD_NAME_CTRL,
 150                                           XKB_MOD_NAME_ALT,
 151                                           NULL) > 0);
 152     assert(xkb_state_mod_names_are_active(state, XKB_STATE_LATCHED,
 153                                           XKB_STATE_MATCH_ANY,
 154                                           XKB_MOD_NAME_CTRL,
 155                                           XKB_MOD_NAME_ALT,
 156                                           NULL) == 0);
 157
 158     /* none down */
 159     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
 160     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 161                                          XKB_STATE_EFFECTIVE));
 162
 163     /* Caps locked */
 164     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 165     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 166                                         XKB_STATE_DEPRESSED) > 0);
 167     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 168     fprintf(stderr, "dumping state for Caps Lock:\n");
 169     print_state(state);
 170     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 171                                         XKB_STATE_DEPRESSED) == 0);
 172     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 173                                         XKB_STATE_LOCKED) > 0);
 174     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
 175     num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 176     assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
 177
 178     /* Num Lock locked */
 179     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 180     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 181     fprintf(stderr, "dumping state for Caps Lock + Num Lock:\n");
 182     print_state(state);
 183     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 184                                         XKB_STATE_LOCKED) > 0);
 185     assert(xkb_state_mod_name_is_active(state, "Mod2",
 186                                         XKB_STATE_LOCKED) > 0);
 187     num_syms = xkb_state_key_get_syms(state, KEY_KP1 + EVDEV_OFFSET, &syms);
 188     assert(num_syms == 1 && syms[0] == XKB_KEY_KP_1);
 189     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) > 0);
 190
 191     /* Num Lock unlocked */
 192     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 193     xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 194
 195     /* Switch to group 2 */
 196     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 197     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 198     assert(xkb_state_led_name_is_active(state, "Group 2") > 0);
 199     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) <= 0);
 200
 201     /* Switch back to group 1. */
 202     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
 203     xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
 204
 205     /* Caps unlocked */
 206     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 207     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 208     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 209                                          XKB_STATE_EFFECTIVE) > 0);
 210     assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
 211     num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 212     assert(num_syms == 1 && syms[0] == XKB_KEY_q);
 213
 214     /* Multiple symbols */
 215     num_syms = xkb_state_key_get_syms(state, KEY_6 + EVDEV_OFFSET, &syms);
 216     assert(num_syms == 5 &&
 217            syms[0] == XKB_KEY_H && syms[1] == XKB_KEY_E &&
 218            syms[2] == XKB_KEY_L && syms[3] == XKB_KEY_L &&
 219            syms[4] == XKB_KEY_O);
 220     one_sym = xkb_state_key_get_one_sym(state, KEY_6 + EVDEV_OFFSET);
 221     assert(one_sym == XKB_KEY_NoSymbol);
 222     xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_DOWN);
 223     xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_UP);
 224
 225     one_sym = xkb_state_key_get_one_sym(state, KEY_5 + EVDEV_OFFSET);
 226     assert(one_sym == XKB_KEY_5);
 227
 228     xkb_state_unref(state);
 229 }
 230
 231 static void
 232 test_serialisation(struct xkb_keymap *keymap)
 233 {
 234     struct xkb_state *state = xkb_state_new(keymap);
 235     xkb_mod_mask_t base_mods;
 236     xkb_mod_mask_t latched_mods;
 237     xkb_mod_mask_t locked_mods;
 238     xkb_mod_mask_t effective_mods;
 239     xkb_mod_index_t caps, shift, ctrl;
 240     xkb_layout_index_t base_group = 0;
 241     xkb_layout_index_t latched_group = 0;
 242     xkb_layout_index_t locked_group = 0;
 243
 244     assert(state);
 245
 246     caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 247     assert(caps != XKB_MOD_INVALID);
 248     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 249     assert(shift != XKB_MOD_INVALID);
 250     ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
 251     assert(ctrl != XKB_MOD_INVALID);
 252
 253     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 254     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 255     base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
 256     assert(base_mods == 0);
 257     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
 258     assert(latched_mods == 0);
 259     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
 260     assert(locked_mods == (1 << caps));
 261     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 262     assert(effective_mods == locked_mods);
 263
 264     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 265     base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
 266     assert(base_mods == (1 << shift));
 267     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
 268     assert(latched_mods == 0);
 269     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
 270     assert(locked_mods == (1 << caps));
 271     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 272     assert(effective_mods == (base_mods | locked_mods));
 273
 274     base_mods |= (1 << ctrl);
 275     xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
 276                           base_group, latched_group, locked_group);
 277
 278     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_DEPRESSED));
 279     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_EFFECTIVE));
 280
 281     xkb_state_unref(state);
 282 }
 283
 284 static void
 285 test_repeat(struct xkb_keymap *keymap)
 286 {
 287     assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + 8));
 288     assert(xkb_keymap_key_repeats(keymap, KEY_A + 8));
 289     assert(xkb_keymap_key_repeats(keymap, KEY_8 + 8));
 290     assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + 8));
 291     assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
 292 }
 293
 294 static void
 295 test_consume(struct xkb_keymap *keymap)
 296 {
 297     struct xkb_state *state = xkb_state_new(keymap);
 298     xkb_mod_index_t alt, shift;
 299     xkb_mod_mask_t mask;
 300
 301     assert(state);
 302
 303     alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
 304     assert(alt != XKB_MOD_INVALID);
 305     shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 306     assert(shift != XKB_MOD_INVALID);
 307
 308     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 309     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 310     xkb_state_update_key(state, KEY_EQUAL + EVDEV_OFFSET, XKB_KEY_DOWN);
 311
 312     fprintf(stderr, "dumping state for Alt-Shift-+\n");
 313     print_state(state);
 314
 315     mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 316     assert(mask == ((1 << alt) | (1 << shift)));
 317     mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
 318                                               mask);
 319     assert(mask == (1 << alt));
 320
 321     xkb_state_unref(state);
 322 }
 323
 324 int
 325 main(void)
 326 {
 327     struct xkb_context *context = test_get_context();
 328     struct xkb_keymap *keymap;
 329
 330     assert(context);
 331
 332     keymap = test_compile_rules(context, "evdev", "pc104", "us,ru", NULL, "grp:menu_toggle");
 333     assert(keymap);
 334
 335     test_update_key(keymap);
 336     test_serialisation(keymap);
 337     test_repeat(keymap);
 338     test_consume(keymap);
 339
 340     xkb_keymap_unref(keymap);
 341     xkb_context_unref(context);
 342 }