kc3-lang/libxkbcommon/test/keymap.c

Branch : - branch - android master - tag -

• Show log

  Commit

• Author : Pierre Le Marre
  Date : 2024-09-30 06:13:38
  Hash : 7c4c718b
  Message : Allow only the first group in symbols sections when using RMLVO Currently `xkb_keymap_num_layouts` may return a greater number than the number of layouts configured using RMLVO, because we allow symbols sections to define various groups per key. This is unintuitive and kind of buggy: groups should be added via rules by setting an explicit `:n` modifier. Fix: when parsing a keymap using RMLVO resolution: - Get the expected layouts count from the resulting KcCGST. - Drop the groups after the first one in included symbols sections. This will ensure that a symbol section can only define one group per key. Notes: - Compiling a keymap string directly is unaffected. - RMLVO resolution may still produce more groups than the input layouts. Indeed, some legacy rules in xkeyboard-config rely on this to insert automatically a US layout before the given non-Latin one, resulting in two layouts while only one was given.

• test/keymap.c

• /*
   * Copyright © 2016 Intel Corporation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice (including the next
   * paragraph) shall be included in all copies or substantial portions of the
   * Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   * DEALINGS IN THE SOFTWARE.
   *
   * Author: Mike Blumenkrantz <zmike@osg.samsung.com>
   */
  
  #include "config.h"
  
  #include <assert.h>
  #include <stdio.h>
  #include <stdlib.h>
  
  #include "test.h"
  #include "keymap.h"
  
  static void
  test_garbage_key(void)
  {
      struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
      struct xkb_keymap *keymap;
      xkb_keycode_t kc;
      int nsyms;
      const xkb_keysym_t *syms;
      const xkb_layout_index_t first_layout = 0;
      xkb_level_index_t nlevels;
  
      assert(context);
  
      keymap = test_compile_rules(context, NULL, NULL, "garbage", NULL, NULL);
      assert(keymap);
  
      /* TLDE uses the 'us' sym on the first level and is thus [grave, exclam] */
      kc = xkb_keymap_key_by_name(keymap, "TLDE");
      assert(kc != XKB_KEYCODE_INVALID);
      nlevels = xkb_keymap_num_levels_for_key(keymap, kc, first_layout);
      assert(nlevels == 2);
      nsyms = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &syms);
      assert(nsyms == 1);
      assert(*syms == XKB_KEY_grave); /* fallback from 'us' */
      nsyms = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 1, &syms);
      assert(nsyms == 1);
      assert(*syms == XKB_KEY_exclam);
  
      /* AE13 has no 'us' fallback and ends up as [NoSymbol, asciitilde] */
      kc = xkb_keymap_key_by_name(keymap, "AE13");
      assert(kc != XKB_KEYCODE_INVALID);
      nlevels = xkb_keymap_num_levels_for_key(keymap, kc, first_layout);
      assert(nlevels == 2);
      nsyms = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &syms);
      assert(nsyms == 0);
      nsyms = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 1, &syms);
      assert(nsyms == 1);
      assert(*syms == XKB_KEY_asciitilde);
  
      xkb_keymap_unref(keymap);
      xkb_context_unref(context);
  }
  
  static void
  test_keymap(void)
  {
      struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
      struct xkb_keymap *keymap;
      xkb_keycode_t kc;
      const char *keyname;
      xkb_mod_mask_t masks_out[4] = { 0, 0, 0, 0 };
      size_t mask_count;
      xkb_mod_mask_t shift_mask;
      xkb_mod_mask_t lock_mask;
      xkb_mod_mask_t mod2_mask;
  
      assert(context);
  
      keymap = test_compile_rules(context, "evdev", "pc104", "us,ru", NULL, "grp:menu_toggle");
      assert(keymap);
  
      kc = xkb_keymap_key_by_name(keymap, "AE09");
      assert(kc != XKB_KEYCODE_INVALID);
      keyname = xkb_keymap_key_get_name(keymap, kc);
      assert(streq(keyname, "AE09"));
  
      kc = xkb_keymap_key_by_name(keymap, "COMP");
      assert(kc != XKB_KEYCODE_INVALID);
      keyname = xkb_keymap_key_get_name(keymap, kc);
      assert(streq(keyname, "COMP"));
  
      kc = xkb_keymap_key_by_name(keymap, "MENU");
      assert(kc != XKB_KEYCODE_INVALID);
      keyname = xkb_keymap_key_get_name(keymap, kc);
      assert(streq(keyname, "COMP"));
  
      kc = xkb_keymap_key_by_name(keymap, "AC01");
      assert(kc != XKB_KEYCODE_INVALID);
  
      // AC01 level 0 ('a') requires no modifiers on us-pc104
      mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 0, masks_out, 4);
      assert(mask_count == 1);
      assert(masks_out[0] == 0);
  
      shift_mask = 1 << xkb_keymap_mod_get_index(keymap, "Shift");
      lock_mask = 1 << xkb_keymap_mod_get_index(keymap, "Lock");
      mod2_mask = 1 << xkb_keymap_mod_get_index(keymap, "Mod2");
  
      // AC01 level 1 ('A') requires either Shift or Lock modifiers on us-pc104
      mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 1, masks_out, 4);
      assert(mask_count == 2);
      assert(masks_out[0] == shift_mask);
      assert(masks_out[1] == lock_mask);
  
      kc = xkb_keymap_key_by_name(keymap, "KP1");
  
      // KP1 level 0 ('End') requires no modifiers or Shift+Mod2 on us-pc104
      mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 0, masks_out, 4);
      assert(mask_count == 2);
      assert(masks_out[0] == 0);
      assert(masks_out[1] == (shift_mask | mod2_mask));
  
      // KP1 level 1 ('1') requires either Shift or Mod2 modifiers on us-pc104
      mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 1, masks_out, 4);
      assert(mask_count == 2);
      assert(masks_out[0] == shift_mask);
      assert(masks_out[1] == mod2_mask);
  
      // Return key is not affected by modifiers on us-pc104
      kc = xkb_keymap_key_by_name(keymap, "RTRN");
      mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 0, masks_out, 4);
      assert(mask_count == 1);
      assert(masks_out[0] == 0);
  
      xkb_keymap_unref(keymap);
      xkb_context_unref(context);
  }
  
  static void
  test_no_extra_groups(void)
  {
      struct xkb_keymap *keymap;
      xkb_keycode_t kc;
      const xkb_keysym_t *syms;
      struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
      assert(context);
  
      /* RMLVO: Legacy rules may add more layouts than the input RMLVO */
      keymap = test_compile_rules(context, "multiple-groups",
                                  "old", "de", NULL, NULL);
      assert(keymap);
      kc = xkb_keymap_key_by_name(keymap, "AD01");
      assert(kc != XKB_KEYCODE_INVALID);
      /* 2 layouts, while only 1 was provided */
      assert(xkb_keymap_num_layouts_for_key(keymap, kc) == 2);
      assert(xkb_keymap_num_layouts(keymap) == 2);
      xkb_keymap_unref(keymap);
  
      /* RMLVO: “one group per key” in symbols sections */
      const char *layouts[] = {"us", "us,us", "us,us,us", "us,us,us,us"};
      for (xkb_layout_index_t k = 0; k < ARRAY_SIZE(layouts); k++) {
          /* `multiple-groups` option defines 4 groups for a key */
          keymap = test_compile_rules(context, "multiple-groups", NULL,
                                      layouts[k], NULL, "multiple-groups");
          assert(keymap);
          kc = xkb_keymap_key_by_name(keymap, "RALT");
          assert(kc != XKB_KEYCODE_INVALID);
          /* Groups after the first one should be dropped */
          assert(xkb_keymap_num_layouts_for_key(keymap, kc) == 1);
          /* Here we expect RMLVO layouts count = keymap layouts count */
          assert(xkb_keymap_num_layouts(keymap) == k + 1);
          for (xkb_layout_index_t l = 0; l <= k; l++) {
              assert(xkb_keymap_key_get_syms_by_level(keymap, kc, l, 0, &syms) == 1);
              assert(syms[0] == XKB_KEY_a);
              syms = NULL;
          }
          xkb_keymap_unref(keymap);
      }
  
      /* RMLVO: Ensure the rule “one group per key” in symbols sections works
       * for the 2nd layout */
      keymap = test_compile_rules(context, NULL, NULL,
                                  "multiple-groups,multiple-groups", "1,2", NULL);
      assert(keymap);
      kc = xkb_keymap_key_by_name(keymap, "RALT");
      assert(kc != XKB_KEYCODE_INVALID);
      assert(xkb_keymap_num_layouts_for_key(keymap, kc) == 2);
      assert(xkb_keymap_num_layouts(keymap) == 2);
      for (xkb_layout_index_t l = 0; l < 2; l++) {
          assert(xkb_keymap_key_get_syms_by_level(keymap, kc, l, 0, &syms) == 1);
          assert(syms[0] == XKB_KEY_a);
          syms = NULL;
      }
      xkb_keymap_unref(keymap);
  
      /* Same configuration as previous, but without using RMLVO resolution:
       * We do accept more than one group per key in symbols sections, but only
       * when not using a modifier: the second layout (`:2`) will have its extra
       * groups dropped. */
      const char keymap_str[] =
          "xkb_keymap {"
          "  xkb_keycodes { include \"evdev+aliases(qwerty)\" };"
          "  xkb_types { include \"complete\" };"
          "  xkb_compat { include \"complete\" };"
          "  xkb_symbols { include \"pc+multiple-groups(1)+multiple-groups(2):2"
                                    "+inet(evdev)\" };"
          "};";
      keymap = test_compile_string(context, keymap_str);
      kc = xkb_keymap_key_by_name(keymap, "RALT");
      assert(kc != XKB_KEYCODE_INVALID);
      assert(xkb_keymap_num_layouts_for_key(keymap, kc) == 4);
      assert(xkb_keymap_num_layouts(keymap) == 4);
      xkb_keysym_t ref_syms[] = { XKB_KEY_a, XKB_KEY_a, XKB_KEY_c, XKB_KEY_d };
      for (xkb_layout_index_t l = 0; l < 4; l++) {
          assert(xkb_keymap_key_get_syms_by_level(keymap, kc, l, 0, &syms) == 1);
          assert(syms[0] == ref_syms[l]);
          syms = NULL;
      }
      xkb_keymap_unref(keymap);
  
      xkb_context_unref(context);
  }
  
  #define Mod1Mask (1 << 3)
  #define Mod2Mask (1 << 4)
  #define Mod3Mask (1 << 5)
  
  static void
  test_numeric_keysyms(void)
  {
      struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
      struct xkb_keymap *keymap;
      const struct xkb_key *key;
      xkb_keycode_t kc;
      int keysyms_count;
      const xkb_layout_index_t first_layout = 0;
      const xkb_keysym_t *keysyms;
  
      assert(context);
  
      keymap = test_compile_rules(context, "evdev", "pc104", "numeric_keysyms", NULL, NULL);
      assert(keymap);
  
      kc = xkb_keymap_key_by_name(keymap, "AD01");
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &keysyms);
      assert(keysyms_count == 1);
      assert(keysyms[0] == 0x1ffffffd);
      key = XkbKey(keymap, kc);
      assert(key->modmap == Mod1Mask);
  
      kc = xkb_keymap_key_by_name(keymap, "AD02");
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &keysyms);
      assert(keysyms_count == 1);
      assert(keysyms[0] == 0x1ffffffe);
      key = XkbKey(keymap, kc);
      assert(key->modmap == Mod2Mask);
  
      kc = xkb_keymap_key_by_name(keymap, "AD03");
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &keysyms);
      assert(keysyms_count == 1);
      assert(keysyms[0] == 0x1fffffff);
      /* Invalid numeric keysym */
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 1, &keysyms);
      assert(keysyms_count == 0);
      key = XkbKey(keymap, kc);
      assert(key->modmap == Mod3Mask);
  
      xkb_keymap_unref(keymap);
      xkb_context_unref(context);
  }
  
  static void
  test_multiple_keysyms_per_level(void)
  {
      struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
      struct xkb_keymap *keymap;
      xkb_keycode_t kc;
      int keysyms_count;
      const xkb_layout_index_t first_layout = 0;
      const xkb_keysym_t *keysyms;
  
      assert(context);
  
      keymap = test_compile_rules(context, "evdev", "pc104", "awesome", NULL, NULL);
      assert(keymap);
  
      kc = xkb_keymap_key_by_name(keymap, "AD01");
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 0, &keysyms);
      assert(keysyms_count == 3);
      assert(keysyms[0] == 'q');
      assert(keysyms[1] == 'a');
      assert(keysyms[2] == 'b');
  
      kc = xkb_keymap_key_by_name(keymap, "AD03");
      keysyms_count = xkb_keymap_key_get_syms_by_level(keymap, kc, first_layout, 1, &keysyms);
      assert(keysyms_count == 2);
      assert(keysyms[0] == 'E');
      assert(keysyms[1] == 'F');
  
      xkb_keymap_unref(keymap);
      xkb_context_unref(context);
  }
  
  int
  main(void)
  {
      test_init();
  
      test_garbage_key();
      test_keymap();
      test_no_extra_groups();
      test_numeric_keysyms();
      test_multiple_keysyms_per_level();
  
      return 0;
  }