@@@ fltfmt mess

[mLib] / struct / t / dstr-putf-test.c

/* -*-c-*-
 *
 * Test driver for universal hashing
 *
 * (c) 2009 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 <float.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "dstr.h"
#include "macros.h"
#include "report.h"

#include "tvec.h"
#include "tvec-adhoc.h"
#include "tvec-types.h"

/*----- Static variables --------------------------------------------------*/

static struct tvec_state tvstate;
static dstr d = DSTR_INIT;
static char strbuf[1024];

/*----- Utilities ---------------------------------------------------------*/

#define TESTGROUP(name) TVEC_TESTGROUP_TAG(grp, &tvstate, name)

static PRINTF_LIKE(1, 2) int format(const char *fmt, ...)
{
  va_list ap;
  int n;

  va_start(ap, fmt);
  dstr_reset(&d);
  n = dstr_vputf(&d, fmt, &ap);
  va_end(ap);
  return (n);
}

static PRINTF_LIKE(1, 2) void prepare(const char *fmt, ...)
{
  va_list ap;
  int n;

  va_start(ap, fmt);
#ifdef HAVE_SNPRINTF
  n = vsnprintf(strbuf, sizeof(strbuf), fmt, ap);
#else
  n = vsprintf(strbuf, fmt, ap);
#endif
  assert(0 <= n && n < sizeof(strbuf));
}

#define TEST_KNOWN(fmtargs, want) do {					\
  int n; n = format fmtargs;						\
  tvec_claimeq_int(&tvstate, n, strlen(want),				\
		   __FILE__, __LINE__, "format " #fmtargs);		\
  tvec_claimeq_text(&tvstate, d.buf, d.len, want, strlen(want),	\
		    __FILE__, __LINE__, "format " #fmtargs);	\
} while (0)

#define TEST_REF(fmtargs) do {						\
  int n = format fmtargs;						\
  prepare fmtargs;							\
  tvec_claimeq_int(&tvstate, n, strlen(strbuf),				\
		   __FILE__, __LINE__, "format " #fmtargs);		\
  tvec_claimeq_text(&tvstate, d.buf, d.len, strbuf, strlen(strbuf),	\
		    __FILE__, __LINE__, "format " #fmtargs);		\
} while (0)

#define LENGTHY								\
  "This is a rather longer string than the code is expecting: will it fit?"

/*----- Main program ------------------------------------------------------*/

int main(int argc, char *argv[])
{
  int argpos;

  tvec_parseargs(argc, argv, &tvstate, &argpos, &tvec_adhocconfig);
  if (argpos < argc) die(2, "no input files expected");
  tvec_adhoc(&tvstate);

  TESTGROUP("basics") {
    TEST_KNOWN(("Hello, world!"), "Hello, world!");
    TEST_KNOWN(("just a ->%%<- sign"), "just a ->%<- sign");
  }

  TESTGROUP("integers") {
    TEST_KNOWN(("Testing, testing, %d, %d, %d.", 1, 2, 3),
	       "Testing, testing, 1, 2, 3.");
    TEST_KNOWN(("->%5d<-", 138), "->  138<-");
    TEST_KNOWN(("->%*d<-", 5, 138), "->  138<-");
    TEST_KNOWN(("->%-*d<-", 5, 138), "->138  <-");
    TEST_KNOWN(("->%*d<-", -5, 138), "->138  <-");
    TEST_KNOWN(("->%-*d<-", -5, 138), "->138  <-");
  }

  TESTGROUP("strings") {
    TEST_KNOWN(("->%.*s<-", 5, "truncate me"), "->trunc<-");
    TEST_KNOWN(("->%.*s<-", -5, "don't truncate me"),
	       "->don't truncate me<-");
    TEST_KNOWN(("Truncation indirect: ->%.*s<-", 10,
		"a long string to be chopped"),
	       "Truncation indirect: ->a long str<-");
  }

  TESTGROUP("combinations") {
    TEST_KNOWN(("%08lx:%s", 0x65604204ul, "tripe-ec"), "65604204:tripe-ec");
    TEST_REF(("big float: ->%f<- and integer %d\n", DBL_MAX, 42));
  }

  TESTGROUP("argument-order") {
    TEST_KNOWN(("Testing, testing, %3$d, %2$d, %1$d.", 3, 2, 1),
	       "Testing, testing, 1, 2, 3.");
    TEST_KNOWN(("Truncation indirect: ->%1$.*2$s<-",
		"a long string to be chopped", 10),
	       "Truncation indirect: ->a long str<-");
  }

  TESTGROUP("misc")
    TEST_KNOWN(("%s", LENGTHY), LENGTHY);

  return (tvec_end(&tvstate));
}

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