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

#include <stdio.h>
#include <string.h>

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

TEST_PROG(t_event_init, "Test operation of event_init() and related functions")
     TEST_ARG(t_event_init, "<event-test.tc>")
     TEST_ARG(t_event_init, "<engmodinit.la>")
     TEST_ARG(t_event_init, "<engmodule.la>")
     TEST_DEP(t_event_init, t_event_log)
     TEST_DEP(t_event_init, t_event_attrs)

static ev_err_t
ei_init(ev_ctx_t *ctx, ev_engine_t *engine, ev_flags_t *eng_flags)
{
  eng_data_set(engine, (void *)(*eng_flags)); /* save the called flags */
  return EINVAL; /* and return an error code */
}

static ev_err_t
ei_poll(ev_ctx_t *ctx, ev_engine_t *engine, struct timeval *timeout)
{
  return 0;
}

static ev_err_t
ei_sock(ev_ctx_t *ctx, ev_engine_t *engine, ev_sock_t *sock)
{
  return 0;
}

static ev_err_t
ei_sockev(ev_ctx_t *ctx, ev_engine_t *engine, ev_sock_t *sock, ev_flags_t evs)
{
  return 0;
}

static ev_err_t
ei_sig(ev_ctx_t *ctx, ev_engine_t *engine, ev_sig_t *sig)
{
  return 0;
}

static ev_err_t
ei_tim(ev_ctx_t *ctx, ev_engine_t *engine, ev_tim_t *tim)
{
  return 0;
}

static struct teng {
  ev_err_t      err_code;       
  ev_flags_t    comp_flags;     
  ev_engine_t   engine;         
} tengs[] = {
  /* Engine with bad socket component. */
  { EINVAL, 0, EV_ENGINE_INIT("badsock", "Test bad socket engine rejection",
                              EV_ENGINE_SOCKET, ei_init, ei_poll, 0,
                              0, 0, 0, 0, 0, 0, 0) },

  /* Engine with bad signal component. */
  { EINVAL, 0, EV_ENGINE_INIT("badsig", "Test bad signal engine rejection",
                              EV_ENGINE_SIGNAL, ei_init, ei_poll, 0,
                              0, 0, 0, 0, 0, 0, 0) },

  /* Engine with bad timer component. */
  { 0, 0, EV_ENGINE_INIT("badtim", "Test bad timer engine rejection",
                         EV_ENGINE_TIMER, ei_init, ei_poll, 0,
                         0, 0, 0, 0, 0, 0, 0) },

  /* Socket-only engine. */
  { 0, EV_ENGINE_SOCKET,
    EV_ENGINE_INIT("sockonly", "Test socket-only initialization",
                   (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL | EV_ENGINE_TIMER),
                   ei_init, ei_poll, 0,
                   ei_sock, ei_sock, ei_sockev,
                   ei_sig, ei_sig,
                   ei_tim, ei_tim) },

  /* Signal-only engine. */
  { 0, EV_ENGINE_SIGNAL,
    EV_ENGINE_INIT("sigonly", "Test signal-only initialization",
                   (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL | EV_ENGINE_TIMER),
                   ei_init, ei_poll, 0,
                   ei_sock, ei_sock, ei_sockev,
                   ei_sig, ei_sig,
                   ei_tim, ei_tim) },

  /* Timer-only engine. */
  { 0, EV_ENGINE_TIMER,
    EV_ENGINE_INIT("timonly", "Test timer-only initialization",
                   (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL | EV_ENGINE_TIMER),
                   ei_init, ei_poll, 0,
                   ei_sock, ei_sock, ei_sockev,
                   ei_sig, ei_sig,
                   ei_tim, ei_tim) },

  /* Default component set engine. */
  { 0, (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL | EV_ENGINE_TIMER),
    EV_ENGINE_INIT("allcomps", "Test all-comps initialization",
                   (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL | EV_ENGINE_TIMER),
                   ei_init, ei_poll, 0,
                   ei_sock, ei_sock, ei_sockev,
                   ei_sig, ei_sig,
                   ei_tim, ei_tim) }
};

#define TENG_CNT        (sizeof(tengs) / sizeof(struct teng))

static int
gen_verify(ev_ctx_t *ctx, unsigned int gentype, ev_magic_t genmagic,
           size_t gensize)
{
  ev_gendesc_t *gd = &ctx->ec_gens->gs_gens[gentype - ctx->ec_gens->gs_first];

  return gd->gd_type == gentype && gd->gd_magic == genmagic &&
    gd->gd_size == gensize && !gd->gd_active.gl_count &&
    !gd->gd_active.gl_list && !gd->gd_free.gl_count && !gd->gd_free.gl_list;
}

