@@@ more mess

[mLib] / test / tvec-output.c

/* -*-c-*-
 *
 * Test vector output management
 *
 * (c) 2023 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 "config.h"

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

#include <unistd.h>

#include "alloc.h"
#include "bench.h"
#include "dstr.h"
#include "quis.h"
#include "report.h"
#include "tvec.h"

/*----- Common machinery --------------------------------------------------*/

static const char *regdisp(unsigned disp)
{
  switch (disp) {
    case TVRD_INPUT: return "input";
    case TVRD_OUTPUT: return "output";
    case TVRD_MATCH: return "matched";
    case TVRD_EXPECT: return "expected";
    case TVRD_FOUND: return "found";
    default: abort();
  }
}

static int getenv_boolean(const char *var, int dflt)
{
  const char *p;

  p = getenv(var);
  if (!p)
    return (dflt);
  else if (STRCMP(p, ==, "y") || STRCMP(p, ==, "yes") ||
	   STRCMP(p, ==, "t") || STRCMP(p, ==, "true") ||
	   STRCMP(p, ==, "on") || STRCMP(p, ==, "force") ||
	   STRCMP(p, ==, "1"))
    return (1);
  else if (STRCMP(p, ==, "n") || STRCMP(p, ==, "no") ||
	   STRCMP(p, ==, "f") || STRCMP(p, ==, "false") ||
	   STRCMP(p, ==, "nil") || STRCMP(p, ==, "off") ||
	   STRCMP(p, ==, "0"))
    return (0);
  else {
    moan("unexpected value `%s' for boolean environment variable `%s'",
	 var, p);
    return (dflt);
  }
}

static int register_maxnamelen(const struct tvec_state *tv)
{
  const struct tvec_regdef *rd;
  int maxlen = 6, n;

  for (rd = tv->test->regs; rd->name; rd++)
    { n = strlen(rd->name); if (n > maxlen) maxlen = n; }
  return (maxlen);
}

/*----- Skeleton ----------------------------------------------------------*/
/*
static void ..._error(struct tvec_output *o, const char *msg, va_list *ap)
static void ..._notice(struct tvec_output *o, const char *msg, va_list *ap)
static void ..._bsession(struct tvec_output *o)
static int ..._esession(struct tvec_output *o)
static void ..._bgroup(struct tvec_output *o)
static void ..._egroup(struct tvec_output *o, unsigned outcome)
static void ..._skipgroup(struct tvec_output *o,
			  const char *excuse, va_list *ap)
static void ..._btest(struct tvec_output *o)
static void ..._skip(struct tvec_output *o, const char *excuse, va_list *ap)
static void ..._fail(struct tvec_output *o, const char *detail, va_list *ap)
static void ..._dumpreg(struct tvec_output *o, unsigned disp,
			union tvec_regval *rv, const struct tvec_regdef *rd)
static void ..._etest(struct tvec_output *o, unsigned outcome)
static void ..._bbench(struct tvec_output *o,
		       const char *ident, unsigned unit)
static void ..._ebench(struct tvec_output *o,
		       const char *ident, unsigned unit,
		       const struct tvec_timing *t)
static void ..._destroy(struct tvec_output *o)

static const struct tvec_outops ..._ops = {
  ..._error, ..._notice,
  ..._bsession, ..._esession,
  ..._bgroup, ..._egroup, ..._skip,
  ..._btest, ..._skip, ..._fail, ..._dumpreg, ..._etest,
  ..._bbench, ..._ebench,
  ..._destroy
};
*/
/*----- Human-readable output ---------------------------------------------*/

