test: untangle interactive-evdev from the test headers

Move (sometimes duplicate) the required bits into new shared files
tools-common.(c|h) that are compiled into the internal tools library. Rename the
test_foo() functions to tools_foo() and in one case just copy the code of the
keymap compile function to the tool.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

meson.build

@@ -445,11 +445,13 @@ executable('fuzz-compose', 'fuzz/compose/target.c', dependencies: test_dep)
 # Demo programs.
 libxkbcommon_tools_internal = static_library(
     'tools-internal',
+    'tools/tools-common.h',
+    'tools/tools-common.c',
     libxkbcommon_sources,
     include_directories: include_directories('src'),
 )
 tools_dep = declare_dependency(
-    include_directories: include_directories('src'),
+    include_directories: [include_directories('src'), include_directories('tools')],
     link_with: libxkbcommon_tools_internal,
 )
 
@@ -460,7 +462,7 @@ if cc.has_header_symbol('getopt.h', 'getopt_long', prefix: '#define _GNU_SOURCE'
     executable('how-to-type', 'tools/how-to-type.c', dependencies: tools_dep)
 endif
 if cc.has_header('linux/input.h')
-    executable('interactive-evdev', 'test/interactive-evdev.c', dependencies: test_dep)
+    executable('interactive-evdev', 'test/interactive-evdev.c', dependencies: tools_dep)
 endif
 if get_option('enable-x11')
     executable('interactive-x11', 'test/interactive-x11.c', dependencies: x11_test_dep)

test/common.c

@@ -441,34 +441,6 @@ test_print_keycode_state(struct xkb_state *state,
     printf("\n");
 }
 
-void
-test_print_state_changes(enum xkb_state_component changed)
-{
-    if (changed == 0)
-        return;
-
-    printf("changed [ ");
-    if (changed & XKB_STATE_LAYOUT_EFFECTIVE)
-        printf("effective-layout ");
-    if (changed & XKB_STATE_LAYOUT_DEPRESSED)
-        printf("depressed-layout ");
-    if (changed & XKB_STATE_LAYOUT_LATCHED)
-        printf("latched-layout ");
-    if (changed & XKB_STATE_LAYOUT_LOCKED)
-        printf("locked-layout ");
-    if (changed & XKB_STATE_MODS_EFFECTIVE)
-        printf("effective-mods ");
-    if (changed & XKB_STATE_MODS_DEPRESSED)
-        printf("depressed-mods ");
-    if (changed & XKB_STATE_MODS_LATCHED)
-        printf("latched-mods ");
-    if (changed & XKB_STATE_MODS_LOCKED)
-        printf("locked-mods ");
-    if (changed & XKB_STATE_LEDS)
-        printf("leds ");
-    printf("]\n");
-}
-
 #ifdef _MSC_VER
 void
 test_disable_stdin_echo(void)

test/interactive-evdev.c

@@ -23,6 +23,7 @@
 
 #include "config.h"
 
+#include <assert.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -30,13 +31,18 @@
 #include <limits.h>
 #include <locale.h>
 #include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <sys/epoll.h>
 #include <linux/input.h>
 
-#include "test.h"
+#include "xkbcommon/xkbcommon.h"
+
+#include "tools-common.h"
 
 struct keyboard {
     char *path;
@@ -264,8 +270,8 @@ process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
     }
 
     if (value != KEY_STATE_RELEASE)
-        test_print_keycode_state(kbd->state, kbd->compose_state, keycode,
+        tools_print_keycode_state(kbd->state, kbd->compose_state, keycode,
-                                 consumed_mode);
+                                  consumed_mode);
 
     if (with_compose) {
         status = xkb_compose_state_get_status(kbd->compose_state);
@@ -279,7 +285,7 @@ process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
         changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
 
     if (report_state_changes)
-        test_print_state_changes(changed);
+        tools_print_state_changes(changed);
 }
 
 static int
@@ -433,7 +439,7 @@ main(int argc, char *argv[])
         }
     }
 
