@@@ adjust bench timings

[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 <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 --------------------------------------------------*/

enum { INPUT, OUTPUT, MATCH, EXPECT, FOUND };
struct mismatchfns {
  void (*report_status)(unsigned /*disp*/, int /*st*/,
			struct tvec_state */*tv*/);
  void (*report_register)(unsigned /*disp*/,
			  const struct tvec_reg */*r*/,
			  const struct tvec_regdef */*rd*/,
			  struct tvec_state */*tv*/);
};

static const char *stdisp(unsigned disp)
{
  switch (disp) {
    case MATCH: return "final";
    case EXPECT: return "expected";
    case FOUND: return "actual";
    default: abort();
  }
}

static const char *regdisp(unsigned disp)
{
  switch (disp) {
    case INPUT: return "input";
    case OUTPUT: return "output";
    case MATCH: return "matched";
    case EXPECT: return "expected";
    case FOUND: return "computed";
    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, ==, "nil") || STRCMP(p, ==, "off") ||
	   STRCMP(p, ==, "0"))
    return (0);
  else {
    moan("unexpected value `%s' for boolean environment variable `%s'",
	 var, p);
    return (dflt);
  }
}

static void basic_report_status(unsigned disp, int st, struct tvec_state *tv)
  { tvec_write(tv, "  %8s status = `%c'\n", stdisp(disp), st); }

static void basic_report_register(unsigned disp,
				  const struct tvec_reg *r,
				  const struct tvec_regdef *rd,
				  struct tvec_state *tv)
{
  tvec_write(tv, "  %8s %s = ", regdisp(disp), rd->name);
  if (r->f&TVRF_LIVE) rd->ty->dump(&r->v, rd, tv, 0);
  else tvec_write(tv, "#<unset>");
  tvec_write(tv, "\n");
}

static const struct mismatchfns basic_mismatchfns =
  { basic_report_status, basic_report_register };

static void dump_inreg(const struct tvec_regdef *rd,
		       const struct mismatchfns *fns, struct tvec_state *tv)
  { fns->report_register(INPUT, TVEC_REG(tv, in, rd->i), rd, tv); }

static void dump_outreg(const struct tvec_regdef *rd,
			const struct mismatchfns *fns, struct tvec_state *tv)
{
  const struct tvec_reg
    *rin = TVEC_REG(tv, in, rd->i), *rout = TVEC_REG(tv, out, rd->i);

  if (tv->st == '.') {
    if (!(rout->f&TVRF_LIVE)) {
      if (!(rin->f&TVRF_LIVE))
	fns->report_register(INPUT, rin, rd, tv);
      else {
	fns->report_register(FOUND, rout, rd, tv);
	fns->report_register(EXPECT, rin, rd, tv);
      }
    } else {
      if (!(rin->f&TVRF_LIVE)) fns->report_register(OUTPUT, rout, rd, tv);
      else if (rd->ty->eq(&rin->v, &rout->v, rd))
	fns->report_register(MATCH, rin, rd, tv);
      else {
	fns->report_register(FOUND, rout, rd, tv);
	fns->report_register(EXPECT, rin, rd, tv);
      }
    }
  }
}

static void mismatch(const struct mismatchfns *fns, struct tvec_state *tv)
{
  const struct tvec_regdef *rd;

  if (tv->st != tv->expst) {
    fns->report_status(FOUND, tv->st, tv);
    fns->report_status(EXPECT, tv->expst, tv);
  } else if (tv->st != '.')
    fns->report_status(MATCH, tv->st, tv);

  for (rd = tv->test->regs; rd->name; rd++) {
    if (rd->i < tv->nrout) dump_outreg(rd, fns, tv);
    else dump_inreg(rd, fns, tv);
  }
}

static void bench_summary(struct tvec_state *tv)
{
  const struct tvec_regdef *rd;
  unsigned f = 0;
#define f_any 1u

  for (rd = tv->test->regs; rd->name; rd++)
    if (rd->f&TVRF_ID) {
      if (f&f_any) tvec_write(tv, ", ");
      else f |= f_any;
      tvec_write(tv, "%s = ", rd->name);
      rd->ty->dump(&TVEC_REG(tv, in, rd->i)->v, rd, tv, TVSF_COMPACT);
    }

#undef f_any
}

static void normalize(double *x_inout, const char **unit_out, double scale)
{
  static const char
    *const nothing = "",
    *const big[] = { "k", "M", "G", "T", "P", "E", 0 },
    *const little[] = { "m", "µ", "n", "p", "f", "a", 0 };
  const char *const *u;
  double x = *x_inout;

  if (x < 1)
    for (u = little, x *= scale; x < 1 && u[1]; u++, x *= scale);
  else if (x >= scale)
    for (u = big, x /= scale; x >= scale && u[1]; u++, x /= scale);
  else
    u = &nothing;

  *x_inout = x; *unit_out = *u;
}