#define HAF_FGMASK 0x0f
#define HAF_FGSHIFT 0
#define HAF_BGMASK 0xf0
#define HAF_BGSHIFT 4
#define HAF_FG 256u
#define HAF_BG 512u
#define HAF_BOLD 1024u
#define HCOL_BLACK 0u
#define HCOL_RED 1u
#define HCOL_GREEN 2u
#define HCOL_YELLOW 3u
#define HCOL_BLUE 4u
#define HCOL_MAGENTA 5u
#define HCOL_CYAN 6u
#define HCOL_WHITE 7u
#define HCF_BRIGHT 8u
#define HFG(col) (HAF_FG | (HCOL_##col) << HAF_FGSHIFT)
#define HBG(col) (HAF_BG | (HCOL_##col) << HAF_BGSHIFT)

#define HA_WIN (HFG(GREEN))
#define HA_LOSE (HFG(RED) | HAF_BOLD)
#define HA_SKIP (HFG(YELLOW))
#define HA_ERR (HFG(MAGENTA) | HAF_BOLD)

struct human_output {
  struct tvec_output _o;
  FILE *fp;
  dstr scoreboard;
  unsigned attr;
  int maxlen;
  unsigned f;
#define HOF_TTY 1u
#define HOF_DUPERR 2u
#define HOF_COLOUR 4u
#define HOF_PROGRESS 8u
};

static void set_colour(FILE *fp, int *sep_inout,
		       const char *norm, const char *bright,
		       unsigned colour)
{
  if (*sep_inout) putc(*sep_inout, fp);
  fprintf(fp, "%s%d", colour&HCF_BRIGHT ? bright : norm, colour&7);
  *sep_inout = ';';
}

static void setattr(struct human_output *h, unsigned attr)
{
  unsigned diff = h->attr ^ attr;
  int sep = 0;

  if (!diff || !(h->f&HOF_COLOUR)) return;
  fputs("\x1b[", h->fp);

  if (diff&HAF_BOLD) {
    if (attr&HAF_BOLD) putc('1', h->fp);
    else { putc('0', h->fp); diff = h->attr; }
    sep = ';';
  }
  if (diff&(HAF_FG | HAF_FGMASK)) {
    if (attr&HAF_FG)
      set_colour(h->fp, &sep, "3", "9", (attr&HAF_FGMASK) >> HAF_FGSHIFT);
    else
      { if (sep) putc(sep, h->fp); fputs("39", h->fp); sep = ';'; }
  }
  if (diff&(HAF_BG | HAF_BGMASK)) {
    if (attr&HAF_BG)
      set_colour(h->fp, &sep, "4", "10", (attr&HAF_BGMASK) >> HAF_BGSHIFT);
    else
      { if (sep) putc(sep, h->fp); fputs("49", h->fp); sep = ';'; }
  }

  putc('m', h->fp); h->attr = attr;

#undef f_any
}

static void clear_progress(struct human_output *h)
{
  size_t i, n;

  if (h->f&HOF_PROGRESS) {
    n = strlen(h->_o.tv->test->name) + 2 + h->scoreboard.len;
    for (i = 0; i < n; i++) fputs("\b \b", h->fp);
    h->f &= ~HOF_PROGRESS;
  }
}

static void write_scoreboard_char(struct human_output *h, int ch)
{
  switch (ch) {
    case 'x': setattr(h, HA_LOSE); break;
    case '_': setattr(h, HA_SKIP); break;
    default: setattr(h, 0); break;
  }
  putc(ch, h->fp); setattr(h, 0);
}

static void show_progress(struct human_output *h)
{
  struct tvec_state *tv = h->_o.tv;
  const char *p, *l;

  if (tv->test && (h->f&HOF_TTY) && !(h->f&HOF_PROGRESS)) {
    fprintf(h->fp, "%s: ", h->_o.tv->test->name);
    if (!(h->f&HOF_COLOUR))
      dstr_write(&h->scoreboard, h->fp);
    else for (p = h->scoreboard.buf, l = p + h->scoreboard.len; p < l; p++)
      write_scoreboard_char(h, *p);
    fflush(h->fp); h->f |= HOF_PROGRESS;
  }
}

