diff --git a/t/t_rfc4648.c b/t/t_rfc4648.c
index 3f14d71..a9991e1 100644
--- a/t/t_rfc4648.c
+++ b/t/t_rfc4648.c
@@ -33,7 +33,7 @@
 # include "config.h"
 #endif
 
-#include <err.h>
+#include <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -44,194 +44,163 @@
 
 #include "t.h"
 
-/*
- * Test vectors from RFC 4648
- */
-static struct t_vector {
-	const char *plain;
-/*	const char *base16; */
-	const char *base32;
-	const char *base64;
-} t_vectors[] = {
-	{
-		.plain	= "",
-		.base32	= "",
-		.base64	= "",
-	},
-	{
-		.plain	= "f",
-		.base32	= "MY======",
-		.base64	= "Zg=="
-	},
-	{
-		.plain	= "fo",
-		.base32	= "MZXQ====",
-		.base64	= "Zm8=",
-	},
-	{
-		.plain	= "foo",
-		.base32	= "MZXW6===",
-		.base64	= "Zm9v",
-	},
-	{
-		.plain	= "foob",
-		.base32	= "MZXW6YQ=",
-		.base64	= "Zm9vYg==",
-	},
-	{
-		.plain	= "fooba",
-		.base32	= "MZXW6YTB",
-		.base64	= "Zm9vYmE=",
-	},
-	{
-		.plain	= "foobar",
-		.base32	= "MZXW6YTBOI======",
-		.base64	= "Zm9vYmFy",
-	},
+struct t_case {
+	const char *desc;
+	int (*func)(const char *, size_t, char *, size_t *);
+	const char *in;		/* input string  */
+	size_t ilen;		/* input length */
+	const char *out;	/* expected output string or NULL */
+	size_t blen;		/* initial value for olen or 0*/
+	size_t olen;		/* expected value for olen */
+	int ret;		/* expected return value */
+	int err;		/* expected errno if ret != 0 */
+};
+
+/* basic encoding / decoding */
+#define T_ENCODE_N(N, i, o)						\
+	{ "base"#N"_enc("#i")", base##N##_enc, i, sizeof i - 1,		\
+	  o, sizeof o, sizeof o, 0, 0 }
+#define T_DECODE_N(N, i, o)						\
+	{ "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1,		\
+	  o, sizeof o - 1, sizeof o - 1, 0, 0 }
+#define T_ENCODE(p, b32, b64)						\
+	T_ENCODE_N(32, p, b32), T_ENCODE_N(64, p, b64)
+#define T_DECODE(p, b32, b64)						\
+	T_DECODE_N(32, b32, p), T_DECODE_N(64, b64, p)
+
+/* roundtrip encoding tests */
+#define T_ENCDEC(p, b32, b64)						\
+	T_ENCODE(p, b32, b64), T_DECODE(p, b32, b64)
+
+/* decoding failure */
+#define T_DECODE_FAIL_N(N, i, e)					\
+	{ "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1,		\
+	  NULL, 0, 0, -1, e }
+#define T_DECODE_FAIL(e, b32, b64)					\
+	T_DECODE_FAIL_N(32, b32, e), T_DECODE_FAIL_N(64, b64, e)
+
+/* input string shorter than input length */
+#define T_SHORT_INPUT_DEC(N, i)						\
+	{ "base"#N"_dec (short input)", base##N##_dec, i, sizeof i + 2, \
+	  NULL, 0, base##N##_declen(sizeof i - 1), 0, 0 }
+#define T_SHORT_INPUT()							\
+	T_SHORT_INPUT_DEC(32, "AAAAAAAA"),				\
+	T_SHORT_INPUT_DEC(64, "AAAA")
+
+/* output string longer than output length */
+#define T_LONG_OUTPUT_ENC(N, i)						\
+	{ "base"#N"_enc (long output)", base##N##_enc, i, sizeof i - 1,	\
+	  NULL, 1, base##N##_enclen(sizeof i - 1) + 1, -1, ENOSPC }
+#define T_LONG_OUTPUT_DEC(N, i)						\
+	{ "base"#N"_dec (long output)", base##N##_dec, "AAAAAAAA", 8,	\
+	  NULL, 1, base##N##_declen(sizeof i - 1), -1, ENOSPC }
+#define T_LONG_OUTPUT()							\
+	T_LONG_OUTPUT_ENC(32, "foo"),					\
+	T_LONG_OUTPUT_DEC(32, "AAAAAAAA"),				\
+	T_LONG_OUTPUT_ENC(64, "foo"),					\
+	T_LONG_OUTPUT_DEC(64, "AAAA")
+
+static struct t_case t_cases[] = {
+	/* test vectors from RFC 4648 */
+	/*	 plain		base32			base64 */
+	T_ENCDEC("",		"",			""),
+	T_ENCDEC("f",		"MY======",		"Zg=="),
+	T_ENCDEC("fo",		"MZXQ====",		"Zm8="),
+	T_ENCDEC("foo",		"MZXW6===",		"Zm9v"),
+	T_ENCDEC("foob",	"MZXW6YQ=",		"Zm9vYg=="),
+	T_ENCDEC("fooba",	"MZXW6YTB",		"Zm9vYmE="),
+	T_ENCDEC("foobar",	"MZXW6YTBOI======",	"Zm9vYmFy"),
+
+	/* zeroes */
+	T_ENCDEC("\0\0\0",	"AAAAA===",		"AAAA"),
+
+	/* sloppy padding */
+	T_DECODE("f",		"MY=",			"Zg="),
+	T_DECODE("f",		"MY",			"Zg"),
+
+	/* whitespace */
+	/*	 plain		base32			base64 */
+	T_DECODE("tst",		"ORZX I===",		"dH N0"),
+	T_DECODE("tst",		"ORZX\tI===",		"dH\tN0"),
+	T_DECODE("tst",		"ORZX\rI===",		"dH\rN0"),
+	T_DECODE("tst",		"ORZX\nI===",		"dH\nN0"),
+
+	/* invalid character in data */
+	T_DECODE_FAIL(EINVAL,	"AA!AAAAAA",		"AA!A"),
+
+	/* invalid character in padding */
+	T_DECODE_FAIL(EINVAL,	"AAAAA==!",		"AA=!"),
+
+	/* padding with no data */
+	T_DECODE_FAIL(EINVAL,	"AAAAAAAA=",		"AAAA="),
+
+	/* data after padding */
+	T_DECODE_FAIL(EINVAL,	"AA=A",			"AA=A"),
+
+	/* padding in incorrect location */
+	T_DECODE_FAIL(EINVAL,	"A=",			"A="),
+
+	/* various error conditions */
+	T_SHORT_INPUT(),
+	T_LONG_OUTPUT(),
 };
 
 /*
  * Encoding test function
  */
 static int
-t_rfc4648_enc(const char *plain, const char *encoded,
-    int (*enc)(const char *, size_t, char *, size_t *))
+t_rfc4648(void *arg)
 {
+	struct t_case *t = arg;
 	char buf[64];
-	size_t blen, ilen, olen;
+	size_t len;
+	int ret;
 
-	blen = sizeof buf;
-	ilen = strlen(plain);
-	olen = strlen(encoded) + 1;
-	if (enc((const char *)plain, ilen, buf, &blen) != 0) {
-		t_verbose("encoding failed\n");
+	len = t->blen ? t->blen : sizeof buf;
+	ret = t->func(t->in, t->ilen, buf, &len);
+	if (ret != t->ret) {
+		t_verbose("expected return code %d, got %d\n",
+		    t->ret, ret);
 		return (0);
 	}
-	if (blen != olen) {
-		t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, encoded, (int)blen, buf);
-		t_verbose("expected %zu B got %zu B\n", olen, blen);
+	if (t->out && len != t->olen) {
+		t_verbose("expected output length %zu, got %zu\n",
+		    t->olen, len);
 		return (0);
 	}
-	if (strncmp(buf, encoded, blen) != 0) {
-		t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, encoded, (int)blen, buf);
+	if (t->ret != 0 && errno != t->err) {
+		t_verbose("expected errno %d, got %d\n",
+		    t->err, errno);
+		return (0);
+	}
+	if (t->ret == 0 && t->out && strncmp(buf, t->out, len) != 0) {
+		t_verbose("expected '%.*s' got '%.*s'\n",
+		    (int)t->olen, t->out, (int)len, buf);
 		return (0);
 	}
 	return (1);
 }
 
-/*
- * Encoding test wrapper for base 32
- */
-static int
-t_base32_enc(void *arg)
-{
-	struct t_vector *tv = (struct t_vector *)arg;
-
-	return (t_rfc4648_enc(tv->plain, tv->base32, base32_enc));
-}
-
-/*
- * Encoding test wrapper for base 64
- */
-static int
-t_base64_enc(void *arg)
-{
-	struct t_vector *tv = (struct t_vector *)arg;
-
-	return (t_rfc4648_enc(tv->plain, tv->base64, base64_enc));
-}
-
-/*
- * Decoding test function
- */
-static int
-t_rfc4648_dec(const char *encoded, const char *plain,
-    int (*dec)(const char *, size_t, char *, size_t *))
-{
-	char buf[64];
-	size_t blen, ilen, olen;
-
-	blen = sizeof buf;
-	ilen = strlen(encoded);
-	olen = strlen(plain);
-	if (dec(encoded, ilen, buf, &blen) != 0) {
-		t_verbose("encoding failed\n");
-		return (0);
-	}
-	if (blen != olen) {
-		t_verbose("expected %zu B got %zu B\n", olen, blen);
-		return (0);
-	}
-	if (strncmp(buf, plain, blen) != 0) {
-		t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, plain, (int)blen, buf);
-		return (0);
-	}
-	return (1);
-}
-
-/*
- * Decoding test wrapper for base 32
- */
-static int
-t_base32_dec(void *arg)
-{
-	struct t_vector *tv = (struct t_vector *)arg;
-
-	return (t_rfc4648_dec(tv->base32, tv->plain, base32_dec));
-}
-
-/*
- * Decoding test wrapper for base 64
- */
-static int
-t_base64_dec(void *arg)
-{
-	struct t_vector *tv = (struct t_vector *)arg;
-
-	return (t_rfc4648_dec(tv->base64, tv->plain, base64_dec));
-}
-
-/*
- * Generate a test case for a given test vector
- */
-static struct t_test *
-t_create_test(int (*func)(void *), const char *name, struct t_vector *tv)
-{
-	struct t_test *test;
-	char *desc;
-
-	if ((test = calloc(1, sizeof *test)) == NULL)
-		return (NULL);
-	test->func = func;
-	if ((desc = calloc(1, strlen(name) + strlen(tv->plain) + 5)) == NULL)
-		return (NULL);
-	sprintf(desc, "%s(\"%s\")", name, tv->plain);
-	test->desc = desc;
-	test->arg = tv;
-	return (test);
-}
-
 /*
  * Generate the test plan
  */
 const struct t_test **
 t_prepare(int argc, char *argv[])
 {
-	struct t_test **plan, **test;
-	int n;
+	struct t_test **plan, *tests;
+	int i, n;
 
 	(void)argc;
 	(void)argv;
-	n = sizeof t_vectors / sizeof t_vectors[0];
-	plan = calloc(n * 4 + 1, sizeof *plan);
-	if (plan == NULL)
+	n = sizeof t_cases / sizeof t_cases[0];
+	if ((plan = calloc(n + 1, sizeof *plan)) == NULL ||
+	    (tests = calloc(n + 1, sizeof *tests)) == NULL)
 		return (NULL);
-	test = plan;
-	for (int i = 0; i < n; ++i) {
-		*test++ = t_create_test(t_base32_enc, "BASE32ENC", &t_vectors[i]);
-		*test++ = t_create_test(t_base32_dec, "BASE32DEC", &t_vectors[i]);
-		*test++ = t_create_test(t_base64_enc, "BASE64ENC", &t_vectors[i]);
-		*test++ = t_create_test(t_base64_dec, "BASE64DEC", &t_vectors[i]);
+	for (i = 0; i < n; ++i) {
+		plan[i] = &tests[i];
+		tests[i].func = t_rfc4648;
+		tests[i].desc = t_cases[i].desc;
+		tests[i].arg = &t_cases[i];
 	}
 	return ((const struct t_test **)plan);
 }