-    ctx = test_get_context(0);
+    ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
     if (!ctx) {
         fprintf(stderr, "Couldn't create xkb context\n");
         goto out;
@@ -452,8 +458,25 @@ main(int argc, char *argv[])
         fclose(file);
     }
     else {
-        keymap = test_compile_rules(ctx, rules, model, layout, variant,
+        struct xkb_rule_names rmlvo = {
-                                    options);
+            .rules = isempty(rules) ? NULL : rules,
+            .model = isempty(model) ? NULL : model,
+            .layout = isempty(layout) ? NULL : layout,
+            .variant = isempty(variant) ? NULL : variant,
+            .options = isempty(options) ? NULL : options
+        };
+
+        if (!rules && !model && !layout && !variant && !options)
+            keymap = xkb_keymap_new_from_names(ctx, NULL, 0);
+        else
+            keymap = xkb_keymap_new_from_names(ctx, &rmlvo, 0);
+
+        if (!keymap) {
+            fprintf(stderr,
+                    "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
+                    rules, model, layout, variant, options);
+            goto out;
+        }
     }
 
     if (!keymap) {
@@ -483,9 +506,9 @@ main(int argc, char *argv[])
     sigaction(SIGINT, &act, NULL);
     sigaction(SIGTERM, &act, NULL);
 
-    test_disable_stdin_echo();
+    tools_disable_stdin_echo();
     ret = loop(kbds);
-    test_enable_stdin_echo();
+    tools_enable_stdin_echo();
 
     free_keyboards(kbds);
 out:

test/test.h

@@ -87,8 +87,6 @@ test_print_keycode_state(struct xkb_state *state,
                          xkb_keycode_t keycode,
                          enum xkb_consumed_mode consumed_mode);
 
-void
-test_print_state_changes(enum xkb_state_component changed);
 
 void
 test_disable_stdin_echo(void);

tools/tools-common.c

@@ -46,9 +46,120 @@
 
 #include "tools-common.h"
 
+void
+tools_print_keycode_state(struct xkb_state *state,
+                          struct xkb_compose_state *compose_state,
+                          xkb_keycode_t keycode,
+                          enum xkb_consumed_mode consumed_mode)
+{
+    struct xkb_keymap *keymap;
+
+    xkb_keysym_t sym;
+    const xkb_keysym_t *syms;
+    int nsyms;
+    char s[16];
+    xkb_layout_index_t layout;
+    enum xkb_compose_status status;
+
+    keymap = xkb_state_get_keymap(state);
+
+    nsyms = xkb_state_key_get_syms(state, keycode, &syms);
+
+    if (nsyms <= 0)
+        return;
+
+    status = XKB_COMPOSE_NOTHING;
+    if (compose_state)
+        status = xkb_compose_state_get_status(compose_state);
+
+    if (status == XKB_COMPOSE_COMPOSING || status == XKB_COMPOSE_CANCELLED)
+        return;
+
+    if (status == XKB_COMPOSE_COMPOSED) {
+        sym = xkb_compose_state_get_one_sym(compose_state);
+        syms = &sym;
+        nsyms = 1;
+    }
+    else if (nsyms == 1) {
+        sym = xkb_state_key_get_one_sym(state, keycode);
+        syms = &sym;
+    }
+
+    printf("keysyms [ ");
+    for (int i = 0; i < nsyms; i++) {
+        xkb_keysym_get_name(syms[i], s, sizeof(s));
+        printf("%-*s ", (int) sizeof(s), s);
+    }
+    printf("] ");
+
+    if (status == XKB_COMPOSE_COMPOSED)
+        xkb_compose_state_get_utf8(compose_state, s, sizeof(s));
+    else
+        xkb_state_key_get_utf8(state, keycode, s, sizeof(s));
+    printf("unicode [ %s ] ", s);
+
+    layout = xkb_state_key_get_layout(state, keycode);
+    printf("layout [ %s (%d) ] ",
+           xkb_keymap_layout_get_name(keymap, layout), layout);
+
+    printf("level [ %d ] ",
+           xkb_state_key_get_level(state, keycode, layout));
+
+    printf("mods [ ");
+    for (xkb_mod_index_t mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
+        if (xkb_state_mod_index_is_active(state, mod,
+                                          XKB_STATE_MODS_EFFECTIVE) <= 0)
+            continue;
+        if (xkb_state_mod_index_is_consumed2(state, keycode, mod,
+                                             consumed_mode))
+            printf("-%s ", xkb_keymap_mod_get_name(keymap, mod));
+        else
+            printf("%s ", xkb_keymap_mod_get_name(keymap, mod));
+    }
+    printf("] ");
+
+    printf("leds [ ");
+    for (xkb_led_index_t led = 0; led < xkb_keymap_num_leds(keymap); led++) {
+        if (xkb_state_led_index_is_active(state, led) <= 0)
+            continue;
+        printf("%s ", xkb_keymap_led_get_name(keymap, led));
+    }
+    printf("] ");
+
+    printf("\n");
+}
+
+void
+tools_print_state_changes(enum xkb_state_component changed)
+{
+    if (changed == 0)
+        return;
+
+    printf("changed [ ");
+    if (changed & XKB_STATE_LAYOUT_EFFECTIVE)
+        printf("effective-layout ");
+    if (changed & XKB_STATE_LAYOUT_DEPRESSED)
+        printf("depressed-layout ");
+    if (changed & XKB_STATE_LAYOUT_LATCHED)
+        printf("latched-layout ");
+    if (changed & XKB_STATE_LAYOUT_LOCKED)
+        printf("locked-layout ");
+    if (changed & XKB_STATE_MODS_EFFECTIVE)
+        printf("effective-mods ");
+    if (changed & XKB_STATE_MODS_DEPRESSED)
+        printf("depressed-mods ");
+    if (changed & XKB_STATE_MODS_LATCHED)
+        printf("latched-mods ");
+    if (changed & XKB_STATE_MODS_LOCKED)
+        printf("locked-mods ");
+    if (changed & XKB_STATE_LEDS)
+        printf("leds ");
+    printf("]\n");
+}
+
 #ifdef _MSC_VER
 void
-test_disable_stdin_echo(void)
+tools_disable_stdin_echo(void)
 {
     HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
     DWORD mode = 0;
@@ -57,7 +168,7 @@ test_disable_stdin_echo(void)
 }
 
 void
-test_enable_stdin_echo(void)
+tools_enable_stdin_echo(void)
 {
     HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
     DWORD mode = 0;
@@ -66,7 +177,7 @@ test_enable_stdin_echo(void)
 }
 #else
 void
-test_disable_stdin_echo(void)
+tools_disable_stdin_echo(void)
 {
     /* Same as `stty -echo`. */
     struct termios termios;
@@ -77,7 +188,7 @@ test_disable_stdin_echo(void)
 }
 
 void
-test_enable_stdin_echo(void)
+tools_enable_stdin_echo(void)
 {
     /* Same as `stty echo`. */
     struct termios termios;

tools/tools-common.h

@@ -23,6 +23,10 @@
  * Author: Daniel Stone <daniel@fooishbar.org>
  */
 
+#pragma once
+
+#include "config.h"
+
 #include <assert.h>
 
 /* Don't use compat names in internal code. */
@@ -31,67 +35,20 @@
 #include "xkbcommon/xkbcommon-compose.h"
 #include "utils.h"
 
-/* The offset between KEY_* numbering, and keycodes in the XKB evdev
+void
- * dataset. */
+tools_print_keycode_state(struct xkb_state *state,
-#define EVDEV_OFFSET 8
+                          struct xkb_compose_state *compose_state,
-
+                          xkb_keycode_t keycode,
-enum key_seq_state {
+                          enum xkb_consumed_mode consumed_mode);
-    DOWN,
-    REPEAT,
-    UP,
-    BOTH,
-    NEXT,
-    FINISH,
-};
-
-int
-test_key_seq(struct xkb_keymap *keymap, ...);
-
-int
-test_key_seq_va(struct xkb_keymap *keymap, va_list args);
-
-char *
-test_get_path(const char *path_rel);
-
-char *
-test_read_file(const char *path_rel);
-
-enum test_context_flags {
-    CONTEXT_NO_FLAG = 0,
-    CONTEXT_ALLOW_ENVIRONMENT_NAMES = (1 << 0),
-};
-
-struct xkb_context *
-test_get_context(enum test_context_flags flags);
-
-struct xkb_keymap *
-test_compile_file(struct xkb_context *context, const char *path_rel);
-
-struct xkb_keymap *
-test_compile_string(struct xkb_context *context, const char *string);
-
-struct xkb_keymap *
-test_compile_buffer(struct xkb_context *context, const char *buf, size_t len);
-
-struct xkb_keymap *
-test_compile_rules(struct xkb_context *context, const char *rules,
-                   const char *model, const char *layout, const char *variant,
-                   const char *options);
 
 void
-test_print_keycode_state(struct xkb_state *state,
+tools_print_state_changes(enum xkb_state_component changed);
-                         struct xkb_compose_state *compose_state,
-                         xkb_keycode_t keycode,
-                         enum xkb_consumed_mode consumed_mode);
 
 void
-test_print_state_changes(enum xkb_state_component changed);
+tools_disable_stdin_echo(void);
 
 void
-test_disable_stdin_echo(void);
+tools_enable_stdin_echo(void);
-
-void
-test_enable_stdin_echo(void);
 
 #ifdef _MSC_VER
 #define setenv(varname, value, overwrite) _putenv_s((varname), (value))