static void report_location(struct human_output *h, FILE *fp,
			    const char *file, unsigned lno)
{
  unsigned f = 0;
#define f_flush 1u

#define FLUSH(fp) do if (f&f_flush) fflush(fp); while (0)

  if (fp != h->fp) f |= f_flush;

  if (file) {
    setattr(h, HFG(CYAN)); FLUSH(h->fp); fputs(file, fp); FLUSH(fp);
    setattr(h, HFG(BLUE)); FLUSH(h->fp); fputc(':', fp); FLUSH(fp);
    setattr(h, HFG(CYAN)); FLUSH(h->fp); fprintf(fp, "%u", lno); FLUSH(fp);
    setattr(h, HFG(BLUE)); FLUSH(h->fp); fputc(':', fp); FLUSH(fp);
    setattr(h, 0); FLUSH(h->fp); fputc(' ', fp);
  }

#undef f_flush
#undef FLUSH
}

static void human_report(struct tvec_output *o, const char *msg, va_list *ap)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;
  dstr d = DSTR_INIT;

  dstr_vputf(&d, msg, ap); dstr_putc(&d, '\n');

  clear_progress(h); fflush(h->fp);
  fprintf(stderr, "%s: ", QUIS);
  report_location(h, stderr, tv->infile, tv->lno);
  fwrite(d.buf, 1, d.len, stderr);

  if (h->f&HOF_DUPERR) {
    report_location(h, h->fp, tv->infile, tv->lno);
    fwrite(d.buf, 1, d.len, h->fp);
  }
  show_progress(h);
}

static void human_bsession(struct tvec_output *o) { ; }

static void report_skipped(struct human_output *h, unsigned n)
{
  if (n) {
    fprintf(h->fp, " (%u ", n);
    setattr(h, HA_SKIP); fputs("skipped", h->fp); setattr(h, 0);
    fputc(')', h->fp);
  }
}

static int human_esession(struct tvec_output *o)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;
  unsigned
    all_win = tv->all[TVOUT_WIN], grps_win = tv->grps[TVOUT_WIN],
    all_lose = tv->all[TVOUT_LOSE], grps_lose = tv->grps[TVOUT_LOSE],
    all_skip = tv->all[TVOUT_SKIP], grps_skip = tv->grps[TVOUT_SKIP],
    all_run = all_win + all_lose, grps_run = grps_win + grps_lose;

  if (!all_lose) {
    setattr(h, HA_WIN); fputs("PASSED", h->fp); setattr(h, 0);
    fprintf(h->fp, " %s%u %s",
	    !(all_skip || grps_skip) ? "all " : "",
	    all_win, all_win == 1 ? "test" : "tests");
    report_skipped(h, all_skip);
    fprintf(h->fp, " in %u %s",
	    grps_win, grps_win == 1 ? "group" : "groups");
    report_skipped(h, grps_skip);
  } else {
    setattr(h, HA_LOSE); fputs("FAILED", h->fp); setattr(h, 0);
    fprintf(h->fp, " %u out of %u %s",
	    all_lose, all_run, all_run == 1 ? "test" : "tests");
    report_skipped(h, all_skip);
    fprintf(h->fp, " in %u out of %u %s",
	    grps_lose, grps_run, grps_run == 1 ? "group" : "groups");
    report_skipped(h, grps_skip);
  }
  fputc('\n', h->fp);

  if (tv->f&TVSF_ERROR) {
    setattr(h, HA_ERR); fputs("ERRORS", h->fp); setattr(h, 0);
    fputs(" found in input; tests may not have run correctly\n", h->fp);
  }

  return (tv->f&TVSF_ERROR ? 2 : tv->all[TVOUT_LOSE] ? 1 : 0);
}

static void human_bgroup(struct tvec_output *o)
{
  struct human_output *h = (struct human_output *)o;

  h->maxlen = register_maxnamelen(h->_o.tv);
  dstr_reset(&h->scoreboard); show_progress(h);
}

