t_evg_alloc.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_alloc.c,v 1.3 2005/12/18 00:15:17 klmitch Exp $
*/
#include "event-test.h"

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

TEST_PROG(t_evg_alloc, "Test operation of event_gen_alloc() and "
          "event_gen_release()")
     TEST_ARG(t_evg_alloc, "<event-test.tc>")
     TEST_ARG(t_evg_alloc, "<engmodule.la>")
     TEST_DEP(t_evg_alloc, t_evg_register)

struct t_gen {
  ev_genhdr_t           tg_hdr;         
  unsigned int          tg_seq;         
};

#define cnt(array)              (sizeof(array) / sizeof(struct t_gen *))

int
main(int argc, char **argv)
{
  int i, fcnt = 0;
  char *prog;
  ev_err_t err;
  ev_ctx_t ctx;
  struct t_gen *alloc[25], *gen;
  ev_gendesc_t *gd;

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

  /* First, let's register our testing generator... */
  if ((err = event_gen_register(&ctx, EGT_RESERVED, EGT_RESERVED,
                                sizeof(struct t_gen), 0)) ||
      (err = _ev_gen_lookup(&ctx, EGT_RESERVED, &gd))) {
    fprintf(stderr, "%s: Unable to register testing generator: "
            "error code %u\n", prog, err);
    exit(1);
  }

  /* allocate some test generators... */
  TEST_DECL(t_evg_alloc, evg_alloc, "Test that event_gen_alloc() can allocate "
            "generators")
    for (i = 0; i < cnt(alloc); i++)
      if ((err = event_gen_alloc(&ctx, EGT_RESERVED, &alloc[i])))
        FAIL(TEST_NAME(evg_alloc), FATAL(0), "Unable to allocate "
             "generator %d; error code %u", i, err);
      else
        alloc[i]->tg_seq = i;
  /* double-check the allocation count... */
  if (gd->gd_active.gl_count == cnt(alloc))
    PASS(TEST_NAME(evg_alloc), "Successfully allocated event generators");
  else
    FAIL(TEST_NAME(evg_alloc), FATAL(0), "Inconsistent generator allocation "
         "count; was %u, should be %u", gd->gd_active.gl_count,
         cnt(alloc));

  /* Now release some test generators back onto the free list */
  TEST_DECL(t_evg_alloc, evg_release, "Test that event_gen_release() can "
            "release generators")
    for (i = 0; i < cnt(alloc); i += 2)
      if ((err = event_gen_release(&ctx, (ev_genhdr_t *)alloc[i])))
        FAIL(TEST_NAME(evg_release), FATAL(0), "Unable to release "
             "generator %d; error code %u", i, err);
      else
        fcnt++; /* keep track of number we released... */
  /* double-check the counts... */
  if (gd->gd_active.gl_count == cnt(alloc) - fcnt &&
      gd->gd_free.gl_count == fcnt)
    PASS(TEST_NAME(evg_release), "Successfully released event generators");
  else
    FAIL(TEST_NAME(evg_release), FATAL(0), "Inconsistent generator allocation "
         "counts; active %u, should be %u; free %u, should be %u",
         gd->gd_active.gl_count, cnt(alloc) - fcnt, gd->gd_free.gl_count,
         fcnt);

  /* Finally, try resurrecting some of the released generators */
  TEST_DECL(t_evg_alloc, evg_realloc, "Test that event_gen_alloc() can "
            "resurrect released generators from the free list")
    for (i = 0; i < fcnt; i++)
      if ((err = event_gen_alloc(&ctx, EGT_RESERVED, &gen)))
        FAIL(TEST_NAME(evg_realloc), FATAL(0), "Unable to allocate "
             "generator %d; error code %u", i, err);
      else if (gen->tg_seq >= cnt(alloc) || gen != alloc[gen->tg_seq])
        FAIL(TEST_NAME(evg_realloc), FATAL(0), "Generator allocated is not "
             "from the free list; seq is %u but address %p is not %p",
             gen->tg_seq, (void *)gen,
             (void *)(gen->tg_seq >= cnt(alloc) ? 0 : alloc[gen->tg_seq]));
  /* double-check the counts... */
  if (gd->gd_active.gl_count == cnt(alloc) && gd->gd_free.gl_count == 0)
    PASS(TEST_NAME(evg_realloc), "Successfully reallocated items from the "
         "free list");
  else
    FAIL(TEST_NAME(evg_realloc), FATAL(0), "Inconsistent generator allocation "
         "counts; active %u, should be %u; free %u, should be 0",
         gd->gd_active.gl_count, cnt(alloc), gd->gd_free.gl_count);

  /* Test the parts of event_destroy() that release the free lists */
  TEST(t_evg_alloc, evg_destroy, "Test that event_destroy() releases "
       "free-listed generators",
       (!(err = event_destroy(&ctx))), 0,
       ("event_destroy() successfully released free-listed generators"),
       ("event_destroy() call failed; error %u", err));

  return 0;
}

---