From 869c6871906526bcef2c835e2072a1a71ad03c33 Mon Sep 17 00:00:00 2001 From: Ran Benita Date: Sat, 19 May 2012 02:35:15 +0300 Subject: [PATCH] rules: add test Add a non-extensive test to check that some basic things (e.g. rule matching, var substitution, indexes and groups) work as expected. Signed-off-by: Ran Benita --- Makefile.am | 13 ++- configure.ac | 3 + test/.gitignore | 1 + test/data/rules/groups | 17 ++++ test/data/rules/index | 28 +++++++ test/data/rules/simple | 21 +++++ test/rules-file.c | 184 +++++++++++++++++++++++++++++++++++++++++ 7 files changed, 265 insertions(+), 2 deletions(-) create mode 100644 test/data/rules/groups create mode 100644 test/data/rules/index create mode 100644 test/data/rules/simple create mode 100644 test/rules-file.c diff --git a/Makefile.am b/Makefile.am index cef9790..bd67aec 100644 --- a/Makefile.am +++ b/Makefile.am @@ -99,6 +99,12 @@ $(top_builddir)/makekeys/makekeys$(EXEEXT): $(top_srcdir)/makekeys/makekeys.c # Tests +# Some tests need to use unexported symbols, so we link them against +# a private copy of libxkbcommon with all symbols exposed. +noinst_LTLIBRARIES = libxkbcommon-priv.la +libxkbcommon_priv_la_LDFLAGS = $(libxkbcommon_la_LDFLAGS) +libxkbcommon_priv_la_SOURCES = $(libxkbcommon_la_SOURCES) + TESTS_ENVIRONMENT = TESTS = \ @@ -108,8 +114,9 @@ TESTS = \ test/rulescomp \ test/canonicalise \ test/state \ - test/context -TESTS_LDADD = libxkbcommon.la + test/context \ + test/rules-file +TESTS_LDADD = libxkbcommon-priv.la test_xkey_LDADD = $(TESTS_LDADD) test_filecomp_LDADD = $(TESTS_LDADD) @@ -118,6 +125,8 @@ test_rulescomp_LDADD = $(TESTS_LDADD) -lrt test_canonicalise_LDADD = $(TESTS_LDADD) test_state_LDADD = $(TESTS_LDADD) test_context_LDADD = $(TESTS_LDADD) +test_rules_file_CFLAGS = $(AM_CFLAGS) -Wno-declaration-after-statement +test_rules_file_LDADD = $(TESTS_LDADD) check_PROGRAMS = $(TESTS) diff --git a/configure.ac b/configure.ac index d2bd3c2..1d427d5 100644 --- a/configure.ac +++ b/configure.ac @@ -45,6 +45,9 @@ XORG_MACROS_VERSION(1.8) XORG_DEFAULT_OPTIONS XORG_CHECK_MALLOC_ZERO +# Check for compiler features +AC_C_INLINE + # Check for programs AC_PROG_LEX AC_PROG_YACC diff --git a/test/.gitignore b/test/.gitignore index 6fd9a35..6ad9405 100644 --- a/test/.gitignore +++ b/test/.gitignore @@ -7,3 +7,4 @@ rulescomp xkey state context +rules-file diff --git a/test/data/rules/groups b/test/data/rules/groups new file mode 100644 index 0000000..d9de6ee --- /dev/null +++ b/test/data/rules/groups @@ -0,0 +1,17 @@ +! $model_group = pc101 pc102 pc104 pc105 +! $layout_group = ar br cr us +! $variant_group = + +! model = keycodes + $model_group = something(%m) + * = default_keycodes + +! layout variant = symbols + $layout_group * = my_symbols+%(v) + * * = default_symbols + +! model = types + * = default_types + +! model = compat + * = default_compat diff --git a/test/data/rules/index b/test/data/rules/index new file mode 100644 index 0000000..cc97ad1 --- /dev/null +++ b/test/data/rules/index @@ -0,0 +1,28 @@ +! $layouts = al az br cn us + +! layout option = symbols + $layouts some:opt = +extra + +! layout[1] option = symbols + $layouts some:opt = +extra:1 + +! layout[2] option = symbols + $layouts some:opt = +extra:2 + +! layout[3] option = symbols + $layouts some:opt = +extra:3 + +! layout[4] option = symbols + $layouts some:opt = +extra:4 + +! model = symbols + * = default_symbols + +! model = keycodes + * = default_keycodes + +! model = types + * = default_types + +! model = compat + * = default_compat diff --git a/test/data/rules/simple b/test/data/rules/simple new file mode 100644 index 0000000..16fc495 --- /dev/null +++ b/test/data/rules/simple @@ -0,0 +1,21 @@ +! model = keycodes + my_model = my_keycodes + * = default_keycodes + +! layout variant = symbols + my_layout my_variant = my_symbols+extra_variant + +! layout = symbols + my_layout = my_symbols + * = default_symbols + +! model = types + my_model = my_types + * = default_types + +! model = compat + my_model = my_compat + * = default_compat + +! option = compat + my_option = +some:compat diff --git a/test/rules-file.c b/test/rules-file.c new file mode 100644 index 0000000..90981a2 --- /dev/null +++ b/test/rules-file.c @@ -0,0 +1,184 @@ +/* + * Copyright © 2012 Ran Benita + * + * 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. + */ + +#include +#include +#include +#include + +#include "xkbcommon/xkbcommon.h" +#include "rules.h" + +struct test_data { + /* Rules file */ + const char *rules; + + /* Input */ + const char *model; + const char *layout; + const char *variant; + const char *options; + + /* Expected output */ + const char *keymap; + const char *keycodes; + const char *types; + const char *compat; + const char *symbols; + + /* Or set this if xkb_components_from_rules() should fail. */ + bool should_fail; +}; + +static inline bool +streq(const char *s1, const char *s2) +{ + if (s1 == NULL || s2 == NULL) + return s1 == s2; + return strcmp(s1, s2) == 0; +} + +static bool +test_rules(struct xkb_context *ctx, struct test_data *data) +{ + bool passed; + const struct xkb_rule_names rmlvo = { + data->rules, data->model, data->layout, data->variant, data->options + }; + struct xkb_component_names *kccgst; + + fprintf(stderr, "\n\nChecking : %s\t%s\t%s\t%s\t%s\n", data->rules, + data->model, data->layout, data->variant, data->options); + + if (data->should_fail) + fprintf(stderr, "Expecting: NULL\n"); + else + fprintf(stderr, "Expecting: %s\t%s\t%s\t%s\t%s\n", data->keymap, + data->keycodes, data->types, data->compat, data->symbols); + + kccgst = xkb_components_from_rules(ctx, &rmlvo); + if (!kccgst) { + fprintf(stderr, "Received: NULL\n"); + return data->should_fail; + } + + fprintf(stderr, "Received : %s\t%s\t%s\t%s\t%s\n", kccgst->keymap, + kccgst->keycodes, kccgst->types, kccgst->compat, kccgst->symbols); + + passed = streq(kccgst->keymap, data->keymap) && + streq(kccgst->keycodes, data->keycodes) && + streq(kccgst->types, data->types) && + streq(kccgst->compat, data->compat) && + streq(kccgst->symbols, data->symbols); + + free(kccgst->keymap); + free(kccgst->keycodes); + free(kccgst->types); + free(kccgst->compat); + free(kccgst->symbols); + free(kccgst); + + return passed; +} + +int +main(void) +{ + struct xkb_context *ctx; + const char *srcdir = getenv("srcdir"); + char *path; + + ctx = xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES); + assert(ctx); + + assert(asprintf(&path, "%s/test/data", srcdir ? srcdir : ".") > 0); + assert(xkb_context_include_path_append(ctx, path)); + free(path); + + struct test_data test1 = { + .rules = "simple", + + .model = "my_model", .layout = "my_layout", .variant = "my_variant", + .options = "my_option", + + .keycodes = "my_keycodes", .types = "my_types", + .compat = "my_compat+some:compat", + .symbols = "my_symbols+extra_variant", + }; + assert(test_rules(ctx, &test1)); + + struct test_data test2 = { + .rules = "simple", + + .model = "", .layout = "", .variant = "", .options = "", + + .keycodes = "default_keycodes", .types = "default_types", + .compat = "default_compat", .symbols = "default_symbols", + }; + assert(test_rules(ctx, &test2)); + + struct test_data test3 = { + .rules = "groups", + + .model = "pc104", .layout = "foo", .variant = "", .options = "", + + .keycodes = "something(pc104)", .types = "default_types", + .compat = "default_compat", .symbols = "default_symbols", + }; + assert(test_rules(ctx, &test3)); + + struct test_data test4 = { + .rules = "groups", + + .model = "foo", .layout = "ar", .variant = "bar", .options = "", + + .keycodes = "default_keycodes", .types = "default_types", + .compat = "default_compat", .symbols = "my_symbols+(bar)", + }; + assert(test_rules(ctx, &test4)); + + struct test_data test5 = { + .rules = "simple", + + .model = NULL, .layout = "my_layout,second_layout", .variant = "my_variant", + .options = "my_option", + + .should_fail = true + }; + assert(test_rules(ctx, &test5)); + + struct test_data test6 = { + .rules = "index", + + .model = "", .layout = "br,al,cn,az", .variant = "", + .options = "some:opt", + + .keycodes = "default_keycodes", .types = "default_types", + .compat = "default_compat", + .symbols = "default_symbols+extra:1+extra:2+extra:3+extra:4", + }; + assert(test_rules(ctx, &test6)); + + xkb_context_unref(ctx); + return 0; +}