static void human_grpsumm(struct human_output *h, unsigned outcome)
{
  struct tvec_state *tv = h->_o.tv;
  unsigned win = tv->curr[TVOUT_WIN], lose = tv->curr[TVOUT_LOSE],
    skip = tv->curr[TVOUT_SKIP], run = win + lose;

  if (lose) {
    assert(outcome == TVOUT_LOSE);
    fprintf(h->fp, " %u/%u ", lose, run);
    setattr(h, HA_LOSE); fputs("FAILED", h->fp); setattr(h, 0);
    report_skipped(h, skip);
  } else {
    assert(outcome == TVOUT_WIN);
    fputc(' ', h->fp); setattr(h, HA_WIN); fputs("ok", h->fp); setattr(h, 0);
    report_skipped(h, skip);
  }
  fputc('\n', h->fp);
}

static void human_egroup(struct tvec_output *o, unsigned outcome)
{
  struct human_output *h = (struct human_output *)o;

  if (h->f&HOF_TTY) h->f &= ~HOF_PROGRESS;
  else fprintf(h->fp, "%s:", h->_o.tv->test->name);
  human_grpsumm(h, outcome);
}

static void human_skipgroup(struct tvec_output *o,
			    const char *excuse, va_list *ap)
{
  struct human_output *h = (struct human_output *)o;

  if (!(~h->f&(HOF_TTY | HOF_PROGRESS))) {
    h->f &= ~HOF_PROGRESS;
    setattr(h, HA_SKIP); fputs("skipped", h->fp); setattr(h, 0);
  } else {
    fprintf(h->fp, "%s: ", h->_o.tv->test->name);
    setattr(h, HA_SKIP); fputs("skipped", h->fp); setattr(h, 0);
  }
  if (excuse) { fputs(": ", h->fp); vfprintf(h->fp, excuse, *ap); }
  fputc('\n', h->fp);
}

static void human_btest(struct tvec_output *o)
  { struct human_output *h = (struct human_output *)o; show_progress(h); }

static void human_skip(struct tvec_output *o,
		       const char *excuse, va_list *ap)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;

  clear_progress(h);
  report_location(h, h->fp, tv->infile, tv->test_lno);
  fprintf(h->fp, "`%s' ", tv->test->name);
  setattr(h, HA_SKIP); fputs("skipped", h->fp); setattr(h, 0);
  if (excuse) { fputs(": ", h->fp); vfprintf(h->fp, excuse, *ap); }
  fputc('\n', h->fp);
}

static void human_fail(struct tvec_output *o,
		       const char *detail, va_list *ap)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;

  clear_progress(h);
  report_location(h, h->fp, tv->infile, tv->test_lno);
  fprintf(h->fp, "`%s' ", tv->test->name);
  setattr(h, HA_LOSE); fputs("FAILED", h->fp); setattr(h, 0);
  if (detail) { fputs(": ", h->fp); vfprintf(h->fp, detail, *ap); }
  fputc('\n', h->fp);
}

static void human_dumpreg(struct tvec_output *o,
			  unsigned disp, const union tvec_regval *rv,
			  const struct tvec_regdef *rd)
{
  struct human_output *h = (struct human_output *)o;
  const char *ds = regdisp(disp); int n = strlen(ds) + strlen(rd->name);

  fprintf(h->fp, "%*s%s %s = ", 10 + h->maxlen - n, "", ds, rd->name);
  if (h->f&HOF_COLOUR) {
    if (!rv) setattr(h, HFG(YELLOW));
    else if (disp == TVRD_FOUND) setattr(h, HFG(RED));
    else if (disp == TVRD_EXPECT) setattr(h, HFG(GREEN));
  }
  if (!rv) fprintf(h->fp, "#<unset>");
  else rd->ty->dump(rv, rd, 0, &file_printops, h->fp);
  setattr(h, 0); fputc('\n', h->fp);
}

