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 "xkbcommon/xkbcommon.h"
  32 #include "test.h"
  33
  34 /* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
  35  * keycode set (where ESC is 9). */
  36 #define EVDEV_OFFSET 8
  37
  38 static void
  39 print_state(struct xkb_state *state)
  40 {
  41     struct xkb_keymap *keymap;
  42     xkb_group_index_t group;
  43     xkb_mod_index_t mod;
  44     xkb_led_index_t led;
  45
  46     group = xkb_state_serialize_group(state, XKB_STATE_EFFECTIVE);
  47     mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
  48     /* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
  49     if (!group && !mod /* && !led */) {
  50         fprintf(stderr, "\tno state\n");
  51         return;
  52     }
  53
  54     keymap = xkb_state_get_map(state);
  55
  56     for (group = 0; group < xkb_map_num_groups(keymap); group++) {
  57         if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE))
  58             continue;
  59         fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
  60                 xkb_map_group_get_name(keymap, group),
  61                 group,
  62                 xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) ?
  63                     "effective " : "",
  64                 xkb_state_group_index_is_active(state, group, XKB_STATE_DEPRESSED) ?
  65                     "depressed " : "",
  66                 xkb_state_group_index_is_active(state, group, XKB_STATE_LATCHED) ?
  67                     "latched " : "",
  68                 xkb_state_group_index_is_active(state, group, XKB_STATE_LOCKED) ?
  69                     "locked " : "");
  70     }
  71
  72     for (mod = 0; mod < xkb_map_num_mods(keymap); mod++) {
  73         if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
  74             continue;
  75         fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
  76                 xkb_map_mod_get_name(keymap, mod),
  77                 mod,
  78                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) ?
  79                     "depressed " : "",
  80                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LATCHED) ?
  81                     "latched " : "",
  82                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LOCKED) ?
  83                     "locked " : "");
  84     }
  85
  86     for (led = 0; led < xkb_map_num_leds(keymap); led++) {
  87         if (!xkb_state_led_index_is_active(state, led))
  88             continue;
  89         fprintf(stderr, "\tled %s (%d): active\n",
  90                 xkb_map_led_get_name(keymap, led),
  91                 led);
  92     }
  93 }
  94
  95 static void
  96 test_update_key(struct xkb_keymap *keymap)
  97 {
  98     struct xkb_state *state = xkb_state_new(keymap);
  99     const xkb_keysym_t *syms;
 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));
 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));
 117     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 118                                         XKB_STATE_DEPRESSED));
 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));
 124     assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 125                                            XKB_STATE_MATCH_ALL,
 126                                            XKB_MOD_NAME_ALT,
 127                                            NULL));
 128     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 129                                           (XKB_STATE_MATCH_ANY |
 130                                            XKB_STATE_MATCH_NON_EXCLUSIVE),
 131                                           XKB_MOD_NAME_ALT,
 132                                           NULL));
 133
 134     /* RAlt down */
 135     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 136     fprintf(stderr, "dumping state for RAlt down:\n");
 137     print_state(state);
 138     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 139                                          XKB_STATE_EFFECTIVE));
 140     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 141                                         XKB_STATE_DEPRESSED));
 142     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 143                                           XKB_STATE_MATCH_ANY,
 144                                           XKB_MOD_NAME_CTRL,
 145                                           XKB_MOD_NAME_ALT,
 146                                           NULL));
 147
 148     /* none down */
 149     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
 150     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 151                                          XKB_STATE_EFFECTIVE));
 152
 153     /* Caps locked */
 154     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 155     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 156     fprintf(stderr, "dumping state for Caps Lock:\n");
 157     print_state(state);
 158     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 159                                         XKB_STATE_LOCKED));
 160     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS));
 161     num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 162     assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
 163
 164     /* Caps unlocked */
 165     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 166     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 167     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 168                                          XKB_STATE_EFFECTIVE));
 169     assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS));
 170     num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 171     assert(num_syms == 1 && syms[0] == XKB_KEY_q);
 172
 173     xkb_state_unref(state);
 174 }
 175
 176 static void
 177 test_serialisation(struct xkb_keymap *keymap)
 178 {
 179     struct xkb_state *state = xkb_state_new(keymap);
 180     xkb_mod_mask_t base_mods;
 181     xkb_mod_mask_t latched_mods;
 182     xkb_mod_mask_t locked_mods;
 183     xkb_mod_mask_t effective_mods;
 184     xkb_mod_index_t caps, shift, ctrl;
 185     xkb_group_index_t base_group = 0;
 186     xkb_group_index_t latched_group = 0;
 187     xkb_group_index_t locked_group = 0;
 188
 189     assert(state);
 190
 191     caps = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
 192     assert(caps != XKB_MOD_INVALID);
 193     shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 194     assert(shift != XKB_MOD_INVALID);
 195     ctrl = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
 196     assert(ctrl != XKB_MOD_INVALID);
 197
 198     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 199     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 200     base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
 201     assert(base_mods == 0);
 202     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
 203     assert(latched_mods == 0);
 204     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
 205     assert(locked_mods == (1 << caps));
 206     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 207     assert(effective_mods == locked_mods);
 208
 209     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 210     base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
 211     assert(base_mods == (1 << shift));
 212     latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
 213     assert(latched_mods == 0);
 214     locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
 215     assert(locked_mods == (1 << caps));
 216     effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 217     assert(effective_mods == (base_mods | locked_mods));
 218
 219     base_mods |= (1 << ctrl);
 220     xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
 221                           base_group, latched_group, locked_group);
 222
 223     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_DEPRESSED));
 224     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_EFFECTIVE));
 225
 226     xkb_state_unref(state);
 227 }
 228
 229 static void
 230 test_repeat(struct xkb_keymap *keymap)
 231 {
 232     assert(!xkb_key_repeats(keymap, KEY_LEFTSHIFT + 8));
 233     assert(xkb_key_repeats(keymap, KEY_A + 8));
 234     assert(xkb_key_repeats(keymap, KEY_8 + 8));
 235     assert(xkb_key_repeats(keymap, KEY_DOWN + 8));
 236     assert(xkb_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
 237 }
 238
 239 static void
 240 test_consume(struct xkb_keymap *keymap)
 241 {
 242     struct xkb_state *state = xkb_state_new(keymap);
 243     xkb_mod_index_t alt, shift;
 244     xkb_mod_mask_t mask;
 245
 246     assert(state);
 247
 248     alt = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT);
 249     assert(alt != XKB_MOD_INVALID);
 250     shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
 251     assert(shift != XKB_MOD_INVALID);
 252
 253     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 254     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 255     xkb_state_update_key(state, KEY_EQUAL + EVDEV_OFFSET, XKB_KEY_DOWN);
 256
 257     fprintf(stderr, "dumping state for Alt-Shift-+\n");
 258     print_state(state);
 259
 260     mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
 261     assert(mask == ((1 << alt) | (1 << shift)));
 262     mask = xkb_key_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
 263                                             mask);
 264     assert(mask == (1 << alt));
 265
 266     xkb_state_unref(state);
 267 }
 268
 269 int
 270 main(void)
 271 {
 272     struct xkb_context *context = test_get_context();
 273     struct xkb_keymap *keymap;
 274
 275     assert(context);
 276
 277     keymap = test_compile_rules(context, "evdev", "pc104", "us", NULL, NULL);
 278     assert(keymap);
 279
 280     test_update_key(keymap);
 281     test_serialisation(keymap);
 282     test_repeat(keymap);
 283     test_consume(keymap);
 284
 285     xkb_map_unref(keymap);
 286     xkb_context_unref(context);
 287 }