Interactive tools: Escape control character for Unicode output

[platform/upstream/libxkbcommon.git] / test / common.c

diff --git a/test/common.c b/test/common.c
index 6d6f25e..cb911e8 100644 (file)
--- a/test/common.c
+++ b/test/common.c
@@ -30,13 +30,23 @@
  *         Ran Benita <ran234@gmail.com>
  */
 
+#include "config.h"
+
 #include <limits.h>
 #include <fcntl.h>
-#include <unistd.h>
+#include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <termios.h>
+#endif
 
 #include "test.h"
+#include "utils.h"
 
 /*
  * Test a sequence of keysyms, resulting from a sequence of key presses,
@@ -64,6 +74,7 @@ test_key_seq_va(struct xkb_keymap *keymap, va_list ap)
     xkb_keysym_t keysym;
 
     const xkb_keysym_t *syms;
+    xkb_keysym_t sym;
     unsigned int nsyms, i;
     char ksbuf[64];
 
@@ -77,7 +88,12 @@ test_key_seq_va(struct xkb_keymap *keymap, va_list ap)
         op = va_arg(ap, int);
 
         nsyms = xkb_state_key_get_syms(state, kc, &syms);
-        fprintf(stderr, "got %d syms for key 0x%x: [", nsyms, kc);
+        if (nsyms == 1) {
+            sym = xkb_state_key_get_one_sym(state, kc);
+            syms = &sym;
+        }
+
+        fprintf(stderr, "got %u syms for keycode %u: [", nsyms, kc);
 
         if (op == DOWN || op == BOTH)
             xkb_state_update_key(state, kc, XKB_KEY_DOWN);
@@ -104,6 +120,15 @@ test_key_seq_va(struct xkb_keymap *keymap, va_list ap)
             }
         }
 
+        if (nsyms == 0) {
+            keysym = va_arg(ap, int);
+            if (keysym != XKB_KEY_NoSymbol) {
+                xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
+                fprintf(stderr, "Expected %s, but got no keysyms.\n", ksbuf);
+                goto fail;
+            }
+        }
+
         fprintf(stderr, "]\n");
 
         keysym = va_arg(ap, int);
@@ -138,16 +163,71 @@ test_key_seq(struct xkb_keymap *keymap, ...)
     return ret;
 }
 
-const char *
+char *
+test_makedir(const char *parent, const char *path)
+{
+    char *dirname;
+    int err;
+
+    dirname = asprintf_safe("%s/%s", parent, path);
+    assert(dirname);
+#ifdef _WIN32
+    err = _mkdir(dirname);
+#else
+    err = mkdir(dirname, 0777);
+#endif
+    assert(err == 0);
+
+    return dirname;
+}
+
+char *
+test_maketempdir(const char *template)
+{
+#ifdef _WIN32
+    const char *basetmp = getenv("TMP");
+    if (basetmp == NULL) {
+        basetmp = getenv("TEMP");
+    }
+    if (basetmp == NULL) {
+        basetmp = getenv("top_builddir");
+    }
+    assert(basetmp != NULL);
+    char *tmpdir = asprintf_safe("%s/%s", basetmp, template);
+    assert(tmpdir != NULL);
+    char *tmp = _mktemp(tmpdir);
+    assert(tmp == tmpdir);
+    int ret = _mkdir(tmp);
+    assert(ret == 0);
+    return tmpdir;
+#else
+    char *tmpdir = asprintf_safe("/tmp/%s", template);
+    assert(tmpdir != NULL);
+    char *tmp = mkdtemp(tmpdir);
+    assert(tmp == tmpdir);
+    return tmpdir;
+#endif
+}
+
+char *
 test_get_path(const char *path_rel)
 {
-    static char path[PATH_MAX];
-    const char *srcdir = getenv("srcdir");
+    char *path;
+    const char *srcdir;
 
-    snprintf(path, PATH_MAX - 1,
-             "%s/test/data/%s", srcdir ? srcdir : ".",
-             path_rel ? path_rel : "");
+    srcdir = getenv("top_srcdir");
+    if (!srcdir)
+        srcdir = ".";
 
+    if (path_rel[0] == '/')
+        return strdup(path_rel);
+
+    path = asprintf_safe("%s/test/data%s%s", srcdir,
+                         path_rel[0] ? "/" : "", path_rel);
+    if (!path) {
+        fprintf(stderr, "Failed to allocate path for %s\n", path_rel);
+        return NULL;
+    }
     return path;
 }
 
@@ -155,10 +235,15 @@ char *
 test_read_file(const char *path_rel)
 {
     struct stat info;
-    char *ret, *tmp;
+    char *ret, *tmp, *path;
     int fd, count, remaining;
 
-    fd = open(test_get_path(path_rel), O_RDONLY);
+    path = test_get_path(path_rel);
+    if (!path)
+        return NULL;
+
+    fd = open(path, O_RDONLY);
+    free(path);
     if (fd < 0)
         return NULL;
 
@@ -195,6 +280,7 @@ test_get_context(enum test_context_flags test_flags)
 {
     enum xkb_context_flags ctx_flags;
     struct xkb_context *ctx;
+    char *path;
 
     ctx_flags = XKB_CONTEXT_NO_DEFAULT_INCLUDES;
     if (test_flags & CONTEXT_ALLOW_ENVIRONMENT_NAMES) {
@@ -212,7 +298,14 @@ test_get_context(enum test_context_flags test_flags)
     if (!ctx)
         return NULL;
 
-    xkb_context_include_path_append(ctx, test_get_path(""));
+    path = test_get_path("");
+    if (!path) {
+        xkb_context_unref(ctx);
+        return NULL;
+    }
+
+    xkb_context_include_path_append(ctx, path);
+    free(path);
 
     return ctx;
 }
@@ -222,11 +315,16 @@ test_compile_file(struct xkb_context *context, const char *path_rel)
 {
     struct xkb_keymap *keymap;
     FILE *file;
-    const char *path = test_get_path(path_rel);
+    char *path;
 
-    file = fopen(path, "r");
+    path = test_get_path(path_rel);
+    if (!path)
+        return NULL;
+
+    file = fopen(path, "rb");
     if (!file) {
         fprintf(stderr, "Failed to open path: %s\n", path);
+        free(path);
         return NULL;
     }
     assert(file != NULL);
@@ -237,10 +335,12 @@ test_compile_file(struct xkb_context *context, const char *path_rel)
 
     if (!keymap) {
         fprintf(stderr, "Failed to compile path: %s\n", path);
+        free(path);
         return NULL;
     }
 
     fprintf(stderr, "Successfully compiled path: %s\n", path);
+    free(path);
 
     return keymap;
 }
@@ -261,6 +361,21 @@ 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 *keymap;
+
+    keymap = xkb_keymap_new_from_buffer(context, buf, len,
+                                        XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+    if (!keymap) {
+        fprintf(stderr, "Failed to compile keymap from memory buffer\n");
+        return NULL;
+    }
+
+    return keymap;
+}
+
+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)