static void human_etest(struct tvec_output *o, unsigned outcome)
{
  struct human_output *h = (struct human_output *)o;
  int ch;

  if (h->f&HOF_TTY) {
    show_progress(h);
    switch (outcome) {
      case TVOUT_WIN: ch = '.'; break;
      case TVOUT_LOSE: ch = 'x'; break;
      case TVOUT_SKIP: ch = '_'; break;
      default: abort();
    }
    dstr_putc(&h->scoreboard, ch);
    write_scoreboard_char(h, ch); fflush(h->fp);
  }
}

static void human_bbench(struct tvec_output *o,
			 const char *ident, unsigned unit)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;

  clear_progress(h);
  fprintf(h->fp, "%s: %s: ", tv->test->name, ident); fflush(h->fp);
}

static void human_ebench(struct tvec_output *o,
			 const char *ident, unsigned unit,
			 const struct bench_timing *tm)
{
  struct human_output *h = (struct human_output *)o;
  tvec_benchreport(&file_printops, h->fp, unit, tm); fputc('\n', h->fp);
}

static void human_destroy(struct tvec_output *o)
{
  struct human_output *h = (struct human_output *)o;

  if (h->f&HOF_DUPERR) fclose(h->fp);
  dstr_destroy(&h->scoreboard);
  xfree(h);
}

static const struct tvec_outops human_ops = {
  human_report, human_report,
  human_bsession, human_esession,
  human_bgroup, human_egroup, human_skipgroup,
  human_btest, human_skip, human_fail, human_dumpreg, human_etest,
  human_bbench, human_ebench,
  human_destroy
};

struct tvec_output *tvec_humanoutput(FILE *fp)
{
  struct human_output *h;
  const char *p;

  h = xmalloc(sizeof(*h)); h->_o.ops = &human_ops;
  h->f = 0; h->attr = 0;

  h->fp = fp;

  switch (getenv_boolean("TVEC_TTY", -1)) {
    case 1: h->f |= HOF_TTY; break;
    case 0: break;
    default:
      if (isatty(fileno(fp))) h->f |= HOF_TTY;
      break;
  }
  switch (getenv_boolean("TVEC_COLOUR", -1)) {
    case 1: h->f |= HOF_COLOUR; break;
    case 0: break;
    default:
      if (h->f&HOF_TTY) {
	p = getenv("TERM");
	if (p && STRCMP(p, !=, "dumb")) h->f |= HOF_COLOUR;
      }
      break;
  }

  if (fp != stderr && (fp != stdout || !(h->f&HOF_TTY))) h->f |= HOF_DUPERR;
  dstr_create(&h->scoreboard);
  return (&h->_o);
}

/*----- Perl's `Test Anything Protocol' -----------------------------------*/

struct tap_output {
  struct tvec_output _o;
  FILE *fp;
  dstr d;
  int maxlen;
  unsigned f;
#define TOF_FRESHLINE 1u
};

static void tap_report(struct tap_output *t, const char *msg, va_list *ap)
{
  struct tvec_state *tv = t->_o.tv;

  if (tv->infile) fprintf(t->fp, "%s:%u: ", tv->infile, tv->lno);
  vfprintf(t->fp, msg, *ap); fputc('\n', t->fp);
}

static void tap_error(struct tvec_output *o, const char *msg, va_list *ap)
{
  struct tap_output *t = (struct tap_output *)o;
  fputs("Bail out!  ", t->fp); tap_report(t, msg, ap);
}

static void tap_notice(struct tvec_output *o, const char *msg, va_list *ap)
{
  struct tap_output *t = (struct tap_output *)o;
  fputs("## ", t->fp); tap_report(t, msg, ap);
}

