@@@ man wip

[mLib] / test / tvec-timeout.c

/* -*-c-*-
 *
 * Timeout extension for test vector framework
 *
 * (c) 2024 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * mLib 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 Library General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

/*----- Header files ------------------------------------------------------*/

#include <ctype.h>
#include <errno.h>
#include <string.h>

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include "tvec.h"

/*----- Main code ---------------------------------------------------------*/

static void reset(struct tvec_timeoutctx *tc)
{
  const struct tvec_timeoutenv *te = tc->te;

  tc->timer = te->timer; tc->t = te->t; tc->f &= ~TVTF_SETMASK;
}

/* --- @tvec_timeoutsetup@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@const struct tvec_env *env@ = environment description
 *		@void *pctx@ = parent context (ignored)
 *		@void *ctx@ = context pointer to initialize
 *
 * Returns:	---
 *
 * Use:		Initialize a timeout environment context.
 *
 *		The environment description should be a @struct
 *		tvec_timeoutenv@.
 */

void tvec_timeoutsetup(struct tvec_state *tv, const struct tvec_env *env,
		       void *pctx, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = (struct tvec_timeoutenv *)env;
  const struct tvec_env *subenv = te->env;

  tc->te = te;

  reset(tc);

  tc->subctx = 0;
  if (subenv && subenv->ctxsz) tc->subctx = xmalloc(subenv->ctxsz);
  if (subenv && subenv->setup) subenv->setup(tv, subenv, tc, tc->subctx);
}

/* --- @tvec_timeoutfindvar@, @setvar@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@const char *var@ = variable name to set
 *		@const union tvec_regval *rv@ = register value
 *		@void **ctx_out@ = where to put the @setvar@ context
 *		@void *ctx@ = context pointer
 *
 * Returns:	@tvec_timeoutfindvar@ returns a pointer to the variable
 *		definition, or null; @setvar@ returns zero on success or
 *		%$-1$% on error.
 *
 * Use:		Find a definition for a special variable.  The following
 *		special variables are supported.
 *
 *		  * %|@timeout|% is the duration to wait before killing the
 *		    process.
 *
 *		  * %|@timer|% is the timer to use to measure the duration.
 *
 *		Unrecognized variables are passed to the subordinate
 *		environment, if there is one.
 */

static int setvar(struct tvec_state *tv, const char *var,
		  const union tvec_regval *rv, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;

  if (STRCMP(var, ==, "@timeout")) {
    if (tc->f&TVTF_SETTMO) return (tvec_dupreg(tv, var));
    tc->t = rv->f; tc->f |= TVTF_SETTMO;
  } else if (STRCMP(var, ==, "@timer")) {
    if (tc->f&TVTF_SETTMR) return (tvec_dupreg(tv, var));
    tc->timer = rv->i; tc->f |= TVTF_SETTMR;
  } else assert(!"unknown var");
  return (0);
}

static const struct tvec_vardef timeout_var =
  { sizeof(struct tvec_reg), setvar,
    { "@timeout", &tvty_duration, -1, 0 } };

static const struct tvec_iassoc timer_assocs[] = {
  { "REAL",	ITIMER_REAL },
  { "VIRTUAL",	ITIMER_VIRTUAL },
  { "PROF",	ITIMER_PROF },
  TVEC_ENDENUM
};
static const struct tvec_ienuminfo timer_enum =
  { "interval-timer", timer_assocs, &tvrange_int };
static const struct tvec_vardef timer_var =
  { sizeof(struct tvec_reg), setvar,
    { "@timer", &tvty_ienum, -1, 0, { &timer_enum } } };

const struct tvec_vardef *tvec_timeoutfindvar
  (struct tvec_state *tv, const char *var, void **ctx_out, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = tc->te;
  const struct tvec_env *subenv = te->env;

  if (STRCMP(var, ==, "@timeout")) { *ctx_out = tc; return (&timeout_var); }
  else if (STRCMP(var, ==, "@timer")) { *ctx_out = tc; return (&timer_var); }
  else if (subenv && subenv->findvar)
    return (subenv->findvar(tv, var, ctx_out, tc->subctx));
  else return (0);
}

/* --- @tvec_timeoutbefore@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@void *ctx@ = context pointer
 *
 * Returns:	---
 *
 * Use:		Invoke the subordinate environment's @before@ function to
 *		prepare for the test.
 */

void tvec_timeoutbefore(struct tvec_state *tv, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = tc->te;
  const struct tvec_env *subenv = te->env;

  if (subenv && subenv->before) subenv->before(tv, tc->subctx);
}

/* --- @tvec_timeoutrun@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@tvec_testfn *fn@ = test function to run
 *		@void *ctx@ = context pointer for the test function
 *
 * Returns:	---
 *
 * Use:		Runs a test with a timeout attached.
 */

void tvec_timeoutrun(struct tvec_state *tv, tvec_testfn *fn, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = tc->te;
  const struct tvec_env *subenv = te->env;
  struct itimerval itv;

  itv.it_interval.tv_sec = 0; itv.it_interval.tv_usec = 0;
  itv.it_value.tv_sec = tc->t;
  itv.it_value.tv_usec = (tc->t - itv.it_value.tv_sec)*1e6;

  if (setitimer(tc->timer, &itv, 0))
    tvec_skip(tv, "failed to set interval timer: %s", strerror(errno));
  else {
    if (subenv && subenv->run) subenv->run(tv, fn, tc->subctx);
    else fn(tv->in, tv->out, tc->subctx);

    itv.it_interval.tv_sec = 0; itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 0; itv.it_value.tv_usec = 0;
    if (setitimer(tc->timer, &itv, 0))
      tvec_error(tv, "failed to disarm interval timer: %s", strerror(errno));
  }
}

/* --- @tvec_timeoutafter@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@void *ctx@ = context pointer
 *
 * Returns:	---
 *
 * Use:		Invoke the subordinate environment's @after@ function to
 *		clean up after the test.
 */

void tvec_timeoutafter(struct tvec_state *tv, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = tc->te;
  const struct tvec_env *subenv = te->env;

  /* Reset variables. */
  reset(tc);

  /* Pass the call on to the subsidiary environment. */
  if (subenv && subenv->after) subenv->after(tv, tc->subctx);
}

/* --- @tvec_timeoutteardown@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@void *ctx@ = context pointer
 *
 * Returns:	---
 *
 * Use:		Tear down the timeoutmark environment.
 */

void tvec_timeoutteardown(struct tvec_state *tv, void *ctx)
{
  struct tvec_timeoutctx *tc = ctx;
  const struct tvec_timeoutenv *te = tc->te;
  const struct tvec_env *subenv = te->env;

  /* Just call the subsidiary environment. */
  if (subenv && subenv->teardown) subenv->teardown(tv, tc->subctx);
}

/*----- That's all, folks -------------------------------------------------*/