static void bench_report(struct tvec_state *tv,
			 const struct bench_timing *tm)
{
  const struct tvec_bench *b = tv->test->arg.p;
  double n = (double)tm->n*b->niter;
  double x, scale;
  const char *u, *what, *whats;

  assert(tm->f&BTF_TIMEOK);

  if (b->rbuf == -1) {
    tvec_write(tv, " -- %.0f iterations ", n);
    what = "op"; whats = "ops"; scale = 1000;
  } else {
    n *= TVEC_REG(tv, in, b->rbuf)->v.bytes.sz;
    x = n; normalize(&x, &u, 1024); tvec_write(tv, " -- %.3f %sB ", x, u);
    what = whats = "B"; scale = 1024;
  }
  x = tm->t; normalize(&x, &u, 1000);
  tvec_write(tv, "in %.3f %ss", x, u);
  if (tm->f&BTF_CYOK) {
    x = tm->cy; normalize(&x, &u, 1000);
    tvec_write(tv, " (%.3f %scy)", x, u);
  }
  tvec_write(tv, ": ");

  x = n/tm->t; normalize(&x, &u, scale);
  tvec_write(tv, "%.3f %s%s/s", x, u, whats);
  x = tm->t/n; normalize(&x, &u, 1000);
  tvec_write(tv, ", %.3f %ss/%s", x, u, what);
  if (tm->f&BTF_CYOK) {
    x = tm->cy/n; normalize(&x, &u, 1000);
    tvec_write(tv, " (%.3f %scy/%s)", x, u, what);
  }
  tvec_write(tv, "\n");
}

/*----- 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 ..._write(struct tvec_output *o, const char *p, size_t sz)
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 *detail, va_list *ap)
static void ..._fail(struct tvec_output *o, const char *detail, va_list *ap)
static void ..._mismatch(struct tvec_output *o)
static void ..._etest(struct tvec_output *o, unsigned outcome)
static void ..._bbench(struct tvec_output *o)
static void ..._ebench(struct tvec_output *o, const struct tvec_timing *t)
static void ..._destroy(struct tvec_output *o)

static const struct tvec_outops ..._ops = {
  ..._error, ..._notice, ..._write,
  ..._bsession, ..._esession,
  ..._bgroup, ..._egroup, ..._skip,
  ..._btest, ..._skip, ..._fail, ..._mismatch, ..._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;
  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;

  clear_progress(h); fflush(h->fp);
  fprintf(stderr, "%s: ", QUIS);
  report_location(h, stderr, tv->infile, tv->lno);
  vfprintf(stderr, msg, *ap);
  fputc('\n', stderr);

  if (h->f&HOF_DUPERR) {
    report_location(h, stderr, tv->infile, tv->lno);
    vfprintf(h->fp, msg, *ap);
    fputc('\n', h->fp);
  }
  show_progress(h);
}

static void human_write(struct tvec_output *o, const char *p, size_t sz)
{
  struct human_output *h = (struct human_output *)o;
  fwrite(p, 1, sz, h->fp);
}

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;
  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 set_dispattr(struct human_output *h, unsigned disp)
{
  switch (disp) {
    case EXPECT: setattr(h, HFG(GREEN)); break;
    case FOUND: setattr(h, HFG(RED)); break;
    default: setattr(h, 0); break;
  }
}

static void human_report_status(unsigned disp, int st, struct tvec_state *tv)
{
  struct human_output *h = (struct human_output *)tv->output;

  fprintf(h->fp, "  %8s status = ", stdisp(disp));
  set_dispattr(h, disp); fprintf(h->fp, "`%c'", st); setattr(h, 0);
  fputc('\n', h->fp);
}

static void human_report_register(unsigned disp,
				  const struct tvec_reg *r,
				  const struct tvec_regdef *rd,
				  struct tvec_state *tv)
{
  struct human_output *h = (struct human_output *)tv->output;

  fprintf(h->fp, "  %8s %s = ", regdisp(disp), rd->name);
  if (!(r->f&TVRF_LIVE))
    tvec_write(tv, "#<unset>");
  else {
    set_dispattr(h, disp);
    rd->ty->dump(&r->v, rd, tv, 0);
    setattr(h, 0);
  }
  tvec_write(tv, "\n");
}

static const struct mismatchfns human_mismatchfns =
  { human_report_status, human_report_register };

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

  if (h->f&HOF_COLOUR) mismatch(&human_mismatchfns, h->_o.tv);
  else mismatch(&basic_mismatchfns, h->_o.tv);
}

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)
{
  struct human_output *h = (struct human_output *)o;
  struct tvec_state *tv = h->_o.tv;

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

static void human_ebench(struct tvec_output *o,
			 const struct bench_timing *tm)
{
  struct human_output *h = (struct human_output *)o;
  bench_report(h->_o.tv, tm);
}

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_write,
  human_bsession, human_esession,
  human_bgroup, human_egroup, human_skipgroup,
  human_btest, human_skip, human_fail, human_mismatch, 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;
  if (fp != stdout && fp != stderr) h->f |= HOF_DUPERR;

  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;
  }

  dstr_create(&h->scoreboard);
  return (&h->_o);
}

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

struct tap_output {
  struct tvec_output _o;
  FILE *fp;
  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 void tap_write(struct tvec_output *o, const char *p, size_t sz)
{
  struct tap_output *t = (struct tap_output *)o;
  const char *q, *l = p + sz;

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

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) { ; }

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_mismatch(struct tvec_output *o)
  { mismatch(&basic_mismatchfns, o->tv); }

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

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

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

  tvec_write(tv, "%s: ", tv->test->name); bench_summary(tv);
  bench_report(tv, tm);
}

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);
  xfree(t);
}

static const struct tvec_outops tap_ops = {
  tap_error, tap_notice, tap_write,
  tap_bsession, tap_esession,
  tap_bgroup, tap_egroup, tap_skipgroup,
  tap_btest, tap_skip, tap_fail, tap_mismatch, 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;
  t->f = TOF_FRESHLINE;
  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 -------------------------------------------------*/