static int tap_writech(void *go, int ch)
{
  struct tap_output *t = go;

  if (t->f&TOF_FRESHLINE) {
    if (fputs("## ", t->fp) < 0) return (-1);
    t->f &= ~TOF_FRESHLINE;
  }
  if (putc(ch, t->fp) < 0) return (-1);
  if (ch == '\n') t->f |= TOF_FRESHLINE;
  return (1);
}

static int tap_writem(void *go, const char *p, size_t sz)
{
  struct tap_output *t = go;
  const char *q, *l = p + sz;
  size_t n;

  if (p == l) return (0);
  if (t->f&TOF_FRESHLINE)
    if (fputs("## ", t->fp) < 0) return (-1);
  for (;;) {
    q = memchr(p, '\n', l - p); if (!q) break;
    n = q + 1 - p; if (fwrite(p, 1, n, t->fp) < n) return (-1);
    p = q + 1;
    if (p == l) { t->f |= TOF_FRESHLINE; return (sz); }
    if (fputs("## ", t->fp) < 0) return (-1);
  }
  n = l - p; if (fwrite(p, 1, n, t->fp) < n) return (-1);
  t->f &= ~TOF_FRESHLINE; return (0);
}

static int tap_nwritef(void *go, size_t maxsz, const char *p, ...)
{
  struct tap_output *t = go;
  va_list ap;
  int n;

  va_start(ap, p); DRESET(&t->d); DENSURE(&t->d, maxsz + 1);
#ifdef HAVE_SNPRINTF
  n = vsnprintf(t->d.buf, maxsz + 1, p, ap);
#else
  n = vsprintf(t->d.buf, p, ap);
#endif
  assert(0 <= n && n <= maxsz);
  va_end(ap);
  return (tap_writem(t, t->d.buf, n));
}

static const struct gprintf_ops tap_printops =
  { tap_writech, tap_writem, tap_nwritef };

static void tap_bsession(struct tvec_output *o) { ; }

static unsigned tap_grpix(struct tap_output *t)
{
  struct tvec_state *tv = t->_o.tv;

  return (tv->grps[TVOUT_WIN] +
	  tv->grps[TVOUT_LOSE] +
	  tv->grps[TVOUT_SKIP]);
}

static int tap_esession(struct tvec_output *o)
{
  struct tap_output *t = (struct tap_output *)o;
  struct tvec_state *tv = t->_o.tv;

  if (tv->f&TVSF_ERROR) {
    fputs("Bail out!  "
	  "Errors found in input; tests may not have run correctly\n",
	  t->fp);
    return (2);
  }

  fprintf(t->fp, "1..%u\n", tap_grpix(t));
  return (tv->all[TVOUT_LOSE] ? 1 : 0);
}

static void tap_bgroup(struct tvec_output *o)
{
  struct tap_output *t = (struct tap_output *)o;
  t->maxlen = register_maxnamelen(t->_o.tv);
}

static void tap_egroup(struct tvec_output *o, unsigned outcome)
{
  struct tap_output *t = (struct tap_output *)o;
  struct tvec_state *tv = t->_o.tv;
  unsigned
    grpix = tap_grpix(t),
    win = tv->curr[TVOUT_WIN],
    lose = tv->curr[TVOUT_LOSE],
    skip = tv->curr[TVOUT_SKIP];

  if (lose) {
    assert(outcome == TVOUT_LOSE);
    fprintf(t->fp, "not ok %u %s: FAILED %u/%u",
	    grpix, tv->test->name, lose, win + lose);
    if (skip) fprintf(t->fp, " (skipped %u)", skip);
  } else {
    assert(outcome == TVOUT_WIN);
    fprintf(t->fp, "ok %u %s: passed %u", grpix, tv->test->name, win);
    if (skip) fprintf(t->fp, " (skipped %u)", skip);
  }
  fputc('\n', t->fp);
}

