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 <X11/keysym.h>
  30 #include <linux/input.h>
  31
  32 #include "xkbcommon/xkbcommon.h"
  33 #include "xkbcommon/xkbcommon-names.h"
  34 #include "xkb-priv.h"
  35
  36 /* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
  37  * keycode set (where ESC is 9). */
  38 #define EVDEV_OFFSET 8
  39
  40 static void
  41 print_state(struct xkb_state *state)
  42 {
  43     xkb_group_index_t group;
  44     xkb_mod_index_t mod;
  45     xkb_led_index_t led;
  46
  47     if (!state->group && !state->mods && !state->leds) {
  48         fprintf(stderr, "\tno state\n");
  49         return;
  50     }
  51
  52     for (group = 0; group < xkb_map_num_groups(state->xkb); group++) {
  53         if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE))
  54             continue;
  55         fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
  56                 xkb_map_group_get_name(state->xkb, group),
  57                 group,
  58                 xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) ?
  59                     "effective " : "",
  60                 xkb_state_group_index_is_active(state, group, XKB_STATE_DEPRESSED) ?
  61                     "depressed " : "",
  62                 xkb_state_group_index_is_active(state, group, XKB_STATE_LATCHED) ?
  63                     "latched " : "",
  64                 xkb_state_group_index_is_active(state, group, XKB_STATE_LOCKED) ?
  65                     "locked " : "");
  66     }
  67
  68     for (mod = 0; mod < xkb_map_num_mods(state->xkb); mod++) {
  69         if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
  70             continue;
  71         fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
  72                 xkb_map_mod_get_name(state->xkb, mod),
  73                 mod,
  74                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) ?
  75                     "depressed " : "",
  76                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LATCHED) ?
  77                     "latched " : "",
  78                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_LOCKED) ?
  79                     "locked " : "");
  80     }
  81
  82     for (led = 0; led < xkb_map_num_leds(state->xkb); led++) {
  83         if (!xkb_state_led_index_is_active(state, led))
  84             continue;
  85         fprintf(stderr, "\tled %s (%d): active\n",
  86                 xkb_map_led_get_name(state->xkb, led),
  87                 led);
  88     }
  89 }
  90
  91 static void
  92 test_update_key(struct xkb_keymap *xkb)
  93 {
  94     struct xkb_state *state = xkb_state_new(xkb);
  95     const xkb_keysym_t *syms;
  96     int num_syms;
  97
  98     assert(state);
  99
 100     /* LCtrl down */
 101     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
 102     fprintf(stderr, "dumping state for LCtrl down:\n");
 103     print_state(state);
 104     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 105                                         XKB_STATE_DEPRESSED));
 106
 107     /* LCtrl + RAlt down */
 108     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
 109     fprintf(stderr, "dumping state for LCtrl + RAlt down:\n");
 110     print_state(state);
 111     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 112                                         XKB_STATE_DEPRESSED));
 113     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 114                                         XKB_STATE_DEPRESSED));
 115     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 116                                           XKB_STATE_MATCH_ALL,
 117                                           XKB_MOD_NAME_CTRL,
 118                                           XKB_MOD_NAME_ALT,
 119                                           NULL));
 120     assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 121                                            XKB_STATE_MATCH_ALL,
 122                                            XKB_MOD_NAME_ALT,
 123                                            NULL));
 124     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 125                                           (XKB_STATE_MATCH_ANY |
 126                                            XKB_STATE_MATCH_NON_EXCLUSIVE),
 127                                           XKB_MOD_NAME_ALT,
 128                                           NULL));
 129
 130     /* RAlt down */
 131     xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 132     fprintf(stderr, "dumping state for RAlt down:\n");
 133     print_state(state);
 134     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
 135                                          XKB_STATE_EFFECTIVE));
 136     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 137                                         XKB_STATE_DEPRESSED));
 138     assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
 139                                           XKB_STATE_MATCH_ANY,
 140                                           XKB_MOD_NAME_CTRL,
 141                                           XKB_MOD_NAME_ALT,
 142                                           NULL));
 143
 144     /* none down */
 145     xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
 146     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
 147                                          XKB_STATE_EFFECTIVE));
 148
 149     /* Caps locked */
 150     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 151     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 152     fprintf(stderr, "dumping state for Caps Lock:\n");
 153     print_state(state);
 154     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 155                                         XKB_STATE_LOCKED));
 156     assert(xkb_state_led_name_is_active(state, XKB_MOD_NAME_CAPS));
 157     num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 158     assert(num_syms == 1 && syms[0] == XK_Q);
 159
 160     /* Caps unlocked */
 161     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 162     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 163     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
 164                                          XKB_STATE_EFFECTIVE));
 165     assert(!xkb_state_led_name_is_active(state, XKB_MOD_NAME_CAPS));
 166     num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
 167     assert(num_syms == 1 && syms[0] == XK_q);
 168
 169     xkb_state_unref(state);
 170 }
 171
 172 static void
 173 test_serialisation(struct xkb_keymap *xkb)
 174 {
 175     struct xkb_state *state = xkb_state_new(xkb);
 176     xkb_mod_mask_t base_mods;
 177     xkb_mod_mask_t latched_mods;
 178     xkb_mod_mask_t locked_mods;
 179     xkb_mod_mask_t effective_mods;
 180     xkb_mod_index_t caps, shift, ctrl;
 181     xkb_group_index_t base_group = 0;
 182     xkb_group_index_t latched_group = 0;
 183     xkb_group_index_t locked_group = 0;
 184
 185     assert(state);
 186
 187     caps = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CAPS);
 188     assert(caps != XKB_MOD_INVALID);
 189     shift = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_SHIFT);
 190     assert(shift != XKB_MOD_INVALID);
 191     ctrl = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CTRL);
 192     assert(ctrl != XKB_MOD_INVALID);
 193
 194     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
 195     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
 196     base_mods = xkb_state_serialise_mods(state, XKB_STATE_DEPRESSED);
 197     assert(base_mods == 0);
 198     latched_mods = xkb_state_serialise_mods(state, XKB_STATE_LATCHED);
 199     assert(latched_mods == 0);
 200     locked_mods = xkb_state_serialise_mods(state, XKB_STATE_LOCKED);
 201     assert(locked_mods == (1 << caps));
 202     effective_mods = xkb_state_serialise_mods(state, XKB_STATE_EFFECTIVE);
 203     assert(effective_mods == locked_mods);
 204
 205     xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
 206     base_mods = xkb_state_serialise_mods(state, XKB_STATE_DEPRESSED);
 207     assert(base_mods == (1 << shift));
 208     latched_mods = xkb_state_serialise_mods(state, XKB_STATE_LATCHED);
 209     assert(latched_mods == 0);
 210     locked_mods = xkb_state_serialise_mods(state, XKB_STATE_LOCKED);
 211     assert(locked_mods == (1 << caps));
 212     effective_mods = xkb_state_serialise_mods(state, XKB_STATE_EFFECTIVE);
 213     assert(effective_mods == (base_mods | locked_mods));
 214
 215     base_mods |= (1 << ctrl);
 216     xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
 217                           base_group, latched_group, locked_group);
 218
 219     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_DEPRESSED));
 220     assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_EFFECTIVE));
 221
 222     xkb_state_unref(state);
 223 }
 224
 225 int
 226 main(void)
 227 {
 228     struct xkb_context *context;
 229     struct xkb_keymap *xkb;
 230     struct xkb_rule_names rmlvo = {
 231         .rules = "evdev",
 232         .model = "pc104",
 233         .layout = "us",
 234         .variant = NULL,
 235         .options = NULL,
 236     };
 237
 238     context = xkb_context_new(0);
 239     assert(context);
 240
 241     xkb = xkb_map_new_from_names(context, &rmlvo, 0);
 242     assert(xkb);
 243
 244     test_update_key(xkb);
 245     test_serialisation(xkb);
 246
 247     xkb_map_unref(xkb);
 248     xkb_context_unref(context);
 249 }