t_evg_register.c

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: t_evg_register.c,v 1.7 2005/12/18 00:15:17 klmitch Exp $
*/
#include "event-test.h"

RCSTAG("@(#)$Id: t_evg_register.c,v 1.7 2005/12/18 00:15:17 klmitch Exp $");

TEST_PROG(t_evg_register, "Test operation of event_gen_register()")
     TEST_ARG(t_evg_register, "<event-test.tc>")
     TEST_ARG(t_evg_register, "<engmodule.la>")
     TEST_DEP(t_evg_register, t_event_log)
     TEST_DEP(t_evg_register, t_event_init)

enum {
  TGT_01 = EGT_RESERVED, TGT_02, TGT_03, TGT_04, TGT_05, TGT_06, TGT_07,
  TGT_08, TGT_09, TGT_10, TGT_11
};

struct rule {
  const int gens;               
  const unsigned int endfl;     
  const unsigned int first;     
  const unsigned int count;     
};

#define rule_init(gens, endfl, first, count)                                  \
  { (gens), (endfl), (first), (count) }

struct test {
  const char *test;             
  const unsigned int gen;       
  const ev_err_t err;           
  const unsigned int rulecnt;   
  const struct rule *rules;     
};

#define test_rule(name, gen, err, rules)                                      \
  { (name), (gen), (err), sizeof(rules) / sizeof(struct rule), (rules) }

#define test_norule(name, gen, err)                                           \
  { (name), (gen), (err), 0, 0 }

static struct rule endcons_rules[] = {
  rule_init(1, 1, TGT_06, 1)
};

static struct rule endextforw_rules[] = {
  rule_init(1, 1, TGT_06, 2)
};

static struct rule endextrev_rules[] = {
  rule_init(1, 1, TGT_05, 3)
};

static struct rule midcons_rules[] = {
  rule_init(1, 0, TGT_02, 1),
  rule_init(2, 1, TGT_05, 3)
};

static struct rule midextforw_rules[] = {
  rule_init(1, 0, TGT_02, 2),
  rule_init(2, 1, TGT_05, 3)
};

static struct rule midextrev_rules[] = {
  rule_init(1, 0, TGT_01, 3),
  rule_init(2, 1, TGT_05, 3)
};

static struct rule endmerge_rules[] = {
  rule_init(1, 1, TGT_01, 7)
};

static struct rule midmerge_rules[] = {
  rule_init(1, 0, TGT_01, 9),
  rule_init(2, 1, TGT_11, 1)
};

static struct test tests[] = {
  TEST_DECL(t_evg_register, evg_endcons, "Test that an event generator "
            "can be constructed at the end of the gens list")
  test_rule(TEST_NAME(evg_endcons), TGT_06, 0, endcons_rules),

  TEST_DECL(t_evg_register, evg_multreg, "Test that multiple generator "
            "registration is rejected")
  test_norule(TEST_NAME(evg_multreg), TGT_06, EV_ERR_DUPGEN),

  TEST_DECL(t_evg_register, evg_endextforw, "Test that an event generator "
            "at end of gens list can be extended forward")
  test_rule(TEST_NAME(evg_endextforw), TGT_07, 0, endextforw_rules),

  TEST_DECL(t_evg_register, evg_endextrev, "Test that an event generator "
            "at end of gens list can be extended in reverse")
  test_rule(TEST_NAME(evg_endextrev), TGT_05, 0, endextrev_rules),

  TEST_DECL(t_evg_register, evg_midcons, "Test that an event generator "
            "can be constructed in middle of gens list")
  test_rule(TEST_NAME(evg_midcons), TGT_02, 0, midcons_rules),

  TEST_DECL(t_evg_register, evg_midextforw, "Test that an event generator "
            "in middle of gens list can be extended forward")
  test_rule(TEST_NAME(evg_midextforw), TGT_03, 0, midextforw_rules),

  TEST_DECL(t_evg_register, evg_midextrev, "Test that an event generator "
            "in middle of gens list can be extended in reverse")
  test_rule(TEST_NAME(evg_midextrev), TGT_01, 0, midextrev_rules),

  TEST_DECL(t_evg_register, evg_endmerge, "Test that adding an event "
            "generator directly between two gens at end of gens list will "
            "result in a merge")
  test_rule(TEST_NAME(evg_endmerge), TGT_04, 0, endmerge_rules),

  /* Set up for testing midlist merge */
  test_norule(0, TGT_09, 0),
  test_norule(0, TGT_11, 0),

  TEST_DECL(t_evg_register, evg_midmerge, "Test that adding an event "
            "generator directly between two gens in middle of gens list will "
            "result in a merge")
  test_rule(TEST_NAME(evg_midmerge), TGT_08, 0, midmerge_rules)
};

static int
do_rules(ev_ctx_t *ctx, unsigned int rulecnt, const struct rule *rules)
{
  int genidx = 0, i, j;
  ev_gens_t *gen = ctx->ec_gens;

  for (i = 0; i < rulecnt; i++) { /* walk through the rules... */
    for (; gen && genidx < rules[i].gens;) {
      gen = gen->gs_next; /* find correct gens struct */
      genidx++;
    }

    if (!gen || /* did we run out of gens without finding it? */
        (rules[i].endfl && gen->gs_next) || /* is it supposed to be the end? */
        rules[i].first != gen->gs_first || rules[i].count != gen->gs_count)
      return 0; /* all simple test performed... */

    /* OK, now we must walk through the generators and make sure they match */
    for (j = 0; j < gen->gs_count; j++)
      if (gen->gs_gens[j].gd_type != (rules[i].first + j) || /* check type */
          gen->gs_gens[j].gd_magic != (rules[i].first + j) || /* magic */
          gen->gs_gens[j].gd_size != (rules[i].first + j +
                                      sizeof(ev_genhdr_t)) || /* and size */
          gen->gs_gens[j].gd_active.gl_count || /* check list init... */
          gen->gs_gens[j].gd_active.gl_list ||
          gen->gs_gens[j].gd_free.gl_count ||
          gen->gs_gens[j].gd_free.gl_list)
        return 0;
  }

  return 1; /* everything tests good! */
}

int
main(int argc, char **argv)
{
  int i;
  char *prog;
  ev_err_t err;
  ev_ctx_t ctx;

  ev_test_init(t_evg_register); /* initialize test program */
  ev_prog_name(prog, argv); /* calculate program name... */
  ev_lib_init(argc, argv, prog, &ctx); /* initialize event library */

  for (i = 0; i < sizeof(tests) / sizeof(struct test); i++)
    /* execute the test case... */
    if ((err = event_gen_register(&ctx, tests[i].gen, tests[i].gen,
                                  tests[i].gen + sizeof(ev_genhdr_t), 0)) !=
        tests[i].err) {
      if (tests[i].test) /* if no test name specified, not an actual test... */
        FAIL(tests[i].test, 0, "event_gen_register() failed with error %u",
             err);
      exit(0); /* We can't continue, so exit here... */
    } else if (tests[i].rulecnt && tests[i].rules && /* check rules... */
               !do_rules(&ctx, tests[i].rulecnt, tests[i].rules)) {
      if (tests[i].test) /* if no test name specified, not an actual test... */
        FAIL(tests[i].test, 0, "event_gen_register() left gens list in "
             "inconsistent state (do_rules() call failed)");
      exit(0); /* We can't continue, so exit here... */
    } else if (tests[i].test) /* test is passed; issue the success... */
      PASS(tests[i].test, "event_gen_register() successfully registered "
           "generator");

  event_destroy(&ctx); /* destroy the context */

  return 0;
}

---