static void tap_skipgroup(struct tvec_output *o,
			  const char *excuse, va_list *ap)
{
  struct tap_output *t = (struct tap_output *)o;

  fprintf(t->fp, "ok %u %s # SKIP", tap_grpix(t), t->_o.tv->test->name);
  if (excuse)
    { fputc(' ', t->fp); vfprintf(t->fp, excuse, *ap); }
  fputc('\n', t->fp);
}

static void tap_btest(struct tvec_output *o) { ; }

static void tap_skip(struct tvec_output *o, const char *excuse, va_list *ap)
{
  struct tap_output *t = (struct tap_output *)o;
  struct tvec_state *tv = t->_o.tv;

  fprintf(t->fp, "## %s:%u: `%s' skipped",
	  tv->infile, tv->test_lno, tv->test->name);
  if (excuse) { fputs(": ", t->fp); vfprintf(t->fp, excuse, *ap); }
  fputc('\n', t->fp);
}

static void tap_fail(struct tvec_output *o, const char *detail, va_list *ap)
{
  struct tap_output *t = (struct tap_output *)o;
  struct tvec_state *tv = t->_o.tv;

  fprintf(t->fp, "## %s:%u: `%s' FAILED",
	  tv->infile, tv->test_lno, tv->test->name);
  if (detail) { fputs(": ", t->fp); vfprintf(t->fp, detail, *ap); }
  fputc('\n', t->fp);
}

static void tap_dumpreg(struct tvec_output *o,
			unsigned disp, const union tvec_regval *rv,
			const struct tvec_regdef *rd)
{
  struct tap_output *t = (struct tap_output *)o;
  const char *ds = regdisp(disp); int n = strlen(ds) + strlen(rd->name);

  fprintf(t->fp, "## %*s%s %s = ", 10 + t->maxlen - n, "", ds, rd->name);
  if (!rv)
    fprintf(t->fp, "#<unset>\n");
  else {
    t->f &= ~TOF_FRESHLINE;
    rd->ty->dump(rv, rd, 0, &tap_printops, t);
    fputc('\n', t->fp);
  }
}

static void tap_etest(struct tvec_output *o, unsigned outcome) { ; }

static void tap_bbench(struct tvec_output *o,
		       const char *ident, unsigned unit)
  { ; }

static void tap_ebench(struct tvec_output *o,
		       const char *ident, unsigned unit,
		       const struct bench_timing *tm)
{
  struct tap_output *t = (struct tap_output *)o;
  struct tvec_state *tv = t->_o.tv;

  fprintf(t->fp, "## %s: %s: ", tv->test->name, ident);
  t->f &= ~TOF_FRESHLINE; tvec_benchreport(&tap_printops, t, unit, tm);
  fputc('\n', t->fp);
}

static void tap_destroy(struct tvec_output *o)
{
  struct tap_output *t = (struct tap_output *)o;

  if (t->fp != stdout && t->fp != stderr) fclose(t->fp);
  dstr_destroy(&t->d);
  xfree(t);
}

static const struct tvec_outops tap_ops = {
  tap_error, tap_notice,
  tap_bsession, tap_esession,
  tap_bgroup, tap_egroup, tap_skipgroup,
  tap_btest, tap_skip, tap_fail, tap_dumpreg, tap_etest,
  tap_bbench, tap_ebench,
  tap_destroy
};

struct tvec_output *tvec_tapoutput(FILE *fp)
{
  struct tap_output *t;

  t = xmalloc(sizeof(*t)); t->_o.ops = &tap_ops;
  dstr_create(&t->d);
  t->f = 0; t->fp = fp;
  return (&t->_o);
}

/*----- Default output ----------------------------------------------------*/

struct tvec_output *tvec_dfltout(FILE *fp)
{
  int ttyp = getenv_boolean("TVEC_TTY", -1);

  if (ttyp == -1) ttyp = isatty(fileno(fp));
  if (ttyp) return (tvec_humanoutput(fp));
  else return (tvec_tapoutput(fp));
}

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