t_event_log.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_log.c,v 1.6 2005/12/18 00:15:17 klmitch Exp $
*/
#include <stdio.h>
#include <stdlib.h>

#include "event-test.h"

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

TEST_PROG(t_event_log, "Test operation of event_log_* functions")


#define _str(a) #a

#define str(a)  _str(a)

#define LC_START 0xf720e0a9

#define LC_EVLOGTEST 0x4ed403d2

#define LC_EVDEBUGTEST 0x2d8fcebe

static unsigned int log_called = LC_START; /* zeroed by first log call... */

static void
t_log(const char *file, int line, const char *func, const char *msg)
{
  fprintf(stderr, "%s:%d%s%s%s: %s\n", file, line,
          func ? " (" : "", func ? func : "", func ? ")" : "", msg);
  log_called = strtoul(msg, 0, 16);
}

/* this is an attempt to keep these macros from being optimized away */
static unsigned int _ev_log(ev_flags_t flag, const char *msg);
static ev_err_t _ev_assert(int expr);
static ev_err_t _ev_abort(void);
static ev_err_t _ev_init(void);

int
main(int argc, char **argv)
{
  ev_log_t logger = _ev_debuglog; /* save original logger for checking */
  ev_err_t err;

  /* explicitly not using ev_test_init(), since this program tests the
   * infrastructure that ev_test_init() is using...
   */

  /* First, check that event_log_set() can be called... */
  TEST(t_event_log, el_set, "Test event_log_set() operation",
       (!(err = event_log_set(t_log)) && _ev_debuglog == t_log &&
        _ev_asflags == EVAS_LOG), FATAL(0),
       ("event_log_set() properly sets logging callback"),
       ("event_log_set() operation failed; error code %u, logger %p (should "
        "be %p), _ev_asflags 0x%08lx (should be 0x%08lx)", err,
        (void *)_ev_debuglog, (void *)t_log, _ev_asflags,
        (ev_flags_t)EVAS_LOG));

  /* Now, does event_log_reset() do what it's supposed to? */
  TEST(t_event_log, el_reset, "Test event_log_reset() operation",
       (!(err = event_log_reset()) && _ev_debuglog == logger &&
        _ev_asflags == 0), FATAL(0),
       ("event_log_reset() properly resets logging callback"),
       ("event_log_reset() operation failed; error code %u, logger %p (should "
        "be %p), _ev_asflags 0x%08lx (should be 0)", err, (void *)_ev_debuglog,
        (void *)logger, _ev_asflags));

  /* OK, put the logger back; do it directly to avoid side-effects */
  _ev_debuglog = t_log;

  /* Test the bit flag toggles */
  /* Turn on debug logging... */
  TEST(t_event_log, el_debug_on, "Test event_log_debug() can turn on logging",
       (!(err = event_log_debug(1)) && _ev_asflags == EVAS_LOG), 0,
       ("event_log_debug(1) properly turns on debug logging"),
       ("event_log_debug(1) fails to turn on debug logging; error %u", err));

  /* ...and off... */
  TEST(t_event_log, el_debug_off, "Test event_log_debug() can turn off "
       "logging",
       (!(err = event_log_debug(0)) && _ev_asflags == 0), 0,
       ("event_log_debug(0) properly turns off debug logging"),
       ("event_log_debug(0) fails to turn off debug logging; error %u", err));

  _ev_asflags = 0; /* reset the asflags... */

  /* Make sure no messages have been output yet */
  TEST(t_event_log, el_logmsg_start, "Test that log messages have not yet "
       "been written",
       (log_called == LC_START), 0,
       ("Log messages have not been written yet (as expected)"),
       ("An unexpected log message appears to have been written..."));

  /* Turn on function tracing... */
  TEST(t_event_log, el_trace_on, "Test event_log_trace() can turn on tracing",
       (!(err = event_log_trace(1)) && _ev_asflags == EVAS_TRACE), 0,
       ("event_log_trace(1) properly turns function tracing on"),
       ("event_log_trace(1) fails to turn on function tracing; error %u",
        err));

  /* Now turn tracing off... */
  TEST(t_event_log, el_trace_off, "Test event_log_trace() can turn off "
       "tracing",
       (!(err = event_log_trace(0)) && _ev_asflags == 0), 0,
       ("event_log_trace(0) properly turns function tracing off"),
       ("event_log_trace(0) fails to turn off function tracing; error %u",
        err));

  /* Now, a log message should have been written while tracing was turned on */
  TEST(t_event_log, el_logmsg_first, "Test that a function trace message was "
       "written",
       (log_called != LC_START), 0,
       ("Function trace log message written (as expected)"),
       ("Function trace log message seems to have not been written..."));

  /* Restore log_called to its starting value... */
  log_called = LC_START;

  _ev_asflags = 0; /* reset the asflags... */

  /* Now lets turn aborting on... */
  TEST(t_event_log, el_abort_on, "Test event_log_abort() can turn on aborting",
       (!(err = event_log_abort(1)) && _ev_asflags == EVAS_ABORT), 0,
       ("event_log_abort(1) properly turns on aborting functionality"),
       ("event_log_abort(1) fails to turn on library abort; error %u", err));

  /* Now turn it off... */
  TEST(t_event_log, el_abort_off, "Test event_log_abort() can turn off "
       "aborting",
       (!(err = event_log_abort(0)) && _ev_asflags == 0), 0,
       ("event_log_abort(0) properly turns aborting functionality off"),
       ("event_log_abort(0) fails to turn off library abort; error %u", err));

  _ev_asflags = 0; /* reset the asflags... */

  /* Test that ev_log() functions correctly */
  TEST(t_event_log, el_evlog_off, "Test that ev_log() does nothing when off",
       (_ev_log(EVAS_LOG, str(LC_EVLOGTEST)) == LC_START), 0,
       ("ev_log() macro properly ignored log message when off"),
       ("ev_log() macro wrote a message even though it was turned off"));

  log_called = LC_START; /* reset, just in case... */
  _ev_asflags = EVAS_LOG; /* turn on logging... */

  /* Try again with logging turned on... */
  TEST(t_event_log, el_evlog_on, "Test that ev_log() logs when on",
       (_ev_log(EVAS_LOG, str(LC_EVLOGTEST)) == LC_EVLOGTEST), 0,
       ("ev_log() macro properly writes log message when on"),
       ("ev_log() failed to write log message even though it was turned on"));

  log_called = LC_START; /* reset the log_called value... */
  _ev_asflags = 0; /* reset the asflags... */

  /* Test that _ev_debug() functions correctly */
  _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func, "0x%08x", LC_EVDEBUGTEST);
  TEST(t_event_log, el_evdebug_off, "Test that _ev_debug() does nothing "
       "when off",
       (log_called == LC_START), 0,
       ("_ev_debug() call properly ignored log message when off"),
       ("_ev_debug() call wrote a message even though it was turned off"));

  log_called = LC_START; /* reset again, just in case... */
  _ev_asflags = EVAS_LOG; /* turn on logging... */

  /* Try again with logging turned on... */
  _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func, "0x%08x", LC_EVDEBUGTEST);
  TEST(t_event_log, el_evdebug_on, "Test that _ev_debug() logs when on",
       (log_called == LC_EVDEBUGTEST), 0,
       ("_ev_debug() properly writes log message when on"),
       ("_ev_debug() failed to write log message even though it was "
        "turned on"));

  /* Test the ev_abort() macro... */
  _ev_asflags = 0; /* first turn off log (and abort) flags... */
  TEST(t_event_log, el_evabort_off, "Test that ev_abort() does a return when "
       "turned off",
       ((err = _ev_abort()) == EV_ERR_ASSERT), 0,
       ("ev_abort() macro properly returns EV_ERR_ASSERT when turned off"),
       ("ev_abort() macro failed to operate properly; error %u", err));

  /* Next, let's test the ev_assert() macro... */
  _ev_asflags = 0; /* clear the asflags */
  TEST(t_event_log, el_assert_true, "Test that ev_assert() accepts true "
       "values",
       ((err = _ev_assert(1)) == 0 && _ev_asflags == 0), 0,
       ("ev_assert() macro properly accepts true value"),
       ("ev_assert() macro rejected true value; error %u asflags 0x%08lx", err,
        _ev_asflags));

  _ev_asflags = 0; /* just in case... */
  TEST(t_event_log, el_assert_false, "Test that ev_assert() rejects false "
       "values",
       ((err = _ev_assert(0)) == EV_ERR_ASSERT && _ev_asflags == EVAS_LOOP), 0,
       ("ev_assert() macro properly rejects false value"),
       ("ev_assert() macro accepted false value; error %u asflags 0x%08lx",
        err, _ev_asflags));

  /* OK, ev_init() with EVAS_LOOP unset has already been tested; try now with
   * EVAS_LOOP set...
   */
  _ev_asflags = EVAS_LOOP; /* just in case... */
  TEST(t_event_log, el_init_loop, "Test that ev_init() returns if an "
       "assertion has been thrown",
       ((err = _ev_init()) == EV_ERR_ASSERT), 0,
       ("ev_init() macro causes return when EVAS_LOOP is set"),
       ("ev_init() macro failed to return properly; error %u", err));

  return 0;
}

static unsigned int
_ev_log(ev_flags_t flag, const char *msg)
{
  ev_log(flag, msg); /* do logging... */

  return log_called; /* convenience return... */
}

static ev_err_t
_ev_assert(int expr)
{
  ev_assert(expr); /* do the assertion... */

  return 0;
}

static ev_err_t
_ev_abort(void)
{
  ev_abort(); /* do the abort... */

  return 0;
}

static ev_err_t
_ev_init(void)
{
  ev_init(); /* do the initialize... */

  return 0;
}

---