X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=test%2Fstate.c;h=89dfa7e585ea334191bff737c71c379cb2165c3d;hb=49690d936bf6cc6bf85058c1f0a545f0d5e37c77;hp=950b4234f956014f016c5d94cc701b1bd60c6878;hpb=4fb7b06b0f91bd720603f9fdab458695c6cd8932;p=platform%2Fupstream%2Flibxkbcommon.git

diff --git a/test/state.c b/test/state.c
index 950b423..89dfa7e 100644
--- a/test/state.c
+++ b/test/state.c
@@ -23,11 +23,13 @@
  * 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
@@ -297,29 +299,106 @@ test_serialisation(struct xkb_keymap *keymap)
 }
 
 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);
@@ -333,9 +412,90 @@ test_consume(struct xkb_keymap *keymap)
                                               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);
 }
 
@@ -354,7 +514,7 @@ test_range(struct xkb_keymap *keymap)
     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);
@@ -378,52 +538,173 @@ test_caps_keysym_transformation(struct xkb_keymap *keymap)
     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);
+}
+
+static void
+test_get_utf8_utf32(struct xkb_keymap *keymap)
+{
+    char buf[256];
+    struct xkb_state *state = xkb_state_new(keymap);
+    assert(state);
+
+#define TEST_KEY(key, expected_utf8, expected_utf32) do { \
+    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 + EVDEV_OFFSET) == expected_utf32); \
+} while (0)
+
+    /* Simple ASCII. */
+    TEST_KEY(KEY_A, "a", 0x61);
+    TEST_KEY(KEY_ESC, "\x1B", 0x1B);
+    TEST_KEY(KEY_1, "1", 0x31);
+
+    /* Invalid. */
+    TEST_KEY(XKB_KEYCODE_INVALID - 8, "", 0);
+    TEST_KEY(300, "", 0);
+
+    /* No string. */
+    TEST_KEY(KEY_LEFTCTRL, "", 0);
+    TEST_KEY(KEY_NUMLOCK, "", 0);
+
+    /* Multiple keysyms. */
+    TEST_KEY(KEY_6, "HELLO", 0);
+    TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
+
+    /* Check truncation. */
+    memset(buf, 'X', sizeof(buf));
+    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 + EVDEV_OFFSET, buf, 1) == strlen("HELLO"));
+    assert(memcmp(buf, "", 1) == 0);
+    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 + EVDEV_OFFSET, buf, 3) == strlen("HELLO"));
+    assert(memcmp(buf, "HE", 3) == 0);
+    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 + EVDEV_OFFSET, buf, 6) == strlen("HELLO"));
+    assert(memcmp(buf, "HELLO", 6) == 0);
+    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 + EVDEV_OFFSET) == 1);
+
+    /* Non ASCII. */
+    TEST_KEY(KEY_ESC, "\x1B", 0x1B);
+    TEST_KEY(KEY_A, "ф", 0x0444);
+    TEST_KEY(KEY_Z, "я", 0x044F);
+
+    /* 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 + EVDEV_OFFSET) == 0);
+
+    xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
+    TEST_KEY(KEY_A, "A", 0x41);
+    TEST_KEY(KEY_ESC, "\x1B", 0x1B);
+    TEST_KEY(KEY_1, "!", 0x21);
+    xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
+
+    TEST_KEY(KEY_6, "HELLO", 0);
+    TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
+
+    xkb_state_unref(state);
+}
+
+static void
+test_ctrl_string_transformation(struct xkb_keymap *keymap)
+{
+    char buf[256];
+    struct xkb_state *state = xkb_state_new(keymap);
+    xkb_mod_index_t ctrl;
+
+    assert(state);
+
+    /* See xkb_state_key_get_utf8() for what's this all about. */
+
+    ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
+    assert(ctrl != XKB_MOD_INVALID);
+
+    /* First without. */
+    TEST_KEY(KEY_A, "a", 0x61);
+    TEST_KEY(KEY_B, "b", 0x62);
+    TEST_KEY(KEY_C, "c", 0x63);
+    TEST_KEY(KEY_ESC, "\x1B", 0x1B);
+    TEST_KEY(KEY_1, "1", 0x31);
+
+    /* And with. */
+    xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
+    assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
+    TEST_KEY(KEY_A, "\x01", 0x01);
+    TEST_KEY(KEY_B, "\x02", 0x02);
+    TEST_KEY(KEY_C, "\x03", 0x03);
+    TEST_KEY(KEY_ESC, "\x1B", 0x1B);
+    TEST_KEY(KEY_1, "1", 0x31);
+    xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
+
+    /* 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 + EVDEV_OFFSET) == 1);
+
+    /* Non ASCII. */
+    xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
+    assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
+    TEST_KEY(KEY_A, "\x01", 0x01);
+    TEST_KEY(KEY_B, "\x02", 0x02);
+    xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
 
     xkb_state_unref(state);
 }
@@ -446,9 +727,12 @@ main(void)
 
     test_update_key(keymap);
     test_serialisation(keymap);
+    test_update_mask_mods(keymap);
     test_repeat(keymap);
     test_consume(keymap);
     test_range(keymap);
+    test_get_utf8_utf32(keymap);
+    test_ctrl_string_transformation(keymap);
 
     xkb_keymap_unref(keymap);
     keymap = test_compile_rules(context, "evdev", NULL, "ch", "fr", NULL);