* Author: Daniel Stone <daniel@fooishbar.org>
*/
+#include "config.h"
+
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
-#include <linux/input.h>
+#include "evdev-scancodes.h"
#include "test.h"
/* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
}
static void
+test_update_mask_mods(struct xkb_keymap *keymap)
+{
+ struct xkb_state *state = xkb_state_new(keymap);
+ xkb_mod_index_t caps, shift, num, alt, mod1, mod2;
+ enum xkb_state_component changed;
+
+ assert(state);
+
+ caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+ assert(caps != XKB_MOD_INVALID);
+ shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+ assert(shift != XKB_MOD_INVALID);
+ num = xkb_keymap_mod_get_index(keymap, "NumLock");
+ assert(num != XKB_MOD_INVALID);
+ alt = xkb_keymap_mod_get_index(keymap, "Alt");
+ assert(alt != XKB_MOD_INVALID);
+ mod1 = xkb_keymap_mod_get_index(keymap, "Mod1");
+ assert(mod1 != XKB_MOD_INVALID);
+ mod2 = xkb_keymap_mod_get_index(keymap, "Mod2");
+ assert(mod2 != XKB_MOD_INVALID);
+
+ changed = xkb_state_update_mask(state, 1 << caps, 0, 0, 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_EFFECTIVE));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
+ (1u << caps));
+
+ changed = xkb_state_update_mask(state, (1 << caps), 0, (1 << shift), 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_LOCKED | XKB_STATE_MODS_EFFECTIVE |
+ XKB_STATE_LEDS));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
+ ((1u << caps) | (1u << shift)));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED) ==
+ (1u << caps));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED) == 0);
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED) ==
+ (1u << shift));
+
+ changed = xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
+ XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) == 0);
+
+ changed = xkb_state_update_mask(state, (1 << alt), 0, 0, 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_EFFECTIVE));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
+ ((1u << alt) | (1u << mod1)));
+
+ changed = xkb_state_update_mask(state, 0, 0, (1 << num), 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
+ XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
+ ((1u << num) | (1u << mod2)));
+
+ xkb_state_update_mask(state, 0, 0, 0, 0, 0, 0);
+
+ changed = xkb_state_update_mask(state, (1 << mod2), 0, (1 << num), 0, 0, 0);
+ assert(changed == (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LOCKED |
+ XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LEDS));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE) ==
+ ((1u << mod2) | (1u << num)));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED) ==
+ (1u << mod2));
+ assert(xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED) ==
+ ((1u << num) | (1u << mod2)));
+
+ xkb_state_unref(state);
+}
+
+static void
test_repeat(struct xkb_keymap *keymap)
{
- assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + 8));
- assert(xkb_keymap_key_repeats(keymap, KEY_A + 8));
- assert(xkb_keymap_key_repeats(keymap, KEY_8 + 8));
- assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + 8));
- assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
+ assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + EVDEV_OFFSET));
+ assert(xkb_keymap_key_repeats(keymap, KEY_A + EVDEV_OFFSET));
+ assert(xkb_keymap_key_repeats(keymap, KEY_8 + EVDEV_OFFSET));
+ assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + EVDEV_OFFSET));
+ assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + EVDEV_OFFSET));
}
static void
test_consume(struct xkb_keymap *keymap)
{
- struct xkb_state *state = xkb_state_new(keymap);
- xkb_mod_index_t alt, shift;
+ struct xkb_state *state;
+ xkb_mod_index_t alt, shift, caps, ctrl, mod5;
xkb_mod_mask_t mask;
+ state = xkb_state_new(keymap);
assert(state);
alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
assert(alt != XKB_MOD_INVALID);
shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
+ caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+ assert(caps != XKB_MOD_INVALID);
+ ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
+ assert(ctrl != XKB_MOD_INVALID);
+ mod5 = xkb_keymap_mod_get_index(keymap, "Mod5");
+ assert(mod5 != XKB_MOD_INVALID);
+ /* Test remove_consumed() */
xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_EQUAL + EVDEV_OFFSET, XKB_KEY_DOWN);
mask);
assert(mask == (1U << alt));
+ /* Test get_consumed_mods() */
mask = xkb_state_key_get_consumed_mods(state, KEY_EQUAL + EVDEV_OFFSET);
assert(mask == (1U << shift));
+ mask = xkb_state_key_get_consumed_mods(state, KEY_ESC + EVDEV_OFFSET);
+ assert(mask == 0);
+
+ xkb_state_unref(state);
+
+ /* Test is_consumed() - simple ALPHABETIC type. */
+ state = xkb_state_new(keymap);
+ assert(state);
+
+ mask = xkb_state_key_get_consumed_mods(state, KEY_A + EVDEV_OFFSET);
+ assert(mask == ((1U << shift) | (1U << caps)));
+
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
+ assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
+
+ xkb_state_unref(state);
+
+ /* More complicated - CTRL+ALT */
+ state = xkb_state_new(keymap);
+ assert(state);
+
+ mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
+ assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
+
+ /* Shift is preserved. */
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
+ mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
+ assert(mask == ((1U << alt) | (1U << ctrl) | (1U << mod5)));
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
+
+ mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
+ assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
+
+ xkb_state_unref(state);
+
+ /* Test XKB_CONSUMED_MODE_GTK, CTRL+ALT */
+ state = xkb_state_new(keymap);
+ assert(state);
+
+ mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
+ XKB_CONSUMED_MODE_GTK);
+ assert(mask == 0);
+
+ xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
+ mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
+ XKB_CONSUMED_MODE_GTK);
+ assert(mask == 0);
+
+ xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
+ mask = xkb_state_key_get_consumed_mods2(state, KEY_F1 + EVDEV_OFFSET,
+ XKB_CONSUMED_MODE_GTK);
+ assert(mask == ((1U << alt) | (1U << ctrl)));
+
+ xkb_state_unref(state);
+
+ /* Test XKB_CONSUMED_MODE_GTK, Simple Shift */
+ state = xkb_state_new(keymap);
+ assert(state);
+
+ mask = xkb_state_key_get_consumed_mods2(state, KEY_A + EVDEV_OFFSET,
+ XKB_CONSUMED_MODE_GTK);
+ assert(mask == ((1U << shift) | (1U << caps)));
+
+ xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
+ mask = xkb_state_key_get_consumed_mods2(state, KEY_A + EVDEV_OFFSET,
+ XKB_CONSUMED_MODE_GTK);
+ assert(mask == ((1U << shift) | (1U << caps)));
+
xkb_state_unref(state);
}
xkb_keycode_t counter;
assert(xkb_keymap_min_keycode(keymap) == 9);
- assert(xkb_keymap_max_keycode(keymap) == 253);
+ assert(xkb_keymap_max_keycode(keymap) == 569);
counter = xkb_keymap_min_keycode(keymap);
xkb_keymap_key_for_each(keymap, key_iter, &counter);
shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(caps != XKB_MOD_INVALID && shift != XKB_MOD_INVALID);
- assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
- assert(xkb_state_key_get_layout(state, KEY_SEMICOLON + 8) == 0);
+ assert(xkb_state_key_get_layout(state, KEY_A + EVDEV_OFFSET) == 0);
+ assert(xkb_state_key_get_layout(state, KEY_SEMICOLON + EVDEV_OFFSET) == 0);
/* Without caps, no transformation. */
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
- assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 0);
- sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(xkb_state_key_get_level(state, KEY_A + EVDEV_OFFSET, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + EVDEV_OFFSET);
assert(sym == XKB_KEY_a);
- assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
- sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ assert(xkb_state_key_get_level(state, KEY_SEMICOLON + EVDEV_OFFSET, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + EVDEV_OFFSET);
assert(sym == XKB_KEY_eacute);
- nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + EVDEV_OFFSET, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
/* With shift, no transformation (only different level). */
- xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) > 0);
- assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
- sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(xkb_state_key_get_level(state, KEY_A + EVDEV_OFFSET, 0) == 1);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + EVDEV_OFFSET);
assert(sym == XKB_KEY_A);
- sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + EVDEV_OFFSET);
assert(sym == XKB_KEY_odiaeresis);
- nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + EVDEV_OFFSET, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_odiaeresis);
- xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
/* With caps, transform in same level, only with _get_one_sym(). */
- xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
- xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
- assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
- sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(xkb_state_key_get_level(state, KEY_A + EVDEV_OFFSET, 0) == 1);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + EVDEV_OFFSET);
assert(sym == XKB_KEY_A);
- assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
- sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ assert(xkb_state_key_get_level(state, KEY_SEMICOLON + EVDEV_OFFSET, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + EVDEV_OFFSET);
assert(sym == XKB_KEY_Eacute);
- nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + EVDEV_OFFSET, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
- xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
- xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
- xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
xkb_state_unref(state);
}
assert(state);
#define TEST_KEY(key, expected_utf8, expected_utf32) do { \
- assert(xkb_state_key_get_utf8(state, key + 8, NULL, 0) == strlen(expected_utf8)); \
- assert(xkb_state_key_get_utf8(state, key + 8, buf, sizeof(buf)) == strlen(expected_utf8)); \
+ assert(xkb_state_key_get_utf8(state, key + EVDEV_OFFSET, NULL, 0) == strlen(expected_utf8)); \
+ assert(xkb_state_key_get_utf8(state, key + EVDEV_OFFSET, buf, sizeof(buf)) == strlen(expected_utf8)); \
assert(memcmp(buf, expected_utf8, sizeof(expected_utf8)) == 0); \
- assert(xkb_state_key_get_utf32(state, key + 8) == expected_utf32); \
+ assert(xkb_state_key_get_utf32(state, key + EVDEV_OFFSET) == expected_utf32); \
} while (0)
/* Simple ASCII. */
/* Check truncation. */
memset(buf, 'X', sizeof(buf));
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 0) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 0) == strlen("HELLO"));
assert(memcmp(buf, "X", 1) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 1) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 1) == strlen("HELLO"));
assert(memcmp(buf, "", 1) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 2) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 2) == strlen("HELLO"));
assert(memcmp(buf, "H", 2) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 3) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 3) == strlen("HELLO"));
assert(memcmp(buf, "HE", 3) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 5) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 5) == strlen("HELLO"));
assert(memcmp(buf, "HELL", 5) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 6) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 6) == strlen("HELLO"));
assert(memcmp(buf, "HELLO", 6) == 0);
- assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 7) == strlen("HELLO"));
+ assert(xkb_state_key_get_utf8(state, KEY_6 + EVDEV_OFFSET, buf, 7) == strlen("HELLO"));
assert(memcmp(buf, "HELLO\0X", 7) == 0);
/* Switch to ru layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
- assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
+ assert(xkb_state_key_get_layout(state, KEY_A + EVDEV_OFFSET) == 1);
/* Non ASCII. */
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
/* Switch back to us layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
- assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
+ assert(xkb_state_key_get_layout(state, KEY_A + EVDEV_OFFSET) == 0);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
TEST_KEY(KEY_A, "A", 0x41);
/* Switch to ru layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
- assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
+ assert(xkb_state_key_get_layout(state, KEY_A + EVDEV_OFFSET) == 1);
/* Non ASCII. */
xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
test_update_key(keymap);
test_serialisation(keymap);
+ test_update_mask_mods(keymap);
test_repeat(keymap);
test_consume(keymap);
test_range(keymap);
projects / platform / upstream / libxkbcommon.git / blobdiff