kc3-lang/libxkbcommon/test/registry.c

• Show log

  Commit

• Hash : 41a7c975
  Author :
  Date : 2020-07-10T14:57:57
  

  Add asprintf_safe helper function We only ever care about whether we error out or not, so let's wrap this into something more sane. Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

Download

• test/registry.c

• /*
   * Copyright © 2020 Red Hat, Inc.
   *
   * 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 "config.h"
  
  #include <assert.h>
  #include <stdarg.h>
  #include <stdio.h>
  #include <sys/stat.h>
  #include <sys/types.h>
  
  #include "xkbcommon/xkbregistry.h"
  
  #include "utils.h"
  
  #define NO_VARIANT NULL
  
  enum {
      MODEL = 78,
      LAYOUT,
      VARIANT,
      OPTION,
  };
  
  struct test_model {
      const char *name; /* required */
      const char *vendor;
      const char *description;
  };
  
  struct test_layout {
      const char *name; /* required */
      const char *variant;
      const char *brief;
      const char *description;
  };
  
  struct test_option {
      const char *name;
      const char *description;
  };
  
  struct test_option_group {
      const char *name;
      const char *description;
      bool allow_multiple_selection;
  
      struct test_option options[10];
  };
  
  static void
  fprint_config_item(FILE *fp,
                     const char *name,
                     const char *vendor,
                     const char *brief,
                     const char *description)
  {
      fprintf(fp, "  <configItem>\n"
                  "    <name>%s</name>\n", name);
      if (brief)
          fprintf(fp, "    <shortDescription>%s</shortDescription>\n", brief);
      if (description)
          fprintf(fp, "    <description>%s</description>\n", description);
      if (vendor)
          fprintf(fp, "    <vendor>%s</vendor>\n", vendor);
      fprintf(fp, "  </configItem>\n");
  }
  
  /**
   * Create a directory populated with a rules/<ruleset>.xml that contains the
   * given items.
   *
   * @return the XKB base directory
   */
  static char *
  test_create_rules(const char *ruleset,
                    const struct test_model *test_models,
                    const struct test_layout *test_layouts,
                    const struct test_option_group *test_groups)
  {
      static int iteration;
      char *tmpdir;
      char buf[PATH_MAX];
      int rc;
      FILE *fp;
  
      tmpdir = asprintf_safe("/tmp/%s.%d.XXXXXX", ruleset, iteration++);
      assert(tmpdir);
      assert(mkdtemp(tmpdir) == tmpdir);
  
      rc = snprintf_safe(buf, sizeof(buf), "%s/rules", tmpdir);
      assert(rc);
      rc = mkdir(buf, 0777);
      assert(rc == 0);
      rc = snprintf_safe(buf, sizeof(buf), "%s/rules/%s.xml", tmpdir, ruleset);
      assert(rc);
  
      fp = fopen(buf, "w");
      assert(fp);
  
      fprintf(fp,
              "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
              "<!DOCTYPE xkbConfigRegistry SYSTEM \"xkb.dtd\">\n"
              "<xkbConfigRegistry version=\"1.1\">\n");
  
      if (test_models) {
          fprintf(fp, "<modelList>\n");
  
          for (const struct test_model *m = test_models; m->name; m++) {
              fprintf(fp, "<model>\n");
              fprint_config_item(fp, m->name, m->vendor, NULL, m->description);
              fprintf(fp, "</model>\n");
          }
          fprintf(fp, "</modelList>\n");
      }
  
      if (test_layouts) {
          const struct test_layout *l, *next;
  
          fprintf(fp, "<layoutList>\n");
  
          l = test_layouts;
          next = l + 1;
  
          assert(l->variant == NULL);
  
          while (l->name) {
              fprintf(fp, "<layout>\n");
              fprint_config_item(fp, l->name, NULL, l->brief, l->description);
  
              if (next->name && streq(next->name, l->name)) {
                  fprintf(fp, "<variantList>\n");
                  do {
                      fprintf(fp, "<variant>\n");
                      fprint_config_item(fp, next->variant, NULL, next->brief,
                                         next->description);
                      fprintf(fp, "</variant>\n");
                      l = next;
                      next++;
                  } while (next->name && streq(next->name, l->name));
                  fprintf(fp, "</variantList>\n");
              }
              fprintf(fp, "</layout>\n");
              l++;
          }
          fprintf(fp, "</layoutList>\n");
      }
  
      if (test_groups) {
          fprintf(fp, "<optionList>\n");
  
          for (const struct test_option_group *g = test_groups; g->name; g++) {
              fprintf(fp, "<group allowMultipleSelection=\"%s\">\n",
                      g->allow_multiple_selection ? "true" : "false");
              fprint_config_item(fp, g->name, NULL, NULL, g->description);
              for (const struct test_option *o = g->options; o->name; o++) {
                  fprintf(fp, "  <option>\n");
                  fprint_config_item(fp, o->name, NULL, NULL, o->description);
                  fprintf(fp, "</option>\n");
              }
              fprintf(fp, "</group>\n");
          }
          fprintf(fp, "</optionList>\n");
      }
  
      fprintf(fp, "</xkbConfigRegistry>\n");
      fclose(fp);
  
      return tmpdir;
  }
  
  static void
  test_remove_rules(char *basedir, const char *ruleset)
  {
      char path[PATH_MAX];
      int rc;
  
      rc = snprintf_safe(path, sizeof(path), "%s/rules/%s.xml", basedir,
                         ruleset);
      assert(rc);
      unlink(path);
      rc = snprintf_safe(path, sizeof(path), "%s/xkb/rules", basedir);
      assert(rc);
      rmdir(path);
      rmdir(basedir);
      free(basedir);
  }
  
  static struct rxkb_context *
  test_setup_context_for(const char *ruleset,
                         struct test_model *system_models,
                         struct test_model *user_models,
                         struct test_layout *system_layouts,
                         struct test_layout *user_layouts,
                         struct test_option_group *system_groups,
                         struct test_option_group *user_groups)
  {
      char *sysdir = NULL, *userdir = NULL;
      struct rxkb_context *ctx;
  
      sysdir = test_create_rules(ruleset, system_models, system_layouts,
                                 system_groups);
      if (user_models || user_layouts || user_groups)
          userdir = test_create_rules(ruleset, user_models, user_layouts,
                                      user_groups);
  
      ctx = rxkb_context_new(RXKB_CONTEXT_NO_DEFAULT_INCLUDES);
      assert(ctx);
      if (userdir)
          assert(rxkb_context_include_path_append(ctx, userdir));
      assert(rxkb_context_include_path_append(ctx, sysdir));
      assert(rxkb_context_parse(ctx, ruleset));
  
      test_remove_rules(sysdir, ruleset);
      if (userdir)
          test_remove_rules(userdir, ruleset);
  
      return ctx;
  }
  
  static struct rxkb_context *
  test_setup_context(struct test_model *system_models,
                     struct test_model *user_models,
                     struct test_layout *system_layouts,
                     struct test_layout *user_layouts,
                     struct test_option_group *system_groups,
                     struct test_option_group *user_groups)
  {
      const char *ruleset = "xkbtests";
      return test_setup_context_for(ruleset, system_models,
                                    user_models, system_layouts,
                                    user_layouts, system_groups,
                                    user_groups);
  }
  
  static struct rxkb_model *
  fetch_model(struct rxkb_context *ctx, const char *model)
  {
      struct rxkb_model *m = rxkb_model_first(ctx);
      while (m) {
          if (streq(rxkb_model_get_name(m), model))
              return rxkb_model_ref(m);
          m = rxkb_model_next(m);
      }
      return NULL;
  }
  
  static bool
  find_model(struct rxkb_context *ctx, const char *model)
  {
      struct rxkb_model *m = fetch_model(ctx, model);
      rxkb_model_unref(m);
      return m != NULL;
  }
  
  static bool
  find_models(struct rxkb_context *ctx, ...)
  {
      va_list args;
      const char *name;
      int idx = 0;
  
      va_start(args, ctx);
      name = va_arg(args, const char *);
      while(name) {
          assert(++idx < 20); /* safety guard */
          if (!find_model(ctx, name))
              return false;
          name = va_arg(args, const char *);
      };
  
      va_end(args);
      return true;
  }
  
  static struct rxkb_layout *
  fetch_layout(struct rxkb_context *ctx, const char *layout, const char *variant)
  {
      struct rxkb_layout *l = rxkb_layout_first(ctx);
      while (l) {
          const char *v = rxkb_layout_get_variant(l);
  
          if (streq(rxkb_layout_get_name(l), layout) &&
              ((v == NULL && variant == NULL) ||
               (v != NULL && variant != NULL && streq(v, variant))))
              return rxkb_layout_ref(l);
          l = rxkb_layout_next(l);
      }
      return NULL;
  }
  
  static bool
  find_layout(struct rxkb_context *ctx, const char *layout, const char *variant)
  {
      struct rxkb_layout *l = fetch_layout(ctx, layout, variant);
      rxkb_layout_unref(l);
      return l != NULL;
  }
  
  static bool
  find_layouts(struct rxkb_context *ctx, ...)
  {
      va_list args;
      const char *name, *variant;
      int idx = 0;
  
      va_start(args, ctx);
      name = va_arg(args, const char *);
      variant = va_arg(args, const char *);
      while(name) {
          assert(++idx < 20); /* safety guard */
          if (!find_layout(ctx, name, variant))
              return false;
          name = va_arg(args, const char *);
          if (name)
              variant = va_arg(args, const char *);
      };
  
      va_end(args);
      return true;
  }
  
  static struct rxkb_option_group *
  fetch_option_group(struct rxkb_context *ctx, const char *grp)
  {
      struct rxkb_option_group *g = rxkb_option_group_first(ctx);
      while (g) {
          if (streq(grp, rxkb_option_group_get_name(g)))
              return rxkb_option_group_ref(g);
          g = rxkb_option_group_next(g);
      }
      return NULL;
  }
  
  static inline bool
  find_option_group(struct rxkb_context *ctx, const char *grp)
  {
      struct rxkb_option_group *g = fetch_option_group(ctx, grp);
      rxkb_option_group_unref(g);
      return g != NULL;
  }
  
  static struct rxkb_option *
  fetch_option(struct rxkb_context *ctx, const char *grp, const char *opt)
  {
      struct rxkb_option_group *g = rxkb_option_group_first(ctx);
      while (g) {
          if (streq(grp, rxkb_option_group_get_name(g))) {
              struct rxkb_option *o = rxkb_option_first(g);
  
              while (o) {
                  if (streq(opt, rxkb_option_get_name(o)))
                      return rxkb_option_ref(o);
                  o = rxkb_option_next(o);
              }
          }
          g = rxkb_option_group_next(g);
      }
      return NULL;
  }
  
  static bool
  find_option(struct rxkb_context *ctx, const char *grp, const char *opt)
  {
      struct rxkb_option *o = fetch_option(ctx, grp, opt);
      rxkb_option_unref(o);
      return o != NULL;
  }
  
  static bool
  find_options(struct rxkb_context *ctx, ...)
  {
      va_list args;
      const char *grp, *opt;
      int idx = 0;
  
      va_start(args, ctx);
      grp = va_arg(args, const char *);
      opt = va_arg(args, const char *);
      while(grp) {
          assert(++idx < 20); /* safety guard */
          if (!find_option(ctx, grp, opt))
              return false;
          grp = va_arg(args, const char *);
          if (grp)
              opt = va_arg(args, const char *);
      };
  
      va_end(args);
      return true;
  }
  
  static bool
  cmp_models(struct test_model *tm, struct rxkb_model *m)
  {
      if (!tm || !m)
          return false;
  
      if (!streq(tm->name, rxkb_model_get_name(m)))
          return false;
  
      if (!streq_null(tm->vendor, rxkb_model_get_vendor(m)))
          return false;
  
      if (!streq_null(tm->description, rxkb_model_get_description(m)))
          return false;
  
      return true;
  }
  
  static bool
  cmp_layouts(struct test_layout *tl, struct rxkb_layout *l)
  {
      if (!tl || !l)
          return false;
  
      if (!streq(tl->name, rxkb_layout_get_name(l)))
          return false;
  
      if (!streq_null(tl->variant, rxkb_layout_get_variant(l)))
          return false;
  
      if (!streq_null(tl->brief, rxkb_layout_get_brief(l)))
          return false;
  
      if (!streq_null(tl->description, rxkb_layout_get_description(l)))
          return false;
  
      return true;
  }
  
  static bool
  cmp_options(struct test_option *to, struct rxkb_option *o)
  {
      if (!to || !o)
          return false;
  
      if (!streq(to->name, rxkb_option_get_name(o)))
          return false;
  
      if (!streq_null(to->description, rxkb_option_get_description(o)))
          return false;
  
      return true;
  }
  
  enum cmp_type {
      CMP_EXACT,
      CMP_MATCHING_ONLY,
  };
  
  static bool
  cmp_option_groups(struct test_option_group *tg, struct rxkb_option_group *g,
                    enum cmp_type cmp)
  {
      struct rxkb_option *o;
      struct test_option *to;
  
      if (!tg || !g)
          return false;
  
      if (!streq(tg->name, rxkb_option_group_get_name(g)))
          return false;
  
      if (!streq_null(tg->description, rxkb_option_group_get_description(g)))
          return false;
  
      if (tg->allow_multiple_selection != rxkb_option_group_allows_multiple(g))
          return false;
  
      to = tg->options;
      o = rxkb_option_first(g);
  
      while (o && to->name) {
          if (!cmp_options(to, o))
              return false;
          to++;
          o = rxkb_option_next(o);
      }
  
      if (cmp == CMP_EXACT && (o || to->name))
          return false;
  
      return true;
  }
  
  static void
  test_load_basic(void)
  {
      struct test_model system_models[] =  {
          {"m1"},
          {"m2"},
          {NULL},
      };
      struct test_layout system_layouts[] =  {
          {"l1"},
          {"l1", "v1"},
          {NULL},
      };
      struct test_option_group system_groups[] = {
          {"grp1", NULL, true,
            { {"grp1:1"}, {"grp1:2"} } },
          {"grp2", NULL, false,
            { {"grp2:1"}, {"grp2:2"} } },
          { NULL },
      };
      struct rxkb_context *ctx;
  
      ctx = test_setup_context(system_models, NULL,
                               system_layouts, NULL,
                               system_groups, NULL);
  
      assert(find_models(ctx, "m1", "m2", NULL));
      assert(find_layouts(ctx, "l1", NO_VARIANT,
                               "l1", "v1", NULL));
      assert(find_options(ctx, "grp1", "grp1:1",
                               "grp1", "grp1:2",
                               "grp2", "grp2:1",
                               "grp2", "grp2:2", NULL));
      rxkb_context_unref(ctx);
  }
  
  static void
  test_load_full(void)
  {
      struct test_model system_models[] =  {
          {"m1", "vendor1", "desc1"},
          {"m2", "vendor2", "desc2"},
          {NULL},
      };
      struct test_layout system_layouts[] =  {
          {"l1", NO_VARIANT, "lbrief1", "ldesc1"},
          {"l1", "v1", "vbrief1", "vdesc1"},
          {NULL},
      };
      struct test_option_group system_groups[] = {
          {"grp1", "gdesc1", true,
            { {"grp1:1", "odesc11"}, {"grp1:2", "odesc12"} } },
          {"grp2", "gdesc2", false,
            { {"grp2:1", "odesc21"}, {"grp2:2", "odesc22"} } },
          { NULL },
      };
      struct rxkb_context *ctx;
      struct rxkb_model *m;
      struct rxkb_layout *l;
      struct rxkb_option_group *g;
  
      ctx = test_setup_context(system_models, NULL,
                               system_layouts, NULL,
                               system_groups, NULL);
  
      m = fetch_model(ctx, "m1");
      assert(cmp_models(&system_models[0], m));
      rxkb_model_unref(m);
  
      m = fetch_model(ctx, "m2");
      assert(cmp_models(&system_models[1], m));
      rxkb_model_unref(m);
  
      l = fetch_layout(ctx, "l1", NO_VARIANT);
      assert(cmp_layouts(&system_layouts[0], l));
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l1", "v1");
      assert(cmp_layouts(&system_layouts[1], l));
      rxkb_layout_unref(l);
  
      g = fetch_option_group(ctx, "grp1");
      assert(cmp_option_groups(&system_groups[0], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      g = fetch_option_group(ctx, "grp2");
      assert(cmp_option_groups(&system_groups[1], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      rxkb_context_unref(ctx);
  }
  
  static void
  test_popularity(void)
  {
      struct test_layout system_layouts[] =  {
          {"l1", NO_VARIANT },
          {"l1", "v1" },
          {NULL},
      };
      struct rxkb_context *ctx;
      struct rxkb_layout *l;
      const char *ruleset = "xkbtests.extras";
      char *dir = NULL;
  
      dir = test_create_rules(ruleset, NULL, system_layouts, NULL);
      ctx = rxkb_context_new(RXKB_CONTEXT_NO_DEFAULT_INCLUDES |
                             RXKB_CONTEXT_LOAD_EXOTIC_RULES);
      assert(ctx);
      assert(rxkb_context_include_path_append(ctx, dir));
      /* Hack: rulest above generates xkbtests.extras.xml, loading "xkbtests"
       * means the extras file counts as exotic */
      assert(rxkb_context_parse(ctx, "xkbtests"));
  
      l = fetch_layout(ctx, "l1", NO_VARIANT);
      assert(rxkb_layout_get_popularity(l) == RXKB_POPULARITY_EXOTIC);
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l1", "v1");
      assert(rxkb_layout_get_popularity(l) == RXKB_POPULARITY_EXOTIC);
      rxkb_layout_unref(l);
  
      test_remove_rules(dir, ruleset);
      rxkb_context_unref(ctx);
  }
  
  
  static void
  test_load_merge(void)
  {
      struct test_model system_models[] =  {
          {"m1", "vendor1", "desc1"},
          {"m2", "vendor2", "desc2"},
          {NULL},
      };
      struct test_model user_models[] =  {
          {"m3", "vendor3", "desc3"},
          {"m4", "vendor4", "desc4"},
          {NULL},
      };
      struct test_layout system_layouts[] =  {
          {"l1", NO_VARIANT, "lbrief1", "ldesc1"},
          {"l1", "v1", "vbrief1", "vdesc1"},
          {NULL},
      };
      struct test_layout user_layouts[] =  {
          {"l2", NO_VARIANT, "lbrief2", "ldesc2"},
          {"l2", "v2", "vbrief2", "vdesc2"},
          {NULL},
      };
      struct test_option_group system_groups[] = {
          {"grp1", NULL, true,
            { {"grp1:1"}, {"grp1:2"} } },
          {"grp2", NULL, false,
            { {"grp2:1"}, {"grp2:2"} } },
          { NULL },
      };
      struct test_option_group user_groups[] = {
          {"grp3", NULL, true,
            { {"grp3:1"}, {"grp3:2"} } },
          {"grp4", NULL, false,
            { {"grp4:1"}, {"grp4:2"} } },
          { NULL },
      };
      struct rxkb_context *ctx;
      struct rxkb_model *m;
      struct rxkb_layout *l;
      struct rxkb_option_group *g;
  
      ctx = test_setup_context(system_models, user_models,
                               system_layouts, user_layouts,
                               system_groups, user_groups);
  
      assert(find_models(ctx, "m1", "m2", "m3", "m4", NULL));
      assert(find_layouts(ctx, "l1", NO_VARIANT,
                               "l1", "v1",
                               "l2", NO_VARIANT,
                               "l2", "v2", NULL));
  
      m = fetch_model(ctx, "m1");
      assert(cmp_models(&system_models[0], m));
      rxkb_model_unref(m);
  
      m = fetch_model(ctx, "m2");
      assert(cmp_models(&system_models[1], m));
      rxkb_model_unref(m);
  
      m = fetch_model(ctx, "m3");
      assert(cmp_models(&user_models[0], m));
      rxkb_model_unref(m);
  
      m = fetch_model(ctx, "m4");
      assert(cmp_models(&user_models[1], m));
      rxkb_model_unref(m);
  
      l = fetch_layout(ctx, "l1", NO_VARIANT);
      assert(cmp_layouts(&system_layouts[0], l));
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l1", "v1");
      assert(cmp_layouts(&system_layouts[1], l));
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l2", NO_VARIANT);
      assert(cmp_layouts(&user_layouts[0], l));
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l2", "v2");
      assert(cmp_layouts(&user_layouts[1], l));
      rxkb_layout_unref(l);
  
      g = fetch_option_group(ctx, "grp1");
      assert(cmp_option_groups(&system_groups[0], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      g = fetch_option_group(ctx, "grp2");
      assert(cmp_option_groups(&system_groups[1], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      g = fetch_option_group(ctx, "grp3");
      assert(cmp_option_groups(&user_groups[0], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      g = fetch_option_group(ctx, "grp4");
      assert(cmp_option_groups(&user_groups[1], g, CMP_EXACT));
      rxkb_option_group_unref(g);
  
      rxkb_context_unref(ctx);
  }
  
  static void
  test_load_merge_no_overwrite(void)
  {
      struct test_model system_models[] =  {
          {"m1", "vendor1", "desc1"},
          {"m2", "vendor2", "desc2"},
          {NULL},
      };
      struct test_model user_models[] =  {
          {"m1", "vendor3", "desc3"}, /* must not overwrite */
          {"m4", "vendor4", "desc4"},
          {NULL},
      };
      struct test_layout system_layouts[] =  {
          {"l1", NO_VARIANT, "lbrief1", "ldesc1"},
          {"l1", "v1", "vbrief1", "vdesc1"},
          {NULL},
      };
      struct test_layout user_layouts[] =  {
          {"l2", NO_VARIANT, "lbrief2", "ldesc2"},
          {"l2", "v2", "vbrief2", "vdesc2"},
          {"l1", NO_VARIANT, "lbrief3", "ldesc3"}, /* must not overwrite */
          {"l1", "v2", "vbrief3", "vdesc3"}, /* must not overwrite */
          {NULL},
      };
      struct test_option_group system_groups[] = {
          {"grp1", "gdesc1", true,
            { {"grp1:1", "odesc11"}, {"grp1:2", "odesc12"} } },
          {"grp2", "gdesc2", false,
            { {"grp2:1", "odesc21"}, {"grp2:2", "odesc22"} } },
          { NULL },
      };
      struct test_option_group user_groups[] = {
          {"grp1", "XXXXX", false, /* must not overwrite */
            { {"grp1:1", "YYYYYYY"}, /* must not overwrite */
              {"grp1:3", "ZZZZZZ"} } }, /* append */
          {"grp4", "gdesc4", false,
            { {"grp4:1", "odesc41"}, {"grp4:2", "odesc42"} } },
          { NULL },
      };
      struct rxkb_context *ctx;
      struct rxkb_model *m;
      struct rxkb_layout *l;
      struct rxkb_option_group *g;
  
      ctx = test_setup_context(system_models, user_models,
                               system_layouts, user_layouts,
                               system_groups, user_groups);
  
      m = fetch_model(ctx, "m1");
      assert(cmp_models(&system_models[0], m));
      rxkb_model_unref(m);
  
      l = fetch_layout(ctx, "l1", NO_VARIANT);
      assert(cmp_layouts(&system_layouts[0], l));
      rxkb_layout_unref(l);
  
      l = fetch_layout(ctx, "l1", "v1");
      assert(cmp_layouts(&system_layouts[1], l));
      rxkb_layout_unref(l);
  
      assert(find_option(ctx, "grp1", "grp1:3"));
      g = fetch_option_group(ctx, "grp1");
      assert(cmp_option_groups(&system_groups[0], g, CMP_MATCHING_ONLY));
      rxkb_option_group_unref(g);
  
      rxkb_context_unref(ctx);
  }
  
  static void
  test_no_include_paths(void)
  {
      struct rxkb_context *ctx;
  
      ctx = rxkb_context_new(RXKB_CONTEXT_NO_DEFAULT_INCLUDES);
      assert(ctx);
      assert(!rxkb_context_parse_default_ruleset(ctx));
  
      rxkb_context_unref(ctx);
  }
  
  static void
  test_invalid_include(void)
  {
      struct rxkb_context *ctx;
  
      ctx = rxkb_context_new(RXKB_CONTEXT_NO_DEFAULT_INCLUDES);
      assert(ctx);
      assert(!rxkb_context_include_path_append(ctx, "/foo/bar/baz/bat"));
      assert(!rxkb_context_parse_default_ruleset(ctx));
  
      rxkb_context_unref(ctx);
  }
  
  int
  main(void)
  {
      test_no_include_paths();
      test_invalid_include();
      test_load_basic();
      test_load_full();
      test_load_merge();
      test_load_merge_no_overwrite();
      test_popularity();
  
      return 0;
  }
  

Download