test/common.c

   1 /*
   2  * Copyright 2009 Dan Nicholson
   3  * Copyright © 2012 Daniel Stone
   4  * Copyright © 2012 Ran Benita
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Except as contained in this notice, the names of the authors or their
  24  * institutions shall not be used in advertising or otherwise to promote the
  25  * sale, use or other dealings in this Software without prior written
  26  * authorization from the authors.
  27  */
  28
  29 #include <assert.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <limits.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38
  39 #include "xkbcommon/xkbcommon.h"
  40 #include "test.h"
  41
  42 const char *
  43 test_get_path(const char *path_rel)
  44 {
  45     static char path[PATH_MAX];
  46     const char *srcdir = getenv("srcdir");
  47
  48     snprintf(path, PATH_MAX - 1,
  49              "%s/test/data/%s", srcdir ? srcdir : ".",
  50              path_rel ? path_rel : "");
  51
  52     return path;
  53 }
  54
  55 char *
  56 test_read_file(const char *path_rel)
  57 {
  58     struct stat info;
  59     char *ret, *tmp;
  60     int fd, count, remaining;
  61
  62     fd = open(test_get_path(path_rel), O_RDONLY);
  63     if (fd < 0)
  64         return NULL;
  65
  66     if (fstat(fd, &info) != 0) {
  67         close(fd);
  68         return NULL;
  69     }
  70
  71     ret = malloc(info.st_size + 1);
  72     if (!ret) {
  73         close(fd);
  74         return NULL;
  75     }
  76
  77     remaining = info.st_size;
  78     tmp = ret;
  79     while ((count = read(fd, tmp, remaining))) {
  80         remaining -= count;
  81         tmp += count;
  82     }
  83     ret[info.st_size] = '\0';
  84     close(fd);
  85
  86     if (remaining != 0) {
  87         free(ret);
  88         return NULL;
  89     }
  90
  91     return ret;
  92 }
  93
  94 struct xkb_context *
  95 test_get_context(void)
  96 {
  97     struct xkb_context *ctx = xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES);
  98
  99     if (!ctx)
 100         return NULL;
 101
 102     xkb_context_include_path_append(ctx, test_get_path(""));
 103
 104     return ctx;
 105 }
 106
 107 struct xkb_keymap *
 108 test_compile_file(struct xkb_context *context, const char *path_rel)
 109 {
 110     struct xkb_keymap *keymap;
 111     FILE *file;
 112     const char *path = test_get_path(path_rel);
 113
 114     file = fopen(path, "r");
 115     if (!file) {
 116         fprintf(stderr, "Failed to open path: %s\n", path);
 117         return NULL;
 118     }
 119     assert(file != NULL);
 120
 121     keymap = xkb_map_new_from_file(context, file,
 122                                    XKB_KEYMAP_FORMAT_TEXT_V1, 0);
 123     fclose(file);
 124
 125     if (!keymap) {
 126         fprintf(stderr, "Failed to compile path: %s\n", path);
 127         return NULL;
 128     }
 129
 130     fprintf(stderr, "Successfully compiled path: %s\n", path);
 131
 132     return keymap;
 133 }
 134
 135 struct xkb_keymap *
 136 test_compile_string(struct xkb_context *context, const char *string)
 137 {
 138     struct xkb_keymap *keymap;
 139
 140     keymap = xkb_map_new_from_string(context, string,
 141                                      XKB_KEYMAP_FORMAT_TEXT_V1, 0);
 142     if (!keymap) {
 143         fprintf(stderr, "Failed to compile string\n");
 144         return NULL;
 145     }
 146
 147     return keymap;
 148 }
 149
 150 struct xkb_keymap *
 151 test_compile_rules(struct xkb_context *context, const char *rules,
 152                    const char *model, const char *layout,
 153                    const char *variant, const char *options)
 154 {
 155     struct xkb_keymap *keymap;
 156     struct xkb_rule_names rmlvo = {
 157         .rules = rules,
 158         .model = model,
 159         .layout = layout,
 160         .variant = variant,
 161         .options = options
 162     };
 163
 164     keymap = xkb_map_new_from_names(context, &rmlvo, 0);
 165     if (!keymap) {
 166         fprintf(stderr,
 167                 "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
 168                 rules, model, layout, variant, options);
 169         return NULL;
 170     }
 171
 172     return keymap;
 173 }