int
main(int argc, char **argv)
{
  const char *conf;
  char *prog, pathbuf[1024], *t1, *t2;
  const char *path = pathbuf;
  const char *modlist = "sockonly:s sigonly:i timonly:t allcomps "
    "engmodule:s engmodinit:it";
  ev_err_t err;
  ev_ctx_t ctx;
  ev_attr_t attrs;
  int i, pathlen;

  ev_test_init(t_event_init); /* initialize test program */
  ev_prog_name(prog, argv); /* calculate program name... */

  if (argc < 4) { /* must have three arguments: path to conf file,
                     path to first module, path to second module */
    fprintf(stderr, "Usage: %s <conf> <mod1> <mod2>\n", prog);
    exit(1);
  }

  conf = argv[1]; /* prepare conf file pointer... */

  if ((t1 = strrchr(t2 = argv[2], '/'))) /* grab first path component */
    *t1 = '\0';
  else
    t2 = "."; /* No path component, must be current directory */
  pathlen = sprintf(pathbuf, "%s", t2); /* format first path component */

  if ((t1 = strrchr(t2 = argv[3], '/'))) /* grab second path component */
    *t1 = '\0';
  else
    t2 = "."; /* No path component, must be current directory */
  /* if not identical to the first... */
  if (strcmp(pathbuf, t2))
    sprintf(pathbuf + pathlen, ":%s", t2); /* add second path component */

  /* Set t to point to the pathbuf... */
  path = pathbuf;

  if ((err = event_attr_init(&attrs)) || /* initialize attributes... */
      (err = event_attr_confpath(&attrs, &conf)) ||
      (err = event_attr_confreg(&attrs, "app.t_event_init.foo", "blah",
                                0, 0, 0)) ||
      (err = event_attr_confreg(&attrs, "app.t_event_init.bar", "halb",
                                0, 0, 0)) ||
      (err = event_attr_confvar(&attrs, "app.t_event_init.foo", "halb")) ||
      (err = event_attr_confvar(&attrs, "event.modules.foo.bar", "bar")) ||
      (err = event_attr_libpath(&attrs, &path)) ||
      (err = event_attr_modlist(&attrs, &modlist))) {
    fprintf(stderr, "%s: Unable to initialize configuration file path: error "
            "code %u\n", prog, err);
    exit(1);
  }

  /* Run through the list of application-specific generators... */
  TEST_DECL(t_event_init, ea_engine, "Test that adding engines to the "
            "attributes set works")
    for (i = 0; i < TENG_CNT; i++)
      if ((err = event_attr_engine(&attrs, &tengs[i].engine)) !=
          tengs[i].err_code)
        FAIL(TEST_NAME(ea_engine), FATAL(0), "Failure adding engine \"%s\" to "
             "attributes set; error code %u (expected %u)",
             eng_name(&tengs[i].engine), err, tengs[i].err_code);
  PASS(TEST_NAME(ea_engine), "Successfully added application-specific "
       "engines");

  /* Test that event_init() can be called... */
  TEST(t_event_init, event_init, "Test that event_init may be called",
       (!(err = event_init(&ctx, &attrs, 0, prog, 0))), FATAL(0),
       ("event_init() call succeeded"),
       ("event_init() call failed with error %u", err));

  /* Release attribute memory... */
  if ((err = event_attr_destroy(&attrs))) {
    fprintf(stderr, "%s: Unable to release attribute memory: error code %u\n",
            prog, err);
    exit(1);
  }

  /* Check that the engines are consistent with expected results */
  TEST_DECL(t_event_init, ea_enginit, "Test that added engines were "
            "initialized properly")
    for (i = 0; i < TENG_CNT; i++)
      if (tengs[i].comp_flags != (ev_flags_t)eng_data(&tengs[i].engine))
        FAIL(TEST_NAME(ea_enginit), FATAL(0), "Failure initializing engine "
             "\"%s\"; init called with flags 0x%08lx, expected 0x%08lx",
             eng_name(&tengs[i].engine),
             (ev_flags_t)eng_data(&tengs[i].engine), tengs[i].comp_flags);
  PASS(TEST_NAME(ea_enginit), "All application-specific engines successfully "
       "initialized");

  /* Now, test that the generator list is setup properly */
  TEST(t_event_init, event_genlist,
       "Test that event_init() left generator list in expected state",
       (ctx.ec_gens && !ctx.ec_gens->gs_next && !ctx.ec_gens->gs_prev &&
        ctx.ec_gens->gs_first == EGT_SOCKET && ctx.ec_gens->gs_count == 3),
       FATAL(0),
       ("event_init() left generator list in consistent state"),
       ("event_init() failed to leave generator list in consistent state"));

  /* And test the actual generator characteristics... */
  TEST(t_event_init, event_defgens,
       "Test that event_init() set the proper parameters for the default "
       "generators",
       (gen_verify(&ctx, EGT_SOCKET, EV_SOCK_MAGIC, sizeof(ev_sock_t)) &&
        gen_verify(&ctx, EGT_SIGNAL, EV_SIG_MAGIC, sizeof(ev_sig_t)) &&
        gen_verify(&ctx, EGT_TIMER, EV_TIM_MAGIC, sizeof(ev_tim_t))), 0,
       ("event_init() initialized default generators properly"),
       ("event_init() failed to initialize default generators properly"));

  /* Finally, test that event_destroy() may be called */
  TEST(t_event_init, event_destroy, "Test that event_destroy() may be "
       "successfully called",
       (!(err = event_destroy(&ctx)) && !ec_verify(&ctx)), FATAL(0),
       ("event_destroy() call succeeded"),
       ("event_destroy() failed with error %u", err));

  return 0;
}

---