424aaa7 Still rearranging the test programs — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Still rearranging the test programs

Matthew Seaman committed 12 years ago

commit 424aaa75b7a22cda4a5c4d31b293fb6a3bb6c214
parent a4809d5

4 files changed +2232 -2145

modified tests/lib/Atffile

@@ -5,4 +5,4 @@ prop: test-suite = lib

 #tp: pkg
 #tp: manifest
 tp: test
 tp: pkg_printf
 tp: pp_test

modified tests/lib/Makefile

@@ -1,12 +1,19 @@

 TESTS=	test pkg_printf
 TESTS=	test pp_test
 SRCS=		tests.h
 test_SRCS=	manifest.c	\
 		pkg.c
 CFLAGS+=	-I../../libpkg
 pp_test_SRCS=	pkg_printf.c
 CFLAGS+=	-DTESTING -I../../libpkg
 LDADD+=		-Wl,-rpath ${.CURDIR}/../../libpkg \
 		-L../../libpkg	\
 		-lpkg
 CLEANFILES+=	pkg_printf.c
 pkg_printf.c:	../../libpkg/pkg_printf.c
 	ln -s ${.OODATE} ${.TARGET}
 .include "../bsd.tests.mk"

deleted tests/lib/pkg_printf.c

@@ -1,2142 +0,0 @@

 /*-
  * Copyright (c) 2012 Matthew Seaman <matthew@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <string.h>
 #include <atf-c.h>
 #include <pkg.h>
 #include <private/pkg_printf.h>
 ATF_TC(gen_format);
 ATF_TC_HEAD(gen_format, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Generate printf format code for final output");
 }
 ATF_TC_BODY(gen_format, tc)
 {
 	char		 buf[32];
 	unsigned	 i;
 	char		*tail = "x";
 	struct gf_test_vals {
 		const char *out;
 		unsigned    flags;
 	} gf_test_vals[] = {
 		{ "%*x",     0, },
 		{ "%*x",     PP_ALTERNATE_FORM1, }, /* Has no effect */
 		{ "%#*x",    PP_ALTERNATE_FORM2, },
 		{ "%-*x",    PP_LEFT_ALIGN, },
 		{ "%#-*x",   PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+*x",    PP_EXPLICIT_PLUS, },
 		{ "%#+*x",   PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "% *x",    PP_SPACE_FOR_PLUS, },
 		{ "%# *x",   PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- *x",   PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- *x",  PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+*x",    PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0*x",    PP_ZERO_PAD, },
 		{ "%#0*x",   PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
 		{ "%-*x",    PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "%#-*x",   PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
 		{ "%#0+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0 *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
 		{ "%#0 *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#0+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%'*x",    PP_THOUSANDS_SEP, },
 		{ "%#'*x",   PP_THOUSANDS_SEP|PP_ALTERNATE_FORM2, },
 		{ "%-'*x",   PP_THOUSANDS_SEP|PP_LEFT_ALIGN, },
 		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+'*x",   PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS, },
 		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "% '*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS, },
 		{ "%# '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- '*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+'*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD, },
 		{ "%#0'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
 		{ "%-'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
 		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0 '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
 		{ "%#0 '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ NULL, 0, },
 	};
 	for (i = 0; gf_test_vals[i].out != NULL; i++) {
 		ATF_CHECK_STREQ(gen_format(buf, sizeof(buf),
 					   gf_test_vals[i].flags, tail),
 				gf_test_vals[i].out);
 	}
 }
 ATF_TC(human_number);
 ATF_TC_HEAD(human_number, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing human_number() output routine");
 }
 ATF_TC_BODY(human_number, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct hn_test_vals {
 		int64_t	in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} hn_test_vals[] = {
 		{ 0,                   "0.00",   0, 0, },
 		{ 1,                   "1.00",   0, 0, },
 		{ 10,                  "10.0",   0, 0, },
 		{ 100,                 "100",    0, 0. },
 		{ 1000,                "1.00k",  0, 0, },
 		{ 10000,               "10.0k",  0, 0, },
 		{ 100000,              "100k",   0, 0, },
 		{ 1000000,             "1.00M",  0, 0, },
 		{ 1000000000,          "1.00G",  0, 0, },
 		{ 1000000000000,       "1.00T",  0, 0, },
 		{ 1000000000000000,    "1.00P",  0, 0, },
 		{ 1000000000000000000, "1.00E",  0, 0, },
 		{ 999,                 "999",    0, 0, },
 		{ 1001,                "1.00k",  0, 0, },
 		{ 1010,                "1.01k",  0, 0, },
 		{ 1490,                "1.49k",  0, 0, },
 		{ 1499,                "1.50k",  0, 0, },
 		{ 1500,                "1.50k",  0, 0, },
 		{ -1,                  "-1.00",  0, 0, },
 		{ -1234,               "-1.23k", 0, 0, },
 		{ -1234567,            "-1.23M", 0, 0, },
 		{ -1234567890,         "-1.23G", 0, 0, },
 		{ -1234567890123,      "-1.23T", 0, 0, },
 		{ -1234567890123456,   "-1.23P", 0, 0, },
 		{ -1234567890123456789,"-1.23E", 0, 0, },
 		{ 512,                 "512",    0, PP_ALTERNATE_FORM2, },
 		{ 1024,                "1.00Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 1536,                "1.50Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 24576,               "24.0Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 393216,              "384Ki",  0, PP_ALTERNATE_FORM2, },
 		{ 2359296,             "2.25Mi", 0, PP_ALTERNATE_FORM2, },
 		{ 3623878656,          "3.38Gi", 0, PP_ALTERNATE_FORM2, },
 		{ 5566277615616,       "5.06Ti", 0, PP_ALTERNATE_FORM2, },
 		{ 8549802417586176,    "7.59Pi", 0, PP_ALTERNATE_FORM2, },
 		{ 1313249651341236633, "1.14Ei", 0, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          0, 0, },
 		{ 123,     "123",          1, 0, },
 		{ 123,     "123",          2, 0, },
 		{ 123,     "123",          3, 0, },
 		{ 123,     " 123",         4, 0, },
 		{ 123,     "  123",        5, 0, },
 		{ 123,     "   123",       6, 0, },
 		{ 123,     "    123",      7, 0, },
 		{ 123,     "     123",     8, 0, },
 		{ 123,     "      123",    9, 0, },
 		{ 123,     " 123",         0, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         1, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         2, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         3, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         4, PP_SPACE_FOR_PLUS, },
 		{ 123,     "  123",        5, PP_SPACE_FOR_PLUS, },
 		{ 123,     "   123",       6, PP_SPACE_FOR_PLUS, },
 		{ 123,     "    123",      7, PP_SPACE_FOR_PLUS, },
 		{ 123,     "     123",     8, PP_SPACE_FOR_PLUS, },
 		{ 123,     "      123",    9, PP_SPACE_FOR_PLUS, },
 		{ -123,    "-123",         0, 0, },
 		{ -123,    "-123",         1, 0, },
 		{ -123,    "-123",         2, 0, },
 		{ -123,    "-123",         3, 0, },
 		{ -123,    "-123",         4, 0, },
 		{ -123,    " -123",        5, 0, },
 		{ -123,    "  -123",       6, 0, },
 		{ -123,    "   -123",      7, 0, },
 		{ -123,    "    -123",     8, 0, },
 		{ -123,    "     -123",    9, 0, },
 		{ 123,     "123",          0, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          1, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          2, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          3, PP_ALTERNATE_FORM2, },
 		{ 123,     " 123",         4, PP_ALTERNATE_FORM2, },
 		{ 123,     "  123",        5, PP_ALTERNATE_FORM2, },
 		{ 123,     "   123",       6, PP_ALTERNATE_FORM2, },
 		{ 123,     "    123",      7, PP_ALTERNATE_FORM2, },
 		{ 123,     "     123",     8, PP_ALTERNATE_FORM2, },
 		{ 123,     "      123",    9, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.23M",        0, 0, },
 		{ 1234567, "1M",           1, 0, },
 		{ 1234567, "1M",           2, 0, },
 		{ 1234567, " 1M",          3, 0, },
 		{ 1234567, "1.2M",         4, 0, },
 		{ 1234567, "1.23M",        5, 0, },
 		{ 1234567, " 1.23M",       6, 0, },
 		{ 1234567, "  1.23M",      7, 0, },
 		{ 1234567, "   1.23M",     8, 0, },
 		{ 1234567, "    1.23M",    9, 0, },
 		{ 12345678, "12.3M",       0, 0, },
 		{ 12345678, "12M",         1, 0, },
 		{ 12345678, "12M",         2, 0, },
 		{ 12345678, "12M",         3, 0, },
 		{ 12345678, " 12M",        4, 0, },
 		{ 12345678, "12.3M",       5, 0, },
 		{ 12345678, " 12.3M",      6, 0, },
 		{ 12345678, "  12.3M",     7, 0, },
 		{ 12345678, "   12.3M",    8, 0, },
 		{ 12345678, "    12.3M",   9, 0, },
 		{ 123456789, "123M",       0, 0, },
 		{ 123456789, "123M",       1, 0, },
 		{ 123456789, "123M",       2, 0, },
 		{ 123456789, "123M",       3, 0, },
 		{ 123456789, "123M",       4, 0, },
 		{ 123456789, " 123M",      5, 0, },
 		{ 123456789, "  123M",     6, 0, },
 		{ 123456789, "   123M",    7, 0, },
 		{ 123456789, "    123M",   8, 0, },
 		{ 123456789, "     123M",  9, 0, },
 		{ 1234567, "1.18Mi",       0, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          1, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          2, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          3, PP_ALTERNATE_FORM2, },
 		{ 1234567, " 1Mi",         4, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.2Mi",        5, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.18Mi",       6, PP_ALTERNATE_FORM2, },
 		{ 1234567, " 1.18Mi",      7, PP_ALTERNATE_FORM2, },
 		{ 1234567, "  1.18Mi",     8, PP_ALTERNATE_FORM2, },
 		{ 1234567, "   1.18Mi",    9, PP_ALTERNATE_FORM2, },
 		{ 12345678, "11.8Mi",      0, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        1, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        2, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        3, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        4, PP_ALTERNATE_FORM2, },
 		{ 12345678, " 12Mi",       5, PP_ALTERNATE_FORM2, },
 		{ 12345678, "11.8Mi",      6, PP_ALTERNATE_FORM2, },
 		{ 12345678, " 11.8Mi",     7, PP_ALTERNATE_FORM2, },
 		{ 12345678, "  11.8Mi",    8, PP_ALTERNATE_FORM2, },
 		{ 12345678, "   11.8Mi",   9, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      0, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      1, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      2, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      3, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      4, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      5, PP_ALTERNATE_FORM2, },
 		{ 123456789, " 118Mi",     6, PP_ALTERNATE_FORM2, },
 		{ 123456789, "  118Mi",    7, PP_ALTERNATE_FORM2, },
 		{ 123456789, "   118Mi",   8, PP_ALTERNATE_FORM2, },
 		{ 123456789, "    118Mi",  9, PP_ALTERNATE_FORM2, },
 		{  1234567, "1.23M",  0, PP_ALTERNATE_FORM1, },
 		{  1234567, "1.18Mi", 0, PP_ALTERNATE_FORM2, },
 		{  1234567, "1.23 M", 6, PP_LEFT_ALIGN, },
 		{  1234567, "+1.23M", 0, PP_EXPLICIT_PLUS, },
 		{ -1234567, "-1.23M", 0, PP_EXPLICIT_PLUS, },
 		{  1234567, " 1.23M", 0, PP_SPACE_FOR_PLUS, },
 		{ -1234567, "-1.23M", 0, PP_SPACE_FOR_PLUS, },
 		{  1234567, "01.23M", 6, PP_ZERO_PAD, },
 		{  1234567, "1.23M",  0, PP_THOUSANDS_SEP, },
 		{  1023,"1023", 0, PP_ALTERNATE_FORM2|PP_THOUSANDS_SEP, },
 		{ -1,                  NULL,     0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; hn_test_vals[i].out != NULL; i++) {
 		p->width = hn_test_vals[i].width;
 		p->flags = hn_test_vals[i].flags;
 		sbuf = human_number(sbuf, hn_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), hn_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(string_val);
 ATF_TC_HEAD(string_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing string_val() output routine");
 }
 ATF_TC_BODY(string_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct sv_test_vals {
 		const char *in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} sv_test_vals[] = {
 		{ "xxx", "xxx",    0, 0, },
 		{ "xxx", "xxx",    1, 0, },
 		{ "xxx", "xxx",    2, 0, },
 		{ "xxx", "xxx",    3, 0, },
 		{ "xxx", " xxx",   4, 0, },
 		{ "xxx", "  xxx",  5, 0, },
 		{ "xxx", "   xxx", 6, 0, },
 		{ "xxy", "xxy",    0, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    1, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    2, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    3, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy ",   4, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy  ",  5, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy   ", 6, PP_LEFT_ALIGN, },
 		{ "xxz", "xxz",    0, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    1, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    2, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    3, PP_ZERO_PAD, },
 		{ "xxz", "0xxz",   4, PP_ZERO_PAD, },
 		{ "xxz", "00xxz",  5, PP_ZERO_PAD, },
 		{ "xxz", "000xxz", 6, PP_ZERO_PAD, },
 		/* Seems you can't zero pad on the RHS of a string */
 		{ "xyx", "xyx",    0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx ",   4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx  ",  5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx   ", 6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		/* Most of the format modifiers don't affect strings */
 		{ "aaa", "aaa", 0, PP_ALTERNATE_FORM1, },
 		{ "bbb", "bbb", 0, PP_ALTERNATE_FORM2, },
 		{ "ccc", "ccc", 0, PP_EXPLICIT_PLUS, },
 		{ "ddd", "ddd", 0, PP_SPACE_FOR_PLUS, },
 		{ "eee", "eee", 0, PP_THOUSANDS_SEP, },
 		{ NULL, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; sv_test_vals[i].out != NULL; i++) {
 		p->width = sv_test_vals[i].width;
 		p->flags = sv_test_vals[i].flags;
 		sbuf = string_val(sbuf, sv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), sv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(int_val);
 ATF_TC_HEAD(int_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing int_val() output routine");
 }
 ATF_TC_BODY(int_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct iv_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} iv_test_vals[] = {
 		{ 0,      "0",   0, 0, },
 		{ 1,      "1",   0, 0, },
 		{ -1,     "-1",  0, 0, },
 		{ 340,    "340",       0, 0, },
 		{ 341,    "341",       1, 0, },
 		{ 342,    "342",       2, 0, },
 		{ 343,    "343",       3, 0, },
 		{ 344,    " 344",      4, 0, },
 		{ 345,    "  345",     5, 0, },
 		{ 346,    "   346",    6, 0, },
 		{ 347,    "    347",   7, 0, },
 		{ 348,    "     348",  8, 0, },
 		{ 349,    "      349", 9, 0, },
 		{ 350,    "350",       0, PP_LEFT_ALIGN, },
 		{ 351,    "351",       1, PP_LEFT_ALIGN, },
 		{ 352,    "352",       2, PP_LEFT_ALIGN, },
 		{ 353,    "353",       3, PP_LEFT_ALIGN, },
 		{ 354,    "354 ",      4, PP_LEFT_ALIGN, },
 		{ 355,    "355  ",     5, PP_LEFT_ALIGN, },
 		{ 356,    "356   ",    6, PP_LEFT_ALIGN, },
 		{ 357,    "357    ",   7, PP_LEFT_ALIGN, },
 		{ 358,    "358     ",  8, PP_LEFT_ALIGN, },
 		{ 359,    "359      ", 9, PP_LEFT_ALIGN, },
 		{ 360,    "+360",      0, PP_EXPLICIT_PLUS, },
 		{ 361,    "+361",      1, PP_EXPLICIT_PLUS, },
 		{ 362,    "+362",      2, PP_EXPLICIT_PLUS, },
 		{ 363,    "+363",      3, PP_EXPLICIT_PLUS, },
 		{ 364,    "+364",      4, PP_EXPLICIT_PLUS, },
 		{ 365,    " +365",     5, PP_EXPLICIT_PLUS, },
 		{ 366,    "  +366",    6, PP_EXPLICIT_PLUS, },
 		{ 367,    "   +367",   7, PP_EXPLICIT_PLUS, },
 		{ 368,    "    +368",  8, PP_EXPLICIT_PLUS, },
 		{ 369,    "     +369", 9, PP_EXPLICIT_PLUS, },
 		{ -370,   "-370",      0, PP_EXPLICIT_PLUS, },
 		{ -371,   "-371",      1, PP_EXPLICIT_PLUS, },
 		{ -372,   "-372",      2, PP_EXPLICIT_PLUS, },
 		{ -373,   "-373",      3, PP_EXPLICIT_PLUS, },
 		{ -374,   "-374",      4, PP_EXPLICIT_PLUS, },
 		{ -375,   " -375",     5, PP_EXPLICIT_PLUS, },
 		{ -376,   "  -376",    6, PP_EXPLICIT_PLUS, },
 		{ -377,   "   -377",   7, PP_EXPLICIT_PLUS, },
 		{ -378,   "    -378",  8, PP_EXPLICIT_PLUS, },
 		{ -379,   "     -379", 9, PP_EXPLICIT_PLUS, },
 		{ 380,    " 380",      0, PP_SPACE_FOR_PLUS, },
 		{ 381,    " 381",      1, PP_SPACE_FOR_PLUS, },
 		{ 382,    " 382",      2, PP_SPACE_FOR_PLUS, },
 		{ 383,    " 383",      3, PP_SPACE_FOR_PLUS, },
 		{ 384,    " 384",      4, PP_SPACE_FOR_PLUS, },
 		{ 385,    "  385",     5, PP_SPACE_FOR_PLUS, },
 		{ 386,    "   386",    6, PP_SPACE_FOR_PLUS, },
 		{ 387,    "    387",   7, PP_SPACE_FOR_PLUS, },
 		{ 388,    "     388",  8, PP_SPACE_FOR_PLUS, },
 		{ 389,    "      389", 9, PP_SPACE_FOR_PLUS, },
 		{ -390,   "-390",      0, PP_SPACE_FOR_PLUS, },
 		{ -391,   "-391",      1, PP_SPACE_FOR_PLUS, },
 		{ -392,   "-392",      2, PP_SPACE_FOR_PLUS, },
 		{ -393,   "-393",      3, PP_SPACE_FOR_PLUS, },
 		{ -394,   "-394",      4, PP_SPACE_FOR_PLUS, },
 		{ -395,   " -395",     5, PP_SPACE_FOR_PLUS, },
 		{ -396,   "  -396",    6, PP_SPACE_FOR_PLUS, },
 		{ -397,   "   -397",   7, PP_SPACE_FOR_PLUS, },
 		{ -398,   "    -398",  8, PP_SPACE_FOR_PLUS, },
 		{ -399,   "     -399", 9, PP_SPACE_FOR_PLUS, },
 		{ 400,    "+400",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 401,    "+401",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 402,    "+402",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 403,    "+403",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 404,    "+404",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 405,    "+405 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 406,    "+406  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 407,    "+407   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 408,    "+408    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 409,    "+409     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -410,   "-410",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -411,   "-411",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -412,   "-412",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -413,   "-413",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -414,   "-414",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -415,   "-415 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -416,   "-416  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -417,   "-417   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -418,   "-418    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -419,   "-419     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 420,    " 420",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 421,    " 421",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 422,    " 422",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 423,    " 423",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 424,    " 424",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 425,    " 425 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 426,    " 426  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 427,    " 427   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 428,    " 428    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 429,    " 429     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -430,   "-430",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -431,   "-431",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -432,   "-432",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -433,   "-433",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -434,   "-434",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -435,   "-435 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -436,   "-436  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -437,   "-437   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -438,   "-438    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -439,   "-439     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 440,    "440",       0, PP_ZERO_PAD, },
 		{ 441,    "441",       1, PP_ZERO_PAD, },
 		{ 442,    "442",       2, PP_ZERO_PAD, },
 		{ 443,    "443",       3, PP_ZERO_PAD, },
 		{ 444,    "0444",      4, PP_ZERO_PAD, },
 		{ 445,    "00445",     5, PP_ZERO_PAD, },
 		{ 446,    "000446",    6, PP_ZERO_PAD, },
 		{ 447,    "0000447",   7, PP_ZERO_PAD, },
 		{ 448,    "00000448",  8, PP_ZERO_PAD, },
 		{ 449,    "000000449", 9, PP_ZERO_PAD, },
 		{ -450,    "-450",      0, PP_ZERO_PAD, },
 		{ -451,    "-451",      1, PP_ZERO_PAD, },
 		{ -452,    "-452",      2, PP_ZERO_PAD, },
 		{ -453,    "-453",      3, PP_ZERO_PAD, },
 		{ -454,    "-454",      4, PP_ZERO_PAD, },
 		{ -455,    "-0455",     5, PP_ZERO_PAD, },
 		{ -456,    "-00456",    6, PP_ZERO_PAD, },
 		{ -457,    "-000457",   7, PP_ZERO_PAD, },
 		{ -458,    "-0000458",  8, PP_ZERO_PAD, },
 		{ -459,    "-00000459", 9, PP_ZERO_PAD, },
 		{ 460,    "+460",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 461,    "+461",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 462,    "+462",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 463,    "+463",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 464,    "+464",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 465,    "+0465",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 466,    "+00466",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 467,    "+000467",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 468,    "+0000468",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 469,    "+00000469", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -470,    "-470",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -471,    "-471",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -472,    "-472",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -473,    "-473",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -474,    "-474",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -475,    "-0475",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -476,    "-00476",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -477,    "-000477",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -478,    "-0000478",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -479,    "-00000479", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 480,    " 480",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 481,    " 481",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 482,    " 482",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 483,    " 483",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 484,    " 484",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 485,    " 0485",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 486,    " 00486",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 487,    " 000487",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 488,    " 0000488",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 489,    " 00000489", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -490,    "-490",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -491,    "-491",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -492,    "-492",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -493,    "-493",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -494,    "-494",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -495,    "-0495",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -496,    "-00496",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -497,    "-000497",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -498,    "-0000498",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -499,    "-00000499", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		/* PP_LEFT_ALIGN beats PP_ZERO_PAD */
 		{ 500,    "500",       0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 501,    "501",       1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 502,    "502",       2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 503,    "503",       3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 504,    "504 ",      4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 505,    "505  ",     5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 506,    "506   ",    6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 507,    "507    ",   7, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 508,    "508     ",  8, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 509,    "509      ", 9, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		/* PP_EXPLICIT_PLUS beats PP_SPACE_FOR_PLUS */
 		{ 700,    "+700",       0, PP_EXPLICIT_PLUS|PP_SPACE_FOR_PLUS, },
 		/* See human_number for comprehensive tests of
 		   PP_ALTERNATE_FORM1 and PP_ALTERNATE_FORM2 */
 		{ -1, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; iv_test_vals[i].out != NULL; i++) {
 		p->width = iv_test_vals[i].width;
 		p->flags = iv_test_vals[i].flags;
 		sbuf = int_val(sbuf, iv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), iv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(bool_val);
 ATF_TC_HEAD(bool_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing bool_val() output routine");
 }
 ATF_TC_BODY(bool_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct bv_test_vals {
 		bool in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} bv_test_vals[] = {
 		{ false, "0",     0, 0, },
 		{ true,  "1",     0, 0, },
 		{ false, "no",    0, PP_ALTERNATE_FORM1, },
 		{ true,  "yes",   0, PP_ALTERNATE_FORM1, },
 		{ false, "false", 0, PP_ALTERNATE_FORM2, },
 		{ true,  "true",  0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See string_val() for tests on field-width and
 		 * left-align
 		 */
 		{ false, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; bv_test_vals[i].out != NULL; i++) {
 		p->width = bv_test_vals[i].width;
 		p->flags = bv_test_vals[i].flags;
 		sbuf = bool_val(sbuf, bv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), bv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(mode_val);
 ATF_TC_HEAD(mode_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing mode_val() output routine");
 }
 ATF_TC_BODY(mode_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct mv_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} mv_test_vals[] = {
 		{ 00000, "0",          0, 0, },
 		{ 00007, "7",          0, 0, },
 		{ 00070, "70",         0, 0, },
 		{ 00700, "700",        0, 0, },
 		{ 07000, "7000",       0, 0, },
 		{ 00000, "    0",      5, 0, },
 		{ 00007, "    7",      5, 0, },
 		{ 00070, "   70",      5, 0, },
 		{ 00700, "  700",      5, 0, },
 		{ 07000, " 7000",      5, 0, },
 		{ 00000, "        0",  9, 0, },
 		{ 00007, "        7",  9, 0, },
 		{ 00070, "       70",  9, 0, },
 		{ 00700, "      700",  9, 0, },
 		{ 07000, "     7000",  9, 0, },
 		/*
                  * Shows a ? character for 'unknown inode type'.  Note
 		 * the trailing space.
 		 */
 		{ 00000, "?--------- ", 0, PP_ALTERNATE_FORM1, },
 		{ 00007, "?------rwx ", 0, PP_ALTERNATE_FORM1, },
 		{ 00070, "?---rwx--- ", 0, PP_ALTERNATE_FORM1, },
 		{ 00700, "?rwx------ ", 0, PP_ALTERNATE_FORM1, },
 		{ 07000, "?--S--S--T ", 0, PP_ALTERNATE_FORM1, },
 		{ 07111, "?--s--s--t ", 0, PP_ALTERNATE_FORM1, },
 		{ 00000, "0",          0, PP_ALTERNATE_FORM2, },
 		{ 00007, "07",         0, PP_ALTERNATE_FORM2, },
 		{ 00070, "070",        0, PP_ALTERNATE_FORM2, },
 		{ 00700, "0700",       0, PP_ALTERNATE_FORM2, },
 		{ 07000, "07000",      0, PP_ALTERNATE_FORM2, },
 		{ 00000, "    0",      5, PP_ALTERNATE_FORM2, },
 		{ 00007, "   07",      5, PP_ALTERNATE_FORM2, },
 		{ 00070, "  070",      5, PP_ALTERNATE_FORM2, },
 		{ 00700, " 0700",      5, PP_ALTERNATE_FORM2, },
 		{ 07000, "07000",      5, PP_ALTERNATE_FORM2, },
 		{ 00000, "        0",  9, PP_ALTERNATE_FORM2, },
 		{ 00007, "       07",  9, PP_ALTERNATE_FORM2, },
 		{ 00070, "      070",  9, PP_ALTERNATE_FORM2, },
 		{ 00700, "     0700",  9, PP_ALTERNATE_FORM2, },
 		{ 07000, "    07000",  9, PP_ALTERNATE_FORM2, },
 		/*
 		 * The device type bits: 0170000
 		 */
 		{ 0010000, "0", 0, 0, }, /* FIFO */
 		{ 0020000, "0", 0, 0, }, /* Char special */
 		{ 0060000, "0", 0, 0, }, /* Block special */
 		{ 0100000, "0", 0, 0, }, /* Regular file */
 		{ 0120000, "0", 0, 0, }, /* Sym-link */
 		{ 0140000, "0", 0, 0, }, /* socket */
 		{ 0160000, "0", 0, 0, }, /* whiteout */
 		{ 0010000, "p--------- ", 0, PP_ALTERNATE_FORM1, }, /* FIFO */
 		{ 0020000, "c--------- ", 0, PP_ALTERNATE_FORM1, }, /* Char special */
 		{ 0060000, "b--------- ", 0, PP_ALTERNATE_FORM1, }, /* Block special */
 		{ 0100000, "---------- ", 0, PP_ALTERNATE_FORM1, }, /* Regular file */
 		{ 0120000, "l--------- ", 0, PP_ALTERNATE_FORM1, }, /* Sym-link */
 		{ 0140000, "s--------- ", 0, PP_ALTERNATE_FORM1, }, /* socket */
 		{ 0160000, "w--------- ", 0, PP_ALTERNATE_FORM1, }, /* whiteout */
 		{ 0010000, "10000",  0, PP_EXPLICIT_PLUS, }, /* FIFO */
 		{ 0020000, "20000",  0, PP_EXPLICIT_PLUS, }, /* Char special */
 		{ 0060000, "60000",  0, PP_EXPLICIT_PLUS, }, /* Block special */
 		{ 0100000, "100000", 0, PP_EXPLICIT_PLUS, }, /* Regular file */
 		{ 0120000, "120000", 0, PP_EXPLICIT_PLUS, }, /* Sym-link */
 		{ 0140000, "140000", 0, PP_EXPLICIT_PLUS, }, /* socket */
 		{ 0160000, "160000", 0, PP_EXPLICIT_PLUS, }, /* whiteout */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; mv_test_vals[i].out != NULL; i++) {
 		p->width = mv_test_vals[i].width;
 		p->flags = mv_test_vals[i].flags;
 		sbuf = mode_val(sbuf, mv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), mv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(liclog_val);
 ATF_TC_HEAD(liclog_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing liclog_val() output routine");
 }
 ATF_TC_BODY(liclog_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct lv_test_vals {
 		lic_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} lv_test_vals[] = {
 		{ LICENSE_SINGLE, "single", 0, 0, },
 		{ LICENSE_OR,     "or",     0, 0, },
 		{ LICENSE_AND,    "and",    0, 0, },
 		{ LICENSE_SINGLE, "",       0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_OR,     "|",      0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_AND,    "&",      0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_SINGLE, "==",     0, PP_ALTERNATE_FORM2, },
 		{ LICENSE_OR,     "||",     0, PP_ALTERNATE_FORM2, },
 		{ LICENSE_AND,    "&&",     0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See string_val() for tests on field-width and
 		 * left-align
 		 */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; lv_test_vals[i].out != NULL; i++) {
 		p->width = lv_test_vals[i].width;
 		p->flags = lv_test_vals[i].flags;
 		sbuf = liclog_val(sbuf, lv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), lv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(list_count);
 ATF_TC_HEAD(list_count, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing list_count() output routine");
 }
 ATF_TC_BODY(list_count, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct lc_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} lc_test_vals[] = {
 		{ 10, "10", 0, 0, },
 		{ 20, "1",  0, PP_ALTERNATE_FORM1, },
 		{ 30, "30", 0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See int_val() for tests on field-width and
 		 * left-align
 		 */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; lc_test_vals[i].out != NULL; i++) {
 		p->width = lc_test_vals[i].width;
 		p->flags = lc_test_vals[i].flags;
 		sbuf = list_count(sbuf, lc_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), lc_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(maybe_read_hex_byte);
 ATF_TC_HEAD(maybe_read_hex_byte, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing maybe_read_hex_byte() format parsing routine");
 }
 ATF_TC_BODY(maybe_read_hex_byte, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct mrhb_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} mrhb_test_vals[] = {
 		{ "x61",   "a",    3, '\0', },
 		{ "x",     "\\x",  1, '\0', },
 		{ "xg",    "\\x",  1, 'g',  },
 		{ "xf",    "\\x",  1, 'f',  },
 		{ "xfg",   "\\x",  1, 'f',  },
 		{ "xff",   "\xff", 3, '\0', },
 		{ "xffg",  "\xff", 3, 'g',  },
 		{ "xfffg", "\xff", 3, 'f',  },
 		{ "x00",   "\0",   3, '\0', },
 		{ "x01",   "\x01", 3, '\0', },
 		{ "x02",   "\x02", 3, '\0', },
 		{ "x03",   "\x03", 3, '\0', },
 		{ "x04",   "\x04", 3, '\0', },
 		{ "x05",   "\x05", 3, '\0', },
 		{ "x06",   "\x06", 3, '\0', },
 		{ "x07",   "\x07", 3, '\0', },
 		{ "x08",   "\x08", 3, '\0', },
 		{ "x09",   "\x09", 3, '\0', },
 		{ "x0a",   "\x0a", 3, '\0', },
 		{ "x0b",   "\x0b", 3, '\0', },
 		{ "x0c",   "\x0c", 3, '\0', },
 		{ "x0d",   "\x0d", 3, '\0', },
 		{ "x0e",   "\x0e", 3, '\0', },
 		{ "x0f",   "\x0f", 3, '\0', },
 		{ "x0A",   "\x0a", 3, '\0', },
 		{ "x0B",   "\x0b", 3, '\0', },
 		{ "x0C",   "\x0c", 3, '\0', },
 		{ "x0D",   "\x0d", 3, '\0', },
 		{ "x0E",   "\x0e", 3, '\0', },
 		{ "x0F",   "\x0f", 3, '\0', },
 		{ "x10",   "\x10", 3, '\0', },
 		{ "x20",   "\x20", 3, '\0', },
 		{ "x30",   "\x30", 3, '\0', },
 		{ "x40",   "\x40", 3, '\0', },
 		{ "x50",   "\x50", 3, '\0', },
 		{ "x60",   "\x60", 3, '\0', },
 		{ "x70",   "\x70", 3, '\0', },
 		{ "x80",   "\x80", 3, '\0', },
 		{ "x90",   "\x90", 3, '\0', },
 		{ "xa0",   "\xa0", 3, '\0', },
 		{ "xb0",   "\xb0", 3, '\0', },
 		{ "xc0",   "\xc0", 3, '\0', },
 		{ "xd0",   "\xd0", 3, '\0', },
 		{ "xe0",   "\xe0", 3, '\0', },
 		{ "xf0",   "\xf0", 3, '\0', },
 		{ "xA0",   "\xa0", 3, '\0', },
 		{ "xB0",   "\xb0", 3, '\0', },
 		{ "xC0",   "\xc0", 3, '\0', },
 		{ "xD0",   "\xd0", 3, '\0', },
 		{ "xE0",   "\xe0", 3, '\0', },
 		{ "xF0",   "\xf0", 3, '\0', },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; mrhb_test_vals[i].in != NULL; i++) {
 		f = maybe_read_hex_byte(sbuf, mrhb_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), mrhb_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - mrhb_test_vals[i].in,
 				 mrhb_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, mrhb_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(read_oct_byte);
 ATF_TC_HEAD(read_oct_byte, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing read_oct_byte() format parsing routine");
 }
 ATF_TC_BODY(read_oct_byte, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct rob_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} rob_test_vals[] = {
 		{ "141",   "a",    3, '\0', },
 		{ "0",     "\0",   1, '\0', },
 		{ "08",    "\0",   1, '8',  },
 		{ "008",    "\0",  2, '8',  },
 		{ "0008",   "\0",  3, '8',  },
 		{ "00008",  "\0",  3, '0',  },
 		{ "1",     "\001", 1, '\0', },
 		{ "2",     "\002", 1, '\0', },
 		{ "3",     "\003", 1, '\0', },
 		{ "4",     "\004", 1, '\0', },
 		{ "5",     "\005", 1, '\0', },
 		{ "6",     "\006", 1, '\0', },
 		{ "7",     "\007", 1, '\0', },
 		{ "00",    "\000", 2, '\0', },
 		{ "01",    "\001", 2, '\0', },
 		{ "02",    "\002", 2, '\0', },
 		{ "03",    "\003", 2, '\0', },
 		{ "04",    "\004", 2, '\0', },
 		{ "05",    "\005", 2, '\0', },
 		{ "06",    "\006", 2, '\0', },
 		{ "07",    "\007", 2, '\0', },
 		{ "000",   "\000", 3, '\0', },
 		{ "001",   "\001", 3, '\0', },
 		{ "002",   "\002", 3, '\0', },
 		{ "003",   "\003", 3, '\0', },
 		{ "004",   "\004", 3, '\0', },
 		{ "005",   "\005", 3, '\0', },
 		{ "006",   "\006", 3, '\0', },
 		{ "007",   "\007", 3, '\0', },
 		{ "10",    "\010", 2, '\0', },
 		{ "20",    "\020", 2, '\0', },
 		{ "30",    "\030", 2, '\0', },
 		{ "40",    "\040", 2, '\0', },
 		{ "50",    "\050", 2, '\0', },
 		{ "60",    "\060", 2, '\0', },
 		{ "70",    "\070", 2, '\0', },
 		{ "010",   "\010", 3, '\0', },
 		{ "020",   "\020", 3, '\0', },
 		{ "030",   "\030", 3, '\0', },
 		{ "040",   "\040", 3, '\0', },
 		{ "050",   "\050", 3, '\0', },
 		{ "060",   "\060", 3, '\0', },
 		{ "070",   "\070", 3, '\0', },
 		{ "100",   "\100", 3, '\0', },
 		{ "200",   "\200", 3, '\0', },
 		{ "300",   "\300", 3, '\0', },
 		{ "370",   "\370", 3, '\0', },
 		{ "371",   "\371", 3, '\0', },
 		{ "372",   "\372", 3, '\0', },
 		{ "373",   "\373", 3, '\0', },
 		{ "374",   "\374", 3, '\0', },
 		{ "375",   "\375", 3, '\0', },
 		{ "376",   "\376", 3, '\0', },
 		{ "377",   "\377", 3, '\0', },
 		{ "400",   "\040", 2, '0',  },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; rob_test_vals[i].in != NULL; i++) {
 		f = read_oct_byte(sbuf, rob_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), rob_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - rob_test_vals[i].in,
 				 rob_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, rob_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(process_escape);
 ATF_TC_HEAD(process_escape, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing process_escape() format parsing routine");
 }
 ATF_TC_BODY(process_escape, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct pe_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} pe_test_vals[] = {
 		{ "\\a",   "\a",   2, '\0', },
 		{ "\\b",   "\b",   2, '\0', },
 		{ "\\f",   "\f",   2, '\0', },
 		{ "\\n",   "\n",   2, '\0', },
 		{ "\\t",   "\t",   2, '\0', },
 		{ "\\v",   "\v",   2, '\0', },
 		{ "\\'",   "'",    2, '\0', },
 		{ "\\\"",  "\"",   2, '\0', },
 		{ "\\\\",  "\\",   2, '\0', },
 		{ "\\q",   "\\",   1, 'q',  },
 		/* See read_oct_byte() for more comprehensive tests on
 		   octal number escapes */
 		{ "\\1234",  "S",   4, '4',  },
 		{ "\\89",    "\\",  1, '8',  },
 		/* See maybe_read_hex_byte() for more comprehensive
 		   tests on hexadecimal number escapes */
 		{ "\\x4cd",  "L",   4, 'd', },
 		{ "\\xGG",   "\\x", 2, 'G', },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; pe_test_vals[i].in != NULL; i++) {
 		f = process_escape(sbuf, pe_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), pe_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - pe_test_vals[i].in,
 				 pe_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, pe_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(field_modifier);
 ATF_TC_HEAD(field_modifier, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing field_modifier() format parsing routine");
 }
 ATF_TC_BODY(field_modifier, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fm_test_vals {
 		const char *in;
 		unsigned flags;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fm_test_vals[] = {
 		{ "?",  PP_ALTERNATE_FORM1, 1, '\0', },
 		{ "#",  PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "-",  PP_LEFT_ALIGN,      1, '\0', },
 		{ "+",  PP_EXPLICIT_PLUS,   1, '\0', },
 		{ " ",  PP_SPACE_FOR_PLUS,  1, '\0', },
 		{ "0",  PP_ZERO_PAD,        1, '\0', },
 		{ "\'", PP_THOUSANDS_SEP,   1, '\0', },
 		/* Not a format modifier... */
 		{ "z",  0,  0, 'z', },
 		{ "*",  0,  0, '*', },
 		{ "1",  0,  0, '1', },
 		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "##",   PP_ALTERNATE_FORM2, 2, '\0', },
 		{ "###",  PP_ALTERNATE_FORM2, 3, '\0', },
 		{ "####", PP_ALTERNATE_FORM2, 4, '\0', },
 		{ "#z",    PP_ALTERNATE_FORM2, 1, 'z', },
 		{ "##z",   PP_ALTERNATE_FORM2, 2, 'z', },
 		{ "###z",  PP_ALTERNATE_FORM2, 3, 'z', },
 		{ "####z", PP_ALTERNATE_FORM2, 4, 'z', },
 		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "#?",   PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 2, '\0', },
 		{ "#?#",  PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 3, '\0', },
 		{ "#?#?", PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 4, '\0', },
 		{ NULL,   0,    0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fm_test_vals[i].in != NULL; i++) {
 		p->flags = 0;
 		f = field_modifier(fm_test_vals[i].in, p);
 		ATF_CHECK_EQ_MSG(p->flags, fm_test_vals[i].flags,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fm_test_vals[i].in,
 				 fm_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fm_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(field_width);
 ATF_TC_HEAD(field_width, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing field_width() format parsing routine");
 }
 ATF_TC_BODY(field_width, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fw_test_vals {
 		const char *in;
 		int width;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fw_test_vals[] = {
 		{  "0",  0, 1, '\0', },
 		{  "1",  1, 1, '\0', },
 		{  "2",  2, 1, '\0', },
 		{  "3",  3, 1, '\0', },
 		{  "4",  4, 1, '\0', },
 		{  "5",  5, 1, '\0', },
 		{  "6",  6, 1, '\0', },
 		{  "7",  7, 1, '\0', },
 		{  "8",  8, 1, '\0', },
 		{  "9",  9, 1, '\0', },
 		{ "10", 10, 2, '\0', },
 		{ "11", 11, 2, '\0', },
 		{ "12", 12, 2, '\0', },
 		{ "23", 23, 2, '\0', },
 		{ "34", 34, 2, '\0', },
 		{ "45", 45, 2, '\0', },
 		{ "56", 56, 2, '\0', },
 		{ "67", 67, 2, '\0', },
 		{ "78", 78, 2, '\0', },
 		{ "89", 89, 2, '\0', },
 		{ "90", 90, 2, '\0', },
 		{ "00",  0, 2, '\0', },
 		{ "001", 1, 3, '\0', },
 		{ "x",   0, 0, 'x',  },
 		{ "0x",  0, 1, 'x',  },
 		{ NULL,  0, 0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fw_test_vals[i].in != NULL; i++) {
 		p->width = 0;
 		f = field_width(fw_test_vals[i].in, p);
 		ATF_CHECK_EQ_MSG(p->width, fw_test_vals[i].width,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fw_test_vals[i].in,
 				 fw_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fw_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(format_code);
 ATF_TC_HEAD(format_code, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing format_code() format parsing routine");
 }
 ATF_TC_BODY(format_code, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fc_test_vals {
 		const char *in;
 		unsigned context;
 		fmt_code_t fmt_code;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fc_test_vals[] = {
 		{ "Bn", PP_PKG, PP_PKG_SHLIB_NAME,        2, '\0', }, /* 0 */
 		{ "B",  PP_PKG, PP_PKG_SHLIBS,            1, '\0', },
 		{ "Cn", PP_PKG, PP_PKG_CATEGORY_NAME,     2, '\0', },
 		{ "C",  PP_PKG, PP_PKG_CATEGORIES,        1, '\0', },
 		{ "Dg", PP_PKG, PP_PKG_DIRECTORY_GROUP,   2, '\0', },
 		{ "Dk", PP_PKG, PP_PKG_DIRECTORY_KEEPFLAG,2, '\0', },
 		{ "Dn", PP_PKG, PP_PKG_DIRECTORY_PATH,    2, '\0', },
 		{ "Dp", PP_PKG, PP_PKG_DIRECTORY_PERMS,   2, '\0', },
 		{ "Dt", PP_PKG, PP_PKG_DIRECTORY_TRYFLAG, 2, '\0', },
 		{ "Du", PP_PKG, PP_PKG_DIRECTORY_USER,    2, '\0', },
 		{ "D",  PP_PKG, PP_PKG_DIRECTORIES,       1, '\0', }, /* 10 */
 		{ "Fg", PP_PKG, PP_PKG_FILE_GROUP,        2, '\0', },
 		{ "Fk", PP_PKG, PP_PKG_FILE_KEEPFLAG,     2, '\0', },
 		{ "Fn", PP_PKG, PP_PKG_FILE_PATH,         2, '\0', },
 		{ "Fp", PP_PKG, PP_PKG_FILE_PERMS,        2, '\0', },
 		{ "Fs", PP_PKG, PP_PKG_FILE_SHA256,       2, '\0', },
 		{ "Fu", PP_PKG, PP_PKG_FILE_USER,         2, '\0', },
 		{ "F",  PP_PKG, PP_PKG_FILES,             1, '\0', },
 		{ "Gg", PP_PKG, PP_PKG_GROUP_GIDSTR,      2, '\0', },
 		{ "Gn", PP_PKG, PP_PKG_GROUP_NAME,        2, '\0', },
 		{ "G",  PP_PKG, PP_PKG_GROUPS,            1, '\0', }, /* 20 */
 		{ "I",  PP_PKG, PP_UNKNOWN,               0, 'I',  },
 		{ "Ln", PP_PKG, PP_PKG_LICENSE_NAME,      2, '\0', },
 		{ "L",  PP_PKG, PP_PKG_LICENSES,          1, '\0', },
 		{ "M",  PP_PKG, PP_PKG_MESSAGE,           1, '\0', },
 		{ "On", PP_PKG, PP_PKG_OPTION_NAME,       2, '\0', },
 		{ "Ov", PP_PKG, PP_PKG_OPTION_VALUE,      2, '\0', },
 		{ "O",  PP_PKG, PP_PKG_OPTIONS,           1, '\0', },
 		{ "Un", PP_PKG, PP_PKG_USER_NAME,         2, '\0', },
 		{ "Uu", PP_PKG, PP_PKG_USER_UIDSTR,       2, '\0', },
 		{ "U",  PP_PKG, PP_PKG_USERS,             1, '\0', }, /* 30 */
 		{ "a",  PP_PKG, PP_PKG_AUTOREMOVE,        1, '\0', },
 		{ "c",  PP_PKG, PP_PKG_COMMENT,           1, '\0', },
 		{ "dn", PP_PKG, PP_PKG_DEPENDENCY_NAME,   2, '\0', },
 		{ "do", PP_PKG, PP_PKG_DEPENDENCY_ORIGIN, 2, '\0', },
 		{ "dv", PP_PKG, PP_PKG_DEPENDENCY_VERSION,2, '\0', },
 		{ "d",  PP_PKG, PP_PKG_DEPENDENCIES,      1, '\0', },
 		{ "i",  PP_PKG, PP_PKG_ADDITIONAL_INFO,   1, '\0', },
 		{ "k",  PP_PKG, PP_PKG_LOCK_STATUS,       1, '\0', },
 		{ "l",  PP_PKG, PP_PKG_LICENSE_LOGIC,     1, '\0', },
 		{ "m",  PP_PKG, PP_PKG_MAINTAINER,        1, '\0', }, /* 40 */
 		{ "n",  PP_PKG, PP_PKG_NAME,              1, '\0', },
 		{ "o",  PP_PKG, PP_PKG_ORIGIN,            1, '\0', },
 		{ "p",  PP_PKG, PP_PKG_PREFIX,            1, '\0', },
 		{ "rn", PP_PKG, PP_PKG_REQUIREMENT_NAME,  2, '\0', },
 		{ "ro", PP_PKG, PP_PKG_REQUIREMENT_ORIGIN, 2, '\0', },
 		{ "rv", PP_PKG, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
 		{ "r",  PP_PKG, PP_PKG_REQUIREMENTS,      1, '\0', },
 		{ "s",  PP_PKG, PP_PKG_FLATSIZE,          1, '\0', },
 		{ "t",  PP_PKG, PP_PKG_INSTALL_TIMESTAMP, 1, '\0', },
 		{ "v",  PP_PKG, PP_PKG_VERSION,           1, '\0', }, /* 50 */
 		{ "w",  PP_PKG, PP_PKG_HOME_PAGE,         1, '\0', },
 		{ "%",  PP_PKG, PP_LITERAL_PERCENT,       1, '\0', },
 		{ "x",  PP_PKG, PP_UNKNOWN,               0, 'x',  },
 		{ "Bn", PP_B, PP_PKG_SHLIB_NAME,          2, '\0', },
 		{ "B",  PP_B, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_B, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_B, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_B, PP_UNKNOWN,                 0, 'D',  }, /* 60 */
 		{ "Dp", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_B, PP_UNKNOWN,                 0, 'F',  }, /* 70 */
 		{ "F",  PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_B, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_B, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_B, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_B, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_B, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_B, PP_UNKNOWN,                 0, 'O',  }, /* 80 */
 		{ "O",  PP_B, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_B, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_B, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_B, PP_UNKNOWN,                 0, 'd',  }, /* 90 */
 		{ "i",  PP_B, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_B, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_B, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_B, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_B, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_B, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_B, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_B, PP_UNKNOWN,                 0, 'r',  }, /* 100 */
 		{ "r",  PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_B, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_B, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_B, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_B, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_B, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_B, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_C, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_C, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_C, PP_PKG_CATEGORY_NAME,       2, '\0', }, /* 110 */
 		{ "C",  PP_C, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_C, PP_UNKNOWN,                 0, 'F',  }, /* 120 */
 		{ "Fn", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_C, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_C, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_C, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_C, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_C, PP_UNKNOWN,                 0, 'L',  }, /* 130 */
 		{ "L",  PP_C, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_C, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_C, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_C, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_C, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_C, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_C, PP_PKG_COMMENT,             1, '\0', }, /* 140 */
 		{ "dn", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_C, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_C, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_C, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_C, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_C, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_C, PP_PKG_ORIGIN,              1, '\0', }, /* 150 */
 		{ "p",  PP_C, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_C, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_C, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_C, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_C, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_C, PP_LITERAL_PERCENT,         1, '\0', }, /* 160 */
 		{ "x",  PP_C, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_D, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_D, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_D, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_D, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_D, PP_PKG_DIRECTORY_GROUP,     2, '\0', },
 		{ "Dk", PP_D, PP_PKG_DIRECTORY_KEEPFLAG,  2, '\0', },
 		{ "Dn", PP_D, PP_PKG_DIRECTORY_PATH,      2, '\0', },
 		{ "Dp", PP_D, PP_PKG_DIRECTORY_PERMS,     2, '\0', },
 		{ "Dt", PP_D, PP_PKG_DIRECTORY_TRYFLAG,   2, '\0', }, /* 170 */
 		{ "Du", PP_D, PP_PKG_DIRECTORY_USER,      2, '\0', },
 		{ "D",  PP_D, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_D, PP_UNKNOWN,                 0, 'G',  }, /* 180 */
 		{ "Gn", PP_D, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_D, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_D, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_D, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_D, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_D, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_D, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_D, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_D, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_D, PP_UNKNOWN,                 0, 'U',  }, /* 190 */
 		{ "Uu", PP_D, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_D, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_D, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_D, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_D, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_D, PP_PKG_LOCK_STATUS,         1, '\0', }, /* 200 */
 		{ "l",  PP_D, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_D, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_D, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_D, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_D, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_D, PP_PKG_FLATSIZE,            1, '\0', }, /* 210 */
 		{ "t",  PP_D, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_D, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_D, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_D, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_D, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_F, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_F, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_F, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_F, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_F, PP_UNKNOWN,                 0, 'D',  },/* 220 */
 		{ "Dk", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_F, PP_PKG_FILE_GROUP,          2, '\0', },
 		{ "Fk", PP_F, PP_PKG_FILE_KEEPFLAG,       2, '\0', },
 		{ "Fn", PP_F, PP_PKG_FILE_PATH,           2, '\0', },
 		{ "Fp", PP_F, PP_PKG_FILE_PERMS,          2, '\0', }, /* 230 */
 		{ "Fs", PP_F, PP_PKG_FILE_SHA256,         2, '\0', },
 		{ "Fu", PP_F, PP_PKG_FILE_USER,           2, '\0', },
 		{ "F",  PP_F, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_F, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_F, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_F, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_F, PP_PKG_MESSAGE,             1, '\0', }, /* 240 */
 		{ "On", PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_F, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_F, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_F, PP_UNKNOWN,                 0, 'd',  }, /* 250 */
 		{ "dv", PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_F, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_F, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_F, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_F, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_F, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_F, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_F, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_F, PP_UNKNOWN,                 0, 'r',  },/* 260 */
 		{ "ro", PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_F, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_F, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_F, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_F, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_F, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_F, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_G, PP_UNKNOWN,                 0, 'B',  }, /* 270 */
 		{ "B",  PP_G, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_G, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_G, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_G, PP_UNKNOWN,                 0, 'D',  }, /* 280 */
 		{ "Fg", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_G, PP_PKG_GROUP_GIDSTR,        2, '\0', },
 		{ "Gn", PP_G, PP_PKG_GROUP_NAME,          2, '\0', },
 		{ "G",  PP_G, PP_UNKNOWN,                 0, 'G',  }, /* 290 */
 		{ "I",  PP_G, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_G, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_G, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_G, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_G, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_G, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_G, PP_UNKNOWN,                 0, 'U',  }, /* 300 */
 		{ "a",  PP_G, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_G, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_G, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_G, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_G, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_G, PP_PKG_MAINTAINER,          1, '\0', }, /* 310 */
 		{ "n",  PP_G, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_G, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_G, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_G, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_G, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_G, PP_PKG_VERSION,             1, '\0', }, /* 320 */
 		{ "w",  PP_G, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_G, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_G, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_L, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_L, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_L, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_L, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_L, PP_UNKNOWN,                 0, 'D',  }, /* 330 */
 		{ "Dp", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_L, PP_UNKNOWN,                 0, 'F',  }, /* 340 */
 		{ "F",  PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_L, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_L, PP_PKG_LICENSE_NAME,        2, '\0', },
 		{ "L",  PP_L, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_L, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_L, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_L, PP_UNKNOWN,                 0, 'O',  }, /* 350 */
 		{ "O",  PP_L, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_L, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_L, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_L, PP_UNKNOWN,                 0, 'd',  }, /* 360 */
 		{ "i",  PP_L, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_L, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_L, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_L, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_L, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_L, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_L, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_L, PP_UNKNOWN,                 0, 'r',  }, /* 370 */
 		{ "r",  PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_L, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_L, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_L, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_L, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_L, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_L, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_O, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_O, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_O, PP_UNKNOWN,                 0, 'C',  }, /* 380 */
 		{ "C",  PP_O, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_O, PP_UNKNOWN,                 0, 'F',  }, /* 390 */
 		{ "Fn", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_O, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_O, PP_UNKNOWN,                 0, 'L',  }, /* 400 */
 		{ "L",  PP_O, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_O, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_O, PP_PKG_OPTION_NAME,         2, '\0', },
 		{ "Ov", PP_O, PP_PKG_OPTION_VALUE,        2, '\0', },
 		{ "O",  PP_O, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_O, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_O, PP_PKG_COMMENT,             1, '\0', }, /* 410 */
 		{ "dn", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_O, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_O, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_O, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_O, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_O, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_O, PP_PKG_ORIGIN,              1, '\0', }, /* 420 */
 		{ "p",  PP_O, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_O, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_O, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_O, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_O, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_O, PP_LITERAL_PERCENT,         1, '\0', }, /* 430 */
 		{ "x",  PP_O, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_U, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_U, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_U, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_U, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_U, PP_UNKNOWN,                 0, 'D',  }, /* 440 */
 		{ "Du", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_U, PP_UNKNOWN,                 0, 'G',  }, /* 450 */
 		{ "Gn", PP_U, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_U, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_U, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_U, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_U, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_U, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_U, PP_PKG_USER_NAME,           2, '\0', }, /* 460 */
 		{ "Uu", PP_U, PP_PKG_USER_UIDSTR,         2, '\0', },
 		{ "U",  PP_U, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_U, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_U, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_U, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_U, PP_PKG_LOCK_STATUS,         1, '\0', }, /* 470 */
 		{ "l",  PP_U, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_U, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_U, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_U, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_U, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_U, PP_PKG_FLATSIZE,            1, '\0', }, /* 480 */
 		{ "t",  PP_U, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_U, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_U, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_U, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_U, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_d, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_d, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_d, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_d, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_d, PP_UNKNOWN,                 0, 'D',  }, /* 490 */
 		{ "Dk", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_d, PP_UNKNOWN,                 0, 'F',  }, /* 500 */
 		{ "Fs", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_d, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_d, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_d, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_d, PP_PKG_MESSAGE,             1, '\0', }, /* 510 */
 		{ "On", PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_d, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_d, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_d, PP_PKG_DEPENDENCY_NAME,     2, '\0', },
 		{ "do", PP_d, PP_PKG_DEPENDENCY_ORIGIN,   2, '\0', }, /* 520 */
 		{ "dv", PP_d, PP_PKG_DEPENDENCY_VERSION,  2, '\0', },
 		{ "d",  PP_d, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_d, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_d, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_d, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_d, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_d, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_d, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_d, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_d, PP_UNKNOWN,                 0, 'r',  }, /* 530 */
 		{ "ro", PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_d, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_d, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_d, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_d, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_d, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_d, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_r, PP_UNKNOWN,                 0, 'B',  }, /* 540 */
 		{ "B",  PP_r, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_r, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_r, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_r, PP_UNKNOWN,                 0, 'D',  }, /* 550 */
 		{ "Fg", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_r, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_r, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_r, PP_UNKNOWN,                 0, 'G',  }, /* 560 */
 		{ "I",  PP_r, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_r, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_r, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_r, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_r, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_r, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_r, PP_UNKNOWN,                 0, 'U',  }, /* 570 */
 		{ "a",  PP_r, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "c",  PP_r, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_r, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_r, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_r, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_r, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_r, PP_PKG_NAME,                1, '\0', }, /* 580 */
 		{ "o",  PP_r, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_r, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_r, PP_PKG_REQUIREMENT_NAME,    2, '\0', },
 		{ "ro", PP_r, PP_PKG_REQUIREMENT_ORIGIN,  2, '\0', },
 		{ "rv", PP_r, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
 		{ "r",  PP_r, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_r, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_r, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_r, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_r, PP_PKG_HOME_PAGE,           1, '\0', }, /* 590 */
 		{ "%",  PP_r, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_r, PP_UNKNOWN,                 0, 'x',  },
 		{ NULL, 0,    0,                          0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fc_test_vals[i].in != NULL; i++) {
 		p->width = 0;
 		f = format_code(fc_test_vals[i].in, fc_test_vals[i].context, p);
 		ATF_CHECK_EQ_MSG(p->fmt_code, fc_test_vals[i].fmt_code,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fc_test_vals[i].in,
 				 fc_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fc_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(format_trailer);
 ATF_TC_HEAD(format_trailer, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing format_trailer() format parsing routine");
 }
 ATF_TC_BODY(format_trailer, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct ft_test_vals {
 		const char *in;
 		const char *item;
 		const char *sep;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} ft_test_vals[] = {
 		{ "%{aaaaaaaa", "",   "",    0, '%',  },
 		{ "%{bb%|cccc", "",   "",    0, '%',  },
 		{ "ddd%|eee%}", "",   "",    0, 'd',  },
 		{ "%{ff%|gg%}", "ff", "gg", 10, '\0', },
 		{ "%{hh%}",     "hh", "",    6, '\0', },
 		{ "%{%|iii%}",  "",   "iii", 9, '\0', },
 		{ NULL,         NULL, NULL,  0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; ft_test_vals[i].in != NULL; i++) {
 		sbuf_clear(p->item_fmt);
 		sbuf_clear(p->sep_fmt);
 		f = format_trailer(ft_test_vals[i].in, p);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->item_fmt),
 				    ft_test_vals[i].item,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->sep_fmt),
 				    ft_test_vals[i].sep,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - ft_test_vals[i].in,
 				 ft_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, ft_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(parse_format);
 ATF_TC_HEAD(parse_format, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing parse_format() format parsing routine");
 }
 ATF_TC_BODY(parse_format, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct pf_test_vals {
 		const char *in;
 		unsigned context;
 		unsigned flags;
 		int width;
 		fmt_code_t fmt_code;
 		const char *item;
 		const char *sep;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} pf_test_vals[] = {
 		{ "%n",    PP_PKG, 0,             0,  PP_PKG_NAME, "",   "",   2, '\0', },
 		{ "%-20n", PP_PKG, PP_LEFT_ALIGN, 20, PP_PKG_NAME, "",   "",   5, '\0', },
 		{ "%?B",   PP_PKG, PP_ALTERNATE_FORM1, 0, PP_PKG_SHLIBS, "", "", 3, '\0', },
 		{ "%#F",   PP_PKG, PP_ALTERNATE_FORM2, 0, PP_PKG_FILES,  "", "", 3, '\0', },
 		{ "%L%{%Ln%| %l %}", PP_PKG, 0, 0, PP_PKG_LICENSES, "%Ln", " %l ", 15, '\0', },
 		{ "%Ln",   PP_L,   0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
 		{ "%l",    PP_L,   0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
 		{ "%Ln",   PP_PKG, 0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
 		{ "%l",    PP_PKG, 0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
 		{ "%I",    PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, 'I', },
 		{ "%^D",   PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, '^', },
 		{ NULL,    0,      0,             0,  0,           NULL, NULL, 0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; pf_test_vals[i].in != NULL; i++) {
 		p = new_percent_esc(p);
 		f = parse_format(pf_test_vals[i].in, pf_test_vals[i].context,
 				 p);
 		ATF_CHECK_EQ_MSG(p->flags, pf_test_vals[i].flags,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(p->width, pf_test_vals[i].width,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(p->fmt_code, pf_test_vals[i].fmt_code,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->item_fmt),
 				    pf_test_vals[i].item,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->sep_fmt),
 				    pf_test_vals[i].sep,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - pf_test_vals[i].in,
 				 pf_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, pf_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TP_ADD_TCS(tp)
 {
 	/* Output routines */
 	ATF_TP_ADD_TC(tp, gen_format);
 	ATF_TP_ADD_TC(tp, human_number);
 	ATF_TP_ADD_TC(tp, string_val);
 	ATF_TP_ADD_TC(tp, int_val);
 	ATF_TP_ADD_TC(tp, bool_val);
 	ATF_TP_ADD_TC(tp, mode_val);
 	ATF_TP_ADD_TC(tp, liclog_val);
 	ATF_TP_ADD_TC(tp, list_count);
 	/* Format string parsing routines */
 	ATF_TP_ADD_TC(tp, maybe_read_hex_byte);
 	ATF_TP_ADD_TC(tp, read_oct_byte);
 	ATF_TP_ADD_TC(tp, process_escape);
 	ATF_TP_ADD_TC(tp, field_modifier);
 	ATF_TP_ADD_TC(tp, field_width);
 	ATF_TP_ADD_TC(tp, format_code);
 	ATF_TP_ADD_TC(tp, format_trailer);
 	ATF_TP_ADD_TC(tp, parse_format);
 	return atf_no_error();
 }
 /*
  * That's All Folks!
  */

added tests/lib/pp_test.c

@@ -0,0 +1,2222 @@

 /*-
  * Copyright (c) 2012 Matthew Seaman <matthew@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <string.h>
 #include <atf-c.h>
 #include <pkg.h>
 #include <private/pkg_printf.h>
 ATF_TC(gen_format);
 ATF_TC_HEAD(gen_format, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Generate printf format code for final output");
 }
 ATF_TC_BODY(gen_format, tc)
 {
 	char		 buf[32];
 	unsigned	 i;
 	char		*tail = "x";
 	struct gf_test_vals {
 		const char *out;
 		unsigned    flags;
 	} gf_test_vals[] = {
 		{ "%*x",     0, },
 		{ "%*x",     PP_ALTERNATE_FORM1, }, /* Has no effect */
 		{ "%#*x",    PP_ALTERNATE_FORM2, },
 		{ "%-*x",    PP_LEFT_ALIGN, },
 		{ "%#-*x",   PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+*x",    PP_EXPLICIT_PLUS, },
 		{ "%#+*x",   PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "% *x",    PP_SPACE_FOR_PLUS, },
 		{ "%# *x",   PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- *x",   PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- *x",  PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+*x",    PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0*x",    PP_ZERO_PAD, },
 		{ "%#0*x",   PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
 		{ "%-*x",    PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "%#-*x",   PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
 		{ "%#0+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0 *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
 		{ "%#0 *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#0+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%'*x",    PP_THOUSANDS_SEP, },
 		{ "%#'*x",   PP_THOUSANDS_SEP|PP_ALTERNATE_FORM2, },
 		{ "%-'*x",   PP_THOUSANDS_SEP|PP_LEFT_ALIGN, },
 		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+'*x",   PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS, },
 		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "% '*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS, },
 		{ "%# '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- '*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%+'*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD, },
 		{ "%#0'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
 		{ "%-'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
 		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0 '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
 		{ "%#0 '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%- '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
 		{ "%#- '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
 		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
 		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
 		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
 		{ NULL, 0, },
 	};
 	for (i = 0; gf_test_vals[i].out != NULL; i++) {
 		ATF_CHECK_STREQ(gen_format(buf, sizeof(buf),
 					   gf_test_vals[i].flags, tail),
 				gf_test_vals[i].out);
 	}
 }
 ATF_TC(human_number);
 ATF_TC_HEAD(human_number, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing human_number() output routine");
 }
 ATF_TC_BODY(human_number, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct hn_test_vals {
 		int64_t	in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} hn_test_vals[] = {
 		{ 0,                   "0.00",   0, 0, },
 		{ 1,                   "1.00",   0, 0, },
 		{ 10,                  "10.0",   0, 0, },
 		{ 100,                 "100",    0, 0. },
 		{ 1000,                "1.00k",  0, 0, },
 		{ 10000,               "10.0k",  0, 0, },
 		{ 100000,              "100k",   0, 0, },
 		{ 1000000,             "1.00M",  0, 0, },
 		{ 1000000000,          "1.00G",  0, 0, },
 		{ 1000000000000,       "1.00T",  0, 0, },
 		{ 1000000000000000,    "1.00P",  0, 0, },
 		{ 1000000000000000000, "1.00E",  0, 0, },
 		{ 999,                 "999",    0, 0, },
 		{ 1001,                "1.00k",  0, 0, },
 		{ 1010,                "1.01k",  0, 0, },
 		{ 1490,                "1.49k",  0, 0, },
 		{ 1499,                "1.50k",  0, 0, },
 		{ 1500,                "1.50k",  0, 0, },
 		{ -1,                  "-1.00",  0, 0, },
 		{ -1234,               "-1.23k", 0, 0, },
 		{ -1234567,            "-1.23M", 0, 0, },
 		{ -1234567890,         "-1.23G", 0, 0, },
 		{ -1234567890123,      "-1.23T", 0, 0, },
 		{ -1234567890123456,   "-1.23P", 0, 0, },
 		{ -1234567890123456789,"-1.23E", 0, 0, },
 		{ 512,                 "512",    0, PP_ALTERNATE_FORM2, },
 		{ 1024,                "1.00Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 1536,                "1.50Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 24576,               "24.0Ki", 0, PP_ALTERNATE_FORM2, },
 		{ 393216,              "384Ki",  0, PP_ALTERNATE_FORM2, },
 		{ 2359296,             "2.25Mi", 0, PP_ALTERNATE_FORM2, },
 		{ 3623878656,          "3.38Gi", 0, PP_ALTERNATE_FORM2, },
 		{ 5566277615616,       "5.06Ti", 0, PP_ALTERNATE_FORM2, },
 		{ 8549802417586176,    "7.59Pi", 0, PP_ALTERNATE_FORM2, },
 		{ 1313249651341236633, "1.14Ei", 0, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          0, 0, },
 		{ 123,     "123",          1, 0, },
 		{ 123,     "123",          2, 0, },
 		{ 123,     "123",          3, 0, },
 		{ 123,     " 123",         4, 0, },
 		{ 123,     "  123",        5, 0, },
 		{ 123,     "   123",       6, 0, },
 		{ 123,     "    123",      7, 0, },
 		{ 123,     "     123",     8, 0, },
 		{ 123,     "      123",    9, 0, },
 		{ 123,     " 123",         0, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         1, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         2, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         3, PP_SPACE_FOR_PLUS, },
 		{ 123,     " 123",         4, PP_SPACE_FOR_PLUS, },
 		{ 123,     "  123",        5, PP_SPACE_FOR_PLUS, },
 		{ 123,     "   123",       6, PP_SPACE_FOR_PLUS, },
 		{ 123,     "    123",      7, PP_SPACE_FOR_PLUS, },
 		{ 123,     "     123",     8, PP_SPACE_FOR_PLUS, },
 		{ 123,     "      123",    9, PP_SPACE_FOR_PLUS, },
 		{ -123,    "-123",         0, 0, },
 		{ -123,    "-123",         1, 0, },
 		{ -123,    "-123",         2, 0, },
 		{ -123,    "-123",         3, 0, },
 		{ -123,    "-123",         4, 0, },
 		{ -123,    " -123",        5, 0, },
 		{ -123,    "  -123",       6, 0, },
 		{ -123,    "   -123",      7, 0, },
 		{ -123,    "    -123",     8, 0, },
 		{ -123,    "     -123",    9, 0, },
 		{ 123,     "123",          0, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          1, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          2, PP_ALTERNATE_FORM2, },
 		{ 123,     "123",          3, PP_ALTERNATE_FORM2, },
 		{ 123,     " 123",         4, PP_ALTERNATE_FORM2, },
 		{ 123,     "  123",        5, PP_ALTERNATE_FORM2, },
 		{ 123,     "   123",       6, PP_ALTERNATE_FORM2, },
 		{ 123,     "    123",      7, PP_ALTERNATE_FORM2, },
 		{ 123,     "     123",     8, PP_ALTERNATE_FORM2, },
 		{ 123,     "      123",    9, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.23M",        0, 0, },
 		{ 1234567, "1M",           1, 0, },
 		{ 1234567, "1M",           2, 0, },
 		{ 1234567, " 1M",          3, 0, },
 		{ 1234567, "1.2M",         4, 0, },
 		{ 1234567, "1.23M",        5, 0, },
 		{ 1234567, " 1.23M",       6, 0, },
 		{ 1234567, "  1.23M",      7, 0, },
 		{ 1234567, "   1.23M",     8, 0, },
 		{ 1234567, "    1.23M",    9, 0, },
 		{ 12345678, "12.3M",       0, 0, },
 		{ 12345678, "12M",         1, 0, },
 		{ 12345678, "12M",         2, 0, },
 		{ 12345678, "12M",         3, 0, },
 		{ 12345678, " 12M",        4, 0, },
 		{ 12345678, "12.3M",       5, 0, },
 		{ 12345678, " 12.3M",      6, 0, },
 		{ 12345678, "  12.3M",     7, 0, },
 		{ 12345678, "   12.3M",    8, 0, },
 		{ 12345678, "    12.3M",   9, 0, },
 		{ 123456789, "123M",       0, 0, },
 		{ 123456789, "123M",       1, 0, },
 		{ 123456789, "123M",       2, 0, },
 		{ 123456789, "123M",       3, 0, },
 		{ 123456789, "123M",       4, 0, },
 		{ 123456789, " 123M",      5, 0, },
 		{ 123456789, "  123M",     6, 0, },
 		{ 123456789, "   123M",    7, 0, },
 		{ 123456789, "    123M",   8, 0, },
 		{ 123456789, "     123M",  9, 0, },
 		{ 1234567, "1.18Mi",       0, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          1, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          2, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1Mi",          3, PP_ALTERNATE_FORM2, },
 		{ 1234567, " 1Mi",         4, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.2Mi",        5, PP_ALTERNATE_FORM2, },
 		{ 1234567, "1.18Mi",       6, PP_ALTERNATE_FORM2, },
 		{ 1234567, " 1.18Mi",      7, PP_ALTERNATE_FORM2, },
 		{ 1234567, "  1.18Mi",     8, PP_ALTERNATE_FORM2, },
 		{ 1234567, "   1.18Mi",    9, PP_ALTERNATE_FORM2, },
 		{ 12345678, "11.8Mi",      0, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        1, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        2, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        3, PP_ALTERNATE_FORM2, },
 		{ 12345678, "12Mi",        4, PP_ALTERNATE_FORM2, },
 		{ 12345678, " 12Mi",       5, PP_ALTERNATE_FORM2, },
 		{ 12345678, "11.8Mi",      6, PP_ALTERNATE_FORM2, },
 		{ 12345678, " 11.8Mi",     7, PP_ALTERNATE_FORM2, },
 		{ 12345678, "  11.8Mi",    8, PP_ALTERNATE_FORM2, },
 		{ 12345678, "   11.8Mi",   9, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      0, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      1, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      2, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      3, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      4, PP_ALTERNATE_FORM2, },
 		{ 123456789, "118Mi",      5, PP_ALTERNATE_FORM2, },
 		{ 123456789, " 118Mi",     6, PP_ALTERNATE_FORM2, },
 		{ 123456789, "  118Mi",    7, PP_ALTERNATE_FORM2, },
 		{ 123456789, "   118Mi",   8, PP_ALTERNATE_FORM2, },
 		{ 123456789, "    118Mi",  9, PP_ALTERNATE_FORM2, },
 		{  1234567, "1.23M",  0, PP_ALTERNATE_FORM1, },
 		{  1234567, "1.18Mi", 0, PP_ALTERNATE_FORM2, },
 		{  1234567, "1.23 M", 6, PP_LEFT_ALIGN, },
 		{  1234567, "+1.23M", 0, PP_EXPLICIT_PLUS, },
 		{ -1234567, "-1.23M", 0, PP_EXPLICIT_PLUS, },
 		{  1234567, " 1.23M", 0, PP_SPACE_FOR_PLUS, },
 		{ -1234567, "-1.23M", 0, PP_SPACE_FOR_PLUS, },
 		{  1234567, "01.23M", 6, PP_ZERO_PAD, },
 		{  1234567, "1.23M",  0, PP_THOUSANDS_SEP, },
 		{  1023,"1023", 0, PP_ALTERNATE_FORM2|PP_THOUSANDS_SEP, },
 		{ -1,                  NULL,     0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; hn_test_vals[i].out != NULL; i++) {
 		p->width = hn_test_vals[i].width;
 		p->flags = hn_test_vals[i].flags;
 		sbuf = human_number(sbuf, hn_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), hn_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(string_val);
 ATF_TC_HEAD(string_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing string_val() output routine");
 }
 ATF_TC_BODY(string_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct sv_test_vals {
 		const char *in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} sv_test_vals[] = {
 		{ "xxx", "xxx",    0, 0, },
 		{ "xxx", "xxx",    1, 0, },
 		{ "xxx", "xxx",    2, 0, },
 		{ "xxx", "xxx",    3, 0, },
 		{ "xxx", " xxx",   4, 0, },
 		{ "xxx", "  xxx",  5, 0, },
 		{ "xxx", "   xxx", 6, 0, },
 		{ "xxy", "xxy",    0, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    1, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    2, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy",    3, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy ",   4, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy  ",  5, PP_LEFT_ALIGN, },
 		{ "xxy", "xxy   ", 6, PP_LEFT_ALIGN, },
 		{ "xxz", "xxz",    0, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    1, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    2, PP_ZERO_PAD, },
 		{ "xxz", "xxz",    3, PP_ZERO_PAD, },
 		{ "xxz", "0xxz",   4, PP_ZERO_PAD, },
 		{ "xxz", "00xxz",  5, PP_ZERO_PAD, },
 		{ "xxz", "000xxz", 6, PP_ZERO_PAD, },
 		/* Seems you can't zero pad on the RHS of a string */
 		{ "xyx", "xyx",    0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx",    3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx ",   4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx  ",  5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ "xyx", "xyx   ", 6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		/* Most of the format modifiers don't affect strings */
 		{ "aaa", "aaa", 0, PP_ALTERNATE_FORM1, },
 		{ "bbb", "bbb", 0, PP_ALTERNATE_FORM2, },
 		{ "ccc", "ccc", 0, PP_EXPLICIT_PLUS, },
 		{ "ddd", "ddd", 0, PP_SPACE_FOR_PLUS, },
 		{ "eee", "eee", 0, PP_THOUSANDS_SEP, },
 		{ NULL, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; sv_test_vals[i].out != NULL; i++) {
 		p->width = sv_test_vals[i].width;
 		p->flags = sv_test_vals[i].flags;
 		sbuf = string_val(sbuf, sv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), sv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(int_val);
 ATF_TC_HEAD(int_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing int_val() output routine");
 }
 ATF_TC_BODY(int_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct iv_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} iv_test_vals[] = {
 		{ 0,      "0",   0, 0, },
 		{ 1,      "1",   0, 0, },
 		{ -1,     "-1",  0, 0, },
 		{ 340,    "340",       0, 0, },
 		{ 341,    "341",       1, 0, },
 		{ 342,    "342",       2, 0, },
 		{ 343,    "343",       3, 0, },
 		{ 344,    " 344",      4, 0, },
 		{ 345,    "  345",     5, 0, },
 		{ 346,    "   346",    6, 0, },
 		{ 347,    "    347",   7, 0, },
 		{ 348,    "     348",  8, 0, },
 		{ 349,    "      349", 9, 0, },
 		{ 350,    "350",       0, PP_LEFT_ALIGN, },
 		{ 351,    "351",       1, PP_LEFT_ALIGN, },
 		{ 352,    "352",       2, PP_LEFT_ALIGN, },
 		{ 353,    "353",       3, PP_LEFT_ALIGN, },
 		{ 354,    "354 ",      4, PP_LEFT_ALIGN, },
 		{ 355,    "355  ",     5, PP_LEFT_ALIGN, },
 		{ 356,    "356   ",    6, PP_LEFT_ALIGN, },
 		{ 357,    "357    ",   7, PP_LEFT_ALIGN, },
 		{ 358,    "358     ",  8, PP_LEFT_ALIGN, },
 		{ 359,    "359      ", 9, PP_LEFT_ALIGN, },
 		{ 360,    "+360",      0, PP_EXPLICIT_PLUS, },
 		{ 361,    "+361",      1, PP_EXPLICIT_PLUS, },
 		{ 362,    "+362",      2, PP_EXPLICIT_PLUS, },
 		{ 363,    "+363",      3, PP_EXPLICIT_PLUS, },
 		{ 364,    "+364",      4, PP_EXPLICIT_PLUS, },
 		{ 365,    " +365",     5, PP_EXPLICIT_PLUS, },
 		{ 366,    "  +366",    6, PP_EXPLICIT_PLUS, },
 		{ 367,    "   +367",   7, PP_EXPLICIT_PLUS, },
 		{ 368,    "    +368",  8, PP_EXPLICIT_PLUS, },
 		{ 369,    "     +369", 9, PP_EXPLICIT_PLUS, },
 		{ -370,   "-370",      0, PP_EXPLICIT_PLUS, },
 		{ -371,   "-371",      1, PP_EXPLICIT_PLUS, },
 		{ -372,   "-372",      2, PP_EXPLICIT_PLUS, },
 		{ -373,   "-373",      3, PP_EXPLICIT_PLUS, },
 		{ -374,   "-374",      4, PP_EXPLICIT_PLUS, },
 		{ -375,   " -375",     5, PP_EXPLICIT_PLUS, },
 		{ -376,   "  -376",    6, PP_EXPLICIT_PLUS, },
 		{ -377,   "   -377",   7, PP_EXPLICIT_PLUS, },
 		{ -378,   "    -378",  8, PP_EXPLICIT_PLUS, },
 		{ -379,   "     -379", 9, PP_EXPLICIT_PLUS, },
 		{ 380,    " 380",      0, PP_SPACE_FOR_PLUS, },
 		{ 381,    " 381",      1, PP_SPACE_FOR_PLUS, },
 		{ 382,    " 382",      2, PP_SPACE_FOR_PLUS, },
 		{ 383,    " 383",      3, PP_SPACE_FOR_PLUS, },
 		{ 384,    " 384",      4, PP_SPACE_FOR_PLUS, },
 		{ 385,    "  385",     5, PP_SPACE_FOR_PLUS, },
 		{ 386,    "   386",    6, PP_SPACE_FOR_PLUS, },
 		{ 387,    "    387",   7, PP_SPACE_FOR_PLUS, },
 		{ 388,    "     388",  8, PP_SPACE_FOR_PLUS, },
 		{ 389,    "      389", 9, PP_SPACE_FOR_PLUS, },
 		{ -390,   "-390",      0, PP_SPACE_FOR_PLUS, },
 		{ -391,   "-391",      1, PP_SPACE_FOR_PLUS, },
 		{ -392,   "-392",      2, PP_SPACE_FOR_PLUS, },
 		{ -393,   "-393",      3, PP_SPACE_FOR_PLUS, },
 		{ -394,   "-394",      4, PP_SPACE_FOR_PLUS, },
 		{ -395,   " -395",     5, PP_SPACE_FOR_PLUS, },
 		{ -396,   "  -396",    6, PP_SPACE_FOR_PLUS, },
 		{ -397,   "   -397",   7, PP_SPACE_FOR_PLUS, },
 		{ -398,   "    -398",  8, PP_SPACE_FOR_PLUS, },
 		{ -399,   "     -399", 9, PP_SPACE_FOR_PLUS, },
 		{ 400,    "+400",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 401,    "+401",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 402,    "+402",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 403,    "+403",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 404,    "+404",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 405,    "+405 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 406,    "+406  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 407,    "+407   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 408,    "+408    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 409,    "+409     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -410,   "-410",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -411,   "-411",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -412,   "-412",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -413,   "-413",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -414,   "-414",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -415,   "-415 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -416,   "-416  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -417,   "-417   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -418,   "-418    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ -419,   "-419     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
 		{ 420,    " 420",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 421,    " 421",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 422,    " 422",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 423,    " 423",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 424,    " 424",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 425,    " 425 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 426,    " 426  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 427,    " 427   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 428,    " 428    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 429,    " 429     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -430,   "-430",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -431,   "-431",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -432,   "-432",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -433,   "-433",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -434,   "-434",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -435,   "-435 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -436,   "-436  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -437,   "-437   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -438,   "-438    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ -439,   "-439     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
 		{ 440,    "440",       0, PP_ZERO_PAD, },
 		{ 441,    "441",       1, PP_ZERO_PAD, },
 		{ 442,    "442",       2, PP_ZERO_PAD, },
 		{ 443,    "443",       3, PP_ZERO_PAD, },
 		{ 444,    "0444",      4, PP_ZERO_PAD, },
 		{ 445,    "00445",     5, PP_ZERO_PAD, },
 		{ 446,    "000446",    6, PP_ZERO_PAD, },
 		{ 447,    "0000447",   7, PP_ZERO_PAD, },
 		{ 448,    "00000448",  8, PP_ZERO_PAD, },
 		{ 449,    "000000449", 9, PP_ZERO_PAD, },
 		{ -450,    "-450",      0, PP_ZERO_PAD, },
 		{ -451,    "-451",      1, PP_ZERO_PAD, },
 		{ -452,    "-452",      2, PP_ZERO_PAD, },
 		{ -453,    "-453",      3, PP_ZERO_PAD, },
 		{ -454,    "-454",      4, PP_ZERO_PAD, },
 		{ -455,    "-0455",     5, PP_ZERO_PAD, },
 		{ -456,    "-00456",    6, PP_ZERO_PAD, },
 		{ -457,    "-000457",   7, PP_ZERO_PAD, },
 		{ -458,    "-0000458",  8, PP_ZERO_PAD, },
 		{ -459,    "-00000459", 9, PP_ZERO_PAD, },
 		{ 460,    "+460",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 461,    "+461",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 462,    "+462",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 463,    "+463",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 464,    "+464",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 465,    "+0465",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 466,    "+00466",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 467,    "+000467",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 468,    "+0000468",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 469,    "+00000469", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -470,    "-470",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -471,    "-471",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -472,    "-472",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -473,    "-473",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -474,    "-474",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -475,    "-0475",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -476,    "-00476",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -477,    "-000477",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -478,    "-0000478",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ -479,    "-00000479", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
 		{ 480,    " 480",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 481,    " 481",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 482,    " 482",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 483,    " 483",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 484,    " 484",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 485,    " 0485",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 486,    " 00486",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 487,    " 000487",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 488,    " 0000488",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ 489,    " 00000489", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -490,    "-490",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -491,    "-491",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -492,    "-492",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -493,    "-493",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -494,    "-494",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -495,    "-0495",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -496,    "-00496",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -497,    "-000497",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -498,    "-0000498",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		{ -499,    "-00000499", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
 		/* PP_LEFT_ALIGN beats PP_ZERO_PAD */
 		{ 500,    "500",       0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 501,    "501",       1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 502,    "502",       2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 503,    "503",       3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 504,    "504 ",      4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 505,    "505  ",     5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 506,    "506   ",    6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 507,    "507    ",   7, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 508,    "508     ",  8, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		{ 509,    "509      ", 9, PP_ZERO_PAD|PP_LEFT_ALIGN, },
 		/* PP_EXPLICIT_PLUS beats PP_SPACE_FOR_PLUS */
 		{ 700,    "+700",       0, PP_EXPLICIT_PLUS|PP_SPACE_FOR_PLUS, },
 		/* See human_number for comprehensive tests of
 		   PP_ALTERNATE_FORM1 and PP_ALTERNATE_FORM2 */
 		{ -1, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; iv_test_vals[i].out != NULL; i++) {
 		p->width = iv_test_vals[i].width;
 		p->flags = iv_test_vals[i].flags;
 		sbuf = int_val(sbuf, iv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), iv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(bool_val);
 ATF_TC_HEAD(bool_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing bool_val() output routine");
 }
 ATF_TC_BODY(bool_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct bv_test_vals {
 		bool in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} bv_test_vals[] = {
 		{ false, "0",     0, 0, },
 		{ true,  "1",     0, 0, },
 		{ false, "no",    0, PP_ALTERNATE_FORM1, },
 		{ true,  "yes",   0, PP_ALTERNATE_FORM1, },
 		{ false, "false", 0, PP_ALTERNATE_FORM2, },
 		{ true,  "true",  0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See string_val() for tests on field-width and
 		 * left-align
 		 */
 		{ false, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; bv_test_vals[i].out != NULL; i++) {
 		p->width = bv_test_vals[i].width;
 		p->flags = bv_test_vals[i].flags;
 		sbuf = bool_val(sbuf, bv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), bv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(mode_val);
 ATF_TC_HEAD(mode_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing mode_val() output routine");
 }
 ATF_TC_BODY(mode_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct mv_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} mv_test_vals[] = {
 		{ 00000, "0",          0, 0, },
 		{ 00007, "7",          0, 0, },
 		{ 00070, "70",         0, 0, },
 		{ 00700, "700",        0, 0, },
 		{ 07000, "7000",       0, 0, },
 		{ 00000, "    0",      5, 0, },
 		{ 00007, "    7",      5, 0, },
 		{ 00070, "   70",      5, 0, },
 		{ 00700, "  700",      5, 0, },
 		{ 07000, " 7000",      5, 0, },
 		{ 00000, "        0",  9, 0, },
 		{ 00007, "        7",  9, 0, },
 		{ 00070, "       70",  9, 0, },
 		{ 00700, "      700",  9, 0, },
 		{ 07000, "     7000",  9, 0, },
 		/*
                  * Shows a ? character for 'unknown inode type'.  Note
 		 * the trailing space.
 		 */
 		{ 00000, "?--------- ", 0, PP_ALTERNATE_FORM1, },
 		{ 00007, "?------rwx ", 0, PP_ALTERNATE_FORM1, },
 		{ 00070, "?---rwx--- ", 0, PP_ALTERNATE_FORM1, },
 		{ 00700, "?rwx------ ", 0, PP_ALTERNATE_FORM1, },
 		{ 07000, "?--S--S--T ", 0, PP_ALTERNATE_FORM1, },
 		{ 07111, "?--s--s--t ", 0, PP_ALTERNATE_FORM1, },
 		{ 00000, "0",          0, PP_ALTERNATE_FORM2, },
 		{ 00007, "07",         0, PP_ALTERNATE_FORM2, },
 		{ 00070, "070",        0, PP_ALTERNATE_FORM2, },
 		{ 00700, "0700",       0, PP_ALTERNATE_FORM2, },
 		{ 07000, "07000",      0, PP_ALTERNATE_FORM2, },
 		{ 00000, "    0",      5, PP_ALTERNATE_FORM2, },
 		{ 00007, "   07",      5, PP_ALTERNATE_FORM2, },
 		{ 00070, "  070",      5, PP_ALTERNATE_FORM2, },
 		{ 00700, " 0700",      5, PP_ALTERNATE_FORM2, },
 		{ 07000, "07000",      5, PP_ALTERNATE_FORM2, },
 		{ 00000, "        0",  9, PP_ALTERNATE_FORM2, },
 		{ 00007, "       07",  9, PP_ALTERNATE_FORM2, },
 		{ 00070, "      070",  9, PP_ALTERNATE_FORM2, },
 		{ 00700, "     0700",  9, PP_ALTERNATE_FORM2, },
 		{ 07000, "    07000",  9, PP_ALTERNATE_FORM2, },
 		/*
 		 * The device type bits: 0170000
 		 */
 		{ 0010000, "0", 0, 0, }, /* FIFO */
 		{ 0020000, "0", 0, 0, }, /* Char special */
 		{ 0060000, "0", 0, 0, }, /* Block special */
 		{ 0100000, "0", 0, 0, }, /* Regular file */
 		{ 0120000, "0", 0, 0, }, /* Sym-link */
 		{ 0140000, "0", 0, 0, }, /* socket */
 		{ 0160000, "0", 0, 0, }, /* whiteout */
 		{ 0010000, "p--------- ", 0, PP_ALTERNATE_FORM1, }, /* FIFO */
 		{ 0020000, "c--------- ", 0, PP_ALTERNATE_FORM1, }, /* Char special */
 		{ 0060000, "b--------- ", 0, PP_ALTERNATE_FORM1, }, /* Block special */
 		{ 0100000, "---------- ", 0, PP_ALTERNATE_FORM1, }, /* Regular file */
 		{ 0120000, "l--------- ", 0, PP_ALTERNATE_FORM1, }, /* Sym-link */
 		{ 0140000, "s--------- ", 0, PP_ALTERNATE_FORM1, }, /* socket */
 		{ 0160000, "w--------- ", 0, PP_ALTERNATE_FORM1, }, /* whiteout */
 		{ 0010000, "10000",  0, PP_EXPLICIT_PLUS, }, /* FIFO */
 		{ 0020000, "20000",  0, PP_EXPLICIT_PLUS, }, /* Char special */
 		{ 0060000, "60000",  0, PP_EXPLICIT_PLUS, }, /* Block special */
 		{ 0100000, "100000", 0, PP_EXPLICIT_PLUS, }, /* Regular file */
 		{ 0120000, "120000", 0, PP_EXPLICIT_PLUS, }, /* Sym-link */
 		{ 0140000, "140000", 0, PP_EXPLICIT_PLUS, }, /* socket */
 		{ 0160000, "160000", 0, PP_EXPLICIT_PLUS, }, /* whiteout */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; mv_test_vals[i].out != NULL; i++) {
 		p->width = mv_test_vals[i].width;
 		p->flags = mv_test_vals[i].flags;
 		sbuf = mode_val(sbuf, mv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), mv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(liclog_val);
 ATF_TC_HEAD(liclog_val, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing liclog_val() output routine");
 }
 ATF_TC_BODY(liclog_val, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct lv_test_vals {
 		lic_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} lv_test_vals[] = {
 		{ LICENSE_SINGLE, "single", 0, 0, },
 		{ LICENSE_OR,     "or",     0, 0, },
 		{ LICENSE_AND,    "and",    0, 0, },
 		{ LICENSE_SINGLE, "",       0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_OR,     "|",      0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_AND,    "&",      0, PP_ALTERNATE_FORM1, },
 		{ LICENSE_SINGLE, "==",     0, PP_ALTERNATE_FORM2, },
 		{ LICENSE_OR,     "||",     0, PP_ALTERNATE_FORM2, },
 		{ LICENSE_AND,    "&&",     0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See string_val() for tests on field-width and
 		 * left-align
 		 */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; lv_test_vals[i].out != NULL; i++) {
 		p->width = lv_test_vals[i].width;
 		p->flags = lv_test_vals[i].flags;
 		sbuf = liclog_val(sbuf, lv_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), lv_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(list_count);
 ATF_TC_HEAD(list_count, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 			  "Testing list_count() output routine");
 }
 ATF_TC_BODY(list_count, tc)
 {
 	struct sbuf		*sbuf;
 	struct percent_esc	*p;
 	int			 i;
 	struct lc_test_vals {
 		int64_t in;
 		const char *out;
 		int width;
 		unsigned flags;
 	} lc_test_vals[] = {
 		{ 10, "10", 0, 0, },
 		{ 20, "1",  0, PP_ALTERNATE_FORM1, },
 		{ 30, "30", 0, PP_ALTERNATE_FORM2, },
 		/*
 		 * See int_val() for tests on field-width and
 		 * left-align
 		 */
 		{ 0, NULL, 0, 0, },
 	};
 	sbuf = sbuf_new_auto();
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; lc_test_vals[i].out != NULL; i++) {
 		p->width = lc_test_vals[i].width;
 		p->flags = lc_test_vals[i].flags;
 		sbuf = list_count(sbuf, lc_test_vals[i].in, p);
 		ATF_CHECK_STREQ(sbuf_data(sbuf), lc_test_vals[i].out);
 		sbuf_clear(sbuf);
 	}
 	free_percent_esc(p);
 	sbuf_delete(sbuf);
 }
 ATF_TC(maybe_read_hex_byte);
 ATF_TC_HEAD(maybe_read_hex_byte, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing maybe_read_hex_byte() format parsing routine");
 }
 ATF_TC_BODY(maybe_read_hex_byte, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct mrhb_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} mrhb_test_vals[] = {
 		{ "x61",   "a",    3, '\0', },
 		{ "x",     "\\x",  1, '\0', },
 		{ "xg",    "\\x",  1, 'g',  },
 		{ "xf",    "\\x",  1, 'f',  },
 		{ "xfg",   "\\x",  1, 'f',  },
 		{ "xff",   "\xff", 3, '\0', },
 		{ "xffg",  "\xff", 3, 'g',  },
 		{ "xfffg", "\xff", 3, 'f',  },
 		{ "x00",   "\0",   3, '\0', },
 		{ "x01",   "\x01", 3, '\0', },
 		{ "x02",   "\x02", 3, '\0', },
 		{ "x03",   "\x03", 3, '\0', },
 		{ "x04",   "\x04", 3, '\0', },
 		{ "x05",   "\x05", 3, '\0', },
 		{ "x06",   "\x06", 3, '\0', },
 		{ "x07",   "\x07", 3, '\0', },
 		{ "x08",   "\x08", 3, '\0', },
 		{ "x09",   "\x09", 3, '\0', },
 		{ "x0a",   "\x0a", 3, '\0', },
 		{ "x0b",   "\x0b", 3, '\0', },
 		{ "x0c",   "\x0c", 3, '\0', },
 		{ "x0d",   "\x0d", 3, '\0', },
 		{ "x0e",   "\x0e", 3, '\0', },
 		{ "x0f",   "\x0f", 3, '\0', },
 		{ "x0A",   "\x0a", 3, '\0', },
 		{ "x0B",   "\x0b", 3, '\0', },
 		{ "x0C",   "\x0c", 3, '\0', },
 		{ "x0D",   "\x0d", 3, '\0', },
 		{ "x0E",   "\x0e", 3, '\0', },
 		{ "x0F",   "\x0f", 3, '\0', },
 		{ "x10",   "\x10", 3, '\0', },
 		{ "x20",   "\x20", 3, '\0', },
 		{ "x30",   "\x30", 3, '\0', },
 		{ "x40",   "\x40", 3, '\0', },
 		{ "x50",   "\x50", 3, '\0', },
 		{ "x60",   "\x60", 3, '\0', },
 		{ "x70",   "\x70", 3, '\0', },
 		{ "x80",   "\x80", 3, '\0', },
 		{ "x90",   "\x90", 3, '\0', },
 		{ "xa0",   "\xa0", 3, '\0', },
 		{ "xb0",   "\xb0", 3, '\0', },
 		{ "xc0",   "\xc0", 3, '\0', },
 		{ "xd0",   "\xd0", 3, '\0', },
 		{ "xe0",   "\xe0", 3, '\0', },
 		{ "xf0",   "\xf0", 3, '\0', },
 		{ "xA0",   "\xa0", 3, '\0', },
 		{ "xB0",   "\xb0", 3, '\0', },
 		{ "xC0",   "\xc0", 3, '\0', },
 		{ "xD0",   "\xd0", 3, '\0', },
 		{ "xE0",   "\xe0", 3, '\0', },
 		{ "xF0",   "\xf0", 3, '\0', },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; mrhb_test_vals[i].in != NULL; i++) {
 		f = maybe_read_hex_byte(sbuf, mrhb_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), mrhb_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - mrhb_test_vals[i].in,
 				 mrhb_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, mrhb_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(read_oct_byte);
 ATF_TC_HEAD(read_oct_byte, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing read_oct_byte() format parsing routine");
 }
 ATF_TC_BODY(read_oct_byte, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct rob_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} rob_test_vals[] = {
 		{ "141",   "a",    3, '\0', },
 		{ "0",     "\0",   1, '\0', },
 		{ "08",    "\0",   1, '8',  },
 		{ "008",    "\0",  2, '8',  },
 		{ "0008",   "\0",  3, '8',  },
 		{ "00008",  "\0",  3, '0',  },
 		{ "1",     "\001", 1, '\0', },
 		{ "2",     "\002", 1, '\0', },
 		{ "3",     "\003", 1, '\0', },
 		{ "4",     "\004", 1, '\0', },
 		{ "5",     "\005", 1, '\0', },
 		{ "6",     "\006", 1, '\0', },
 		{ "7",     "\007", 1, '\0', },
 		{ "00",    "\000", 2, '\0', },
 		{ "01",    "\001", 2, '\0', },
 		{ "02",    "\002", 2, '\0', },
 		{ "03",    "\003", 2, '\0', },
 		{ "04",    "\004", 2, '\0', },
 		{ "05",    "\005", 2, '\0', },
 		{ "06",    "\006", 2, '\0', },
 		{ "07",    "\007", 2, '\0', },
 		{ "000",   "\000", 3, '\0', },
 		{ "001",   "\001", 3, '\0', },
 		{ "002",   "\002", 3, '\0', },
 		{ "003",   "\003", 3, '\0', },
 		{ "004",   "\004", 3, '\0', },
 		{ "005",   "\005", 3, '\0', },
 		{ "006",   "\006", 3, '\0', },
 		{ "007",   "\007", 3, '\0', },
 		{ "10",    "\010", 2, '\0', },
 		{ "20",    "\020", 2, '\0', },
 		{ "30",    "\030", 2, '\0', },
 		{ "40",    "\040", 2, '\0', },
 		{ "50",    "\050", 2, '\0', },
 		{ "60",    "\060", 2, '\0', },
 		{ "70",    "\070", 2, '\0', },
 		{ "010",   "\010", 3, '\0', },
 		{ "020",   "\020", 3, '\0', },
 		{ "030",   "\030", 3, '\0', },
 		{ "040",   "\040", 3, '\0', },
 		{ "050",   "\050", 3, '\0', },
 		{ "060",   "\060", 3, '\0', },
 		{ "070",   "\070", 3, '\0', },
 		{ "100",   "\100", 3, '\0', },
 		{ "200",   "\200", 3, '\0', },
 		{ "300",   "\300", 3, '\0', },
 		{ "370",   "\370", 3, '\0', },
 		{ "371",   "\371", 3, '\0', },
 		{ "372",   "\372", 3, '\0', },
 		{ "373",   "\373", 3, '\0', },
 		{ "374",   "\374", 3, '\0', },
 		{ "375",   "\375", 3, '\0', },
 		{ "376",   "\376", 3, '\0', },
 		{ "377",   "\377", 3, '\0', },
 		{ "400",   "\040", 2, '0',  },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; rob_test_vals[i].in != NULL; i++) {
 		f = read_oct_byte(sbuf, rob_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), rob_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - rob_test_vals[i].in,
 				 rob_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, rob_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(process_escape);
 ATF_TC_HEAD(process_escape, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing process_escape() format parsing routine");
 }
 ATF_TC_BODY(process_escape, tc)
 {
 	struct sbuf	*sbuf;
 	const char	*f;
 	int		 i;
 	struct pe_test_vals {
 		const char *in;
 		const char *out; /* What gets written to the sbuf */
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} pe_test_vals[] = {
 		{ "\\a",   "\a",   2, '\0', },
 		{ "\\b",   "\b",   2, '\0', },
 		{ "\\f",   "\f",   2, '\0', },
 		{ "\\n",   "\n",   2, '\0', },
 		{ "\\t",   "\t",   2, '\0', },
 		{ "\\v",   "\v",   2, '\0', },
 		{ "\\'",   "'",    2, '\0', },
 		{ "\\\"",  "\"",   2, '\0', },
 		{ "\\\\",  "\\",   2, '\0', },
 		{ "\\q",   "\\",   1, 'q',  },
 		/* See read_oct_byte() for more comprehensive tests on
 		   octal number escapes */
 		{ "\\1234",  "S",   4, '4',  },
 		{ "\\89",    "\\",  1, '8',  },
 		/* See maybe_read_hex_byte() for more comprehensive
 		   tests on hexadecimal number escapes */
 		{ "\\x4cd",  "L",   4, 'd', },
 		{ "\\xGG",   "\\x", 2, 'G', },
 		{ NULL,   NULL,    0, '\0', },
 	};
 	sbuf = sbuf_new_auto();
 	ATF_REQUIRE_EQ(sbuf != NULL, true);
 	for (i = 0; pe_test_vals[i].in != NULL; i++) {
 		f = process_escape(sbuf, pe_test_vals[i].in);
 		sbuf_finish(sbuf);
 		ATF_CHECK_STREQ_MSG(sbuf_data(sbuf), pe_test_vals[i].out,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - pe_test_vals[i].in,
 				 pe_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, pe_test_vals[i].fend_val,
 				 "(test %d)", i);
 		sbuf_clear(sbuf);
 	}
 	sbuf_delete(sbuf);
 }
 ATF_TC(field_modifier);
 ATF_TC_HEAD(field_modifier, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing field_modifier() format parsing routine");
 }
 ATF_TC_BODY(field_modifier, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fm_test_vals {
 		const char *in;
 		unsigned flags;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fm_test_vals[] = {
 		{ "?",  PP_ALTERNATE_FORM1, 1, '\0', },
 		{ "#",  PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "-",  PP_LEFT_ALIGN,      1, '\0', },
 		{ "+",  PP_EXPLICIT_PLUS,   1, '\0', },
 		{ " ",  PP_SPACE_FOR_PLUS,  1, '\0', },
 		{ "0",  PP_ZERO_PAD,        1, '\0', },
 		{ "\'", PP_THOUSANDS_SEP,   1, '\0', },
 		/* Not a format modifier... */
 		{ "z",  0,  0, 'z', },
 		{ "*",  0,  0, '*', },
 		{ "1",  0,  0, '1', },
 		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "##",   PP_ALTERNATE_FORM2, 2, '\0', },
 		{ "###",  PP_ALTERNATE_FORM2, 3, '\0', },
 		{ "####", PP_ALTERNATE_FORM2, 4, '\0', },
 		{ "#z",    PP_ALTERNATE_FORM2, 1, 'z', },
 		{ "##z",   PP_ALTERNATE_FORM2, 2, 'z', },
 		{ "###z",  PP_ALTERNATE_FORM2, 3, 'z', },
 		{ "####z", PP_ALTERNATE_FORM2, 4, 'z', },
 		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
 		{ "#?",   PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 2, '\0', },
 		{ "#?#",  PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 3, '\0', },
 		{ "#?#?", PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 4, '\0', },
 		{ NULL,   0,    0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fm_test_vals[i].in != NULL; i++) {
 		p->flags = 0;
 		f = field_modifier(fm_test_vals[i].in, p);
 		ATF_CHECK_EQ_MSG(p->flags, fm_test_vals[i].flags,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fm_test_vals[i].in,
 				 fm_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fm_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(field_width);
 ATF_TC_HEAD(field_width, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing field_width() format parsing routine");
 }
 ATF_TC_BODY(field_width, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fw_test_vals {
 		const char *in;
 		int width;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fw_test_vals[] = {
 		{  "0",  0, 1, '\0', },
 		{  "1",  1, 1, '\0', },
 		{  "2",  2, 1, '\0', },
 		{  "3",  3, 1, '\0', },
 		{  "4",  4, 1, '\0', },
 		{  "5",  5, 1, '\0', },
 		{  "6",  6, 1, '\0', },
 		{  "7",  7, 1, '\0', },
 		{  "8",  8, 1, '\0', },
 		{  "9",  9, 1, '\0', },
 		{ "10", 10, 2, '\0', },
 		{ "11", 11, 2, '\0', },
 		{ "12", 12, 2, '\0', },
 		{ "23", 23, 2, '\0', },
 		{ "34", 34, 2, '\0', },
 		{ "45", 45, 2, '\0', },
 		{ "56", 56, 2, '\0', },
 		{ "67", 67, 2, '\0', },
 		{ "78", 78, 2, '\0', },
 		{ "89", 89, 2, '\0', },
 		{ "90", 90, 2, '\0', },
 		{ "00",  0, 2, '\0', },
 		{ "001", 1, 3, '\0', },
 		{ "x",   0, 0, 'x',  },
 		{ "0x",  0, 1, 'x',  },
 		{ NULL,  0, 0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fw_test_vals[i].in != NULL; i++) {
 		p->width = 0;
 		f = field_width(fw_test_vals[i].in, p);
 		ATF_CHECK_EQ_MSG(p->width, fw_test_vals[i].width,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fw_test_vals[i].in,
 				 fw_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fw_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(format_code);
 ATF_TC_HEAD(format_code, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing format_code() format parsing routine");
 }
 ATF_TC_BODY(format_code, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct fc_test_vals {
 		const char *in;
 		unsigned context;
 		fmt_code_t fmt_code;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} fc_test_vals[] = {
 		{ "Bn", PP_PKG, PP_PKG_SHLIB_REQUIRED_NAME, 2, '\0', }, /* 0 */
 		{ "B",  PP_PKG, PP_PKG_SHLIBS_REQUIRED,     1, '\0', },
 		{ "Cn", PP_PKG, PP_PKG_CATEGORY_NAME,       2, '\0', },
 		{ "C",  PP_PKG, PP_PKG_CATEGORIES,          1, '\0', },
 		{ "Dg", PP_PKG, PP_PKG_DIRECTORY_GROUP,     2, '\0', },
 		{ "Dk", PP_PKG, PP_PKG_DIRECTORY_KEEPFLAG,  2, '\0', },
 		{ "Dn", PP_PKG, PP_PKG_DIRECTORY_PATH,      2, '\0', },
 		{ "Dp", PP_PKG, PP_PKG_DIRECTORY_PERMS,     2, '\0', },
 		{ "Dt", PP_PKG, PP_PKG_DIRECTORY_TRYFLAG,   2, '\0', },
 		{ "Du", PP_PKG, PP_PKG_DIRECTORY_USER,      2, '\0', },
 		{ "D",  PP_PKG, PP_PKG_DIRECTORIES,         1, '\0', }, /* 10 */
 		{ "Fg", PP_PKG, PP_PKG_FILE_GROUP,          2, '\0', },
 		{ "Fk", PP_PKG, PP_PKG_FILE_KEEPFLAG,       2, '\0', },
 		{ "Fn", PP_PKG, PP_PKG_FILE_PATH,           2, '\0', },
 		{ "Fp", PP_PKG, PP_PKG_FILE_PERMS,          2, '\0', },
 		{ "Fs", PP_PKG, PP_PKG_FILE_SHA256,         2, '\0', },
 		{ "Fu", PP_PKG, PP_PKG_FILE_USER,           2, '\0', },
 		{ "F",  PP_PKG, PP_PKG_FILES,               1, '\0', },
 		{ "Gg", PP_PKG, PP_PKG_GROUP_GIDSTR,        2, '\0', },
 		{ "Gn", PP_PKG, PP_PKG_GROUP_NAME,          2, '\0', },
 		{ "G",  PP_PKG, PP_PKG_GROUPS,              1, '\0', }, /* 20 */
 		{ "I",  PP_PKG, PP_UNKNOWN,                 0, 'I',  },
 		{ "Ln", PP_PKG, PP_PKG_LICENSE_NAME,        2, '\0', },
 		{ "L",  PP_PKG, PP_PKG_LICENSES,            1, '\0', },
 		{ "M",  PP_PKG, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_PKG, PP_PKG_OPTION_NAME,         2, '\0', },
 		{ "Ov", PP_PKG, PP_PKG_OPTION_VALUE,        2, '\0', },
 		{ "O",  PP_PKG, PP_PKG_OPTIONS,             1, '\0', },
 		{ "Un", PP_PKG, PP_PKG_USER_NAME,           2, '\0', },
 		{ "Uu", PP_PKG, PP_PKG_USER_UIDSTR,         2, '\0', },
 		{ "U",  PP_PKG, PP_PKG_USERS,               1, '\0', }, /* 30 */
 		{ "a",  PP_PKG, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_PKG, PP_PKG_SHLIB_PROVIDED_NAME, 2, '\0', },
 		{ "b",  PP_PKG, PP_PKG_SHLIBS_PROVIDED,     1, '\0', },
 		{ "c",  PP_PKG, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_PKG, PP_PKG_DEPENDENCY_NAME,     2, '\0', },
 		{ "do", PP_PKG, PP_PKG_DEPENDENCY_ORIGIN,   2, '\0', },
 		{ "dv", PP_PKG, PP_PKG_DEPENDENCY_VERSION,  2, '\0', },
 		{ "d",  PP_PKG, PP_PKG_DEPENDENCIES,        1, '\0', },
 		{ "i",  PP_PKG, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_PKG, PP_PKG_LOCK_STATUS,         1, '\0', }, /* 40 */
 		{ "l",  PP_PKG, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_PKG, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_PKG, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_PKG, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_PKG, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_PKG, PP_PKG_REQUIREMENT_NAME,    2, '\0', },
 		{ "ro", PP_PKG, PP_PKG_REQUIREMENT_ORIGIN,  2, '\0', },
 		{ "rv", PP_PKG, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
 		{ "r",  PP_PKG, PP_PKG_REQUIREMENTS,        1, '\0', },
 		{ "s",  PP_PKG, PP_PKG_FLATSIZE,            1, '\0', }, /* 50 */
 		{ "t",  PP_PKG, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_PKG, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_PKG, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_PKG, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_PKG, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_B, PP_PKG_SHLIB_REQUIRED_NAME, 2, '\0', },
 		{ "B",  PP_B, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_B, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_B, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_B, PP_UNKNOWN,                 0, 'D',  }, /* 60 */
 		{ "Dk", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_B, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_B, PP_UNKNOWN,                 0, 'F',  }, /* 70 */
 		{ "Fs", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_B, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_B, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_B, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_B, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_B, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_B, PP_PKG_MESSAGE,             1, '\0', }, /* 80 */
 		{ "On", PP_B, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_B, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_B, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_B, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_B, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_B, PP_UNKNOWN,                 0, 'b', },
 		{ "b",  PP_B, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_B, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_B, PP_UNKNOWN,                 0, 'd',  }, /* 90 */
 		{ "dv", PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_B, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_B, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_B, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_B, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_B, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_B, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_B, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_B, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_B, PP_UNKNOWN,                 0, 'r',  }, /* 100 */
 		{ "ro", PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_B, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_B, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_B, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_B, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_B, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_B, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_B, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_C, PP_UNKNOWN,                 0, 'B',  }, /* 110 */
 		{ "B",  PP_C, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_C, PP_PKG_CATEGORY_NAME,       2, '\0', },
 		{ "C",  PP_C, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_C, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_C, PP_UNKNOWN,                 0, 'D',  }, /* 120 */
 		{ "Fg", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_C, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_C, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_C, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_C, PP_UNKNOWN,                 0, 'G',  }, /* 130 */
 		{ "I",  PP_C, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_C, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_C, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_C, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_C, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_C, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_C, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_C, PP_UNKNOWN,                 0, 'U',  }, /* 140 */
 		{ "a",  PP_C, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_C, PP_UNKNOWN,                 0, 'b',  }, /* 110 */
 		{ "b",  PP_C, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_C, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_C, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_C, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_C, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_C, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_C, PP_PKG_MAINTAINER,          1, '\0', }, /* 150 */
 		{ "n",  PP_C, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_C, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_C, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_C, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_C, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_C, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_C, PP_PKG_VERSION,             1, '\0', }, /* 160 */
 		{ "w",  PP_C, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_C, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_C, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_D, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_D, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_D, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_D, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_D, PP_PKG_DIRECTORY_GROUP,     2, '\0', },
 		{ "Dk", PP_D, PP_PKG_DIRECTORY_KEEPFLAG,  2, '\0', },
 		{ "Dn", PP_D, PP_PKG_DIRECTORY_PATH,      2, '\0', }, /* 170 */
 		{ "Dp", PP_D, PP_PKG_DIRECTORY_PERMS,     2, '\0', },
 		{ "Dt", PP_D, PP_PKG_DIRECTORY_TRYFLAG,   2, '\0', },
 		{ "Du", PP_D, PP_PKG_DIRECTORY_USER,      2, '\0', },
 		{ "D",  PP_D, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_D, PP_UNKNOWN,                 0, 'F',  }, /* 180 */
 		{ "F",  PP_D, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_D, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_D, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_D, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_D, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_D, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_D, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_D, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_D, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_D, PP_UNKNOWN,                 0, 'O',  }, /* 190 */
 		{ "O",  PP_D, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_D, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_D, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_D, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_D, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_D, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_D, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_D, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_D, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_D, PP_UNKNOWN,                 0, 'd',  }, /* 200 */
 		{ "i",  PP_D, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_D, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_D, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_D, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_D, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_D, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_D, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_D, PP_UNKNOWN,                 0, 'r',  }, /* 210 */
 		{ "r",  PP_D, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_D, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_D, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_D, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_D, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_D, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_D, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_F, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_F, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_F, PP_UNKNOWN,                 0, 'C',  }, /* 220 */
 		{ "C",  PP_F, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_F, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_F, PP_PKG_FILE_GROUP,          2, '\0', },
 		{ "Fk", PP_F, PP_PKG_FILE_KEEPFLAG,       2, '\0', }, /* 230 */
 		{ "Fn", PP_F, PP_PKG_FILE_PATH,           2, '\0', },
 		{ "Fp", PP_F, PP_PKG_FILE_PERMS,          2, '\0', },
 		{ "Fs", PP_F, PP_PKG_FILE_SHA256,         2, '\0', },
 		{ "Fu", PP_F, PP_PKG_FILE_USER,           2, '\0', },
 		{ "F",  PP_F, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_F, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_F, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_F, PP_UNKNOWN,                 0, 'L',  }, /* 240 */
 		{ "L",  PP_F, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_F, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_F, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_F, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_F, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_F, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_F, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_F, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_F, PP_UNKNOWN,                 0, 'd',  }, /* 250 */
 		{ "dv", PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_F, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_F, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_F, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_F, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_F, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_F, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_F, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_F, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_F, PP_UNKNOWN,                 0, 'r',  },/* 260 */
 		{ "ro", PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_F, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_F, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_F, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_F, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_F, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_F, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_F, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_G, PP_UNKNOWN,                 0, 'B',  }, /* 270 */
 		{ "B",  PP_G, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_G, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_G, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_G, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_G, PP_UNKNOWN,                 0, 'D',  }, /* 280 */
 		{ "Fg", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_G, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_G, PP_PKG_GROUP_GIDSTR,        2, '\0', },
 		{ "Gn", PP_G, PP_PKG_GROUP_NAME,          2, '\0', },
 		{ "G",  PP_G, PP_UNKNOWN,                 0, 'G',  }, /* 290 */
 		{ "I",  PP_G, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_G, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_G, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_G, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_G, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_G, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_G, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_G, PP_UNKNOWN,                 0, 'U',  }, /* 300 */
 		{ "a",  PP_G, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_G, PP_UNKNOWN,                 0, 'b',  }, /* 270 */
 		{ "b",  PP_G, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_G, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_G, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_G, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_G, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_G, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_G, PP_PKG_MAINTAINER,          1, '\0', }, /* 310 */
 		{ "n",  PP_G, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_G, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_G, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_G, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_G, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_G, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_G, PP_PKG_VERSION,             1, '\0', }, /* 320 */
 		{ "w",  PP_G, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_G, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_G, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_L, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_L, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_L, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_L, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_L, PP_UNKNOWN,                 0, 'D',  }, /* 330 */
 		{ "Dp", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_L, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_L, PP_UNKNOWN,                 0, 'F',  }, /* 340 */
 		{ "F",  PP_L, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_L, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_L, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_L, PP_PKG_LICENSE_NAME,        2, '\0', },
 		{ "L",  PP_L, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_L, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_L, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_L, PP_UNKNOWN,                 0, 'O',  }, /* 350 */
 		{ "O",  PP_L, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_L, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_L, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_L, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_L, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_L, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_L, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_L, PP_UNKNOWN,                 0, 'd',  }, /* 360 */
 		{ "i",  PP_L, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_L, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_L, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_L, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_L, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_L, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_L, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_L, PP_UNKNOWN,                 0, 'r',  }, /* 370 */
 		{ "r",  PP_L, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_L, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_L, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_L, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_L, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_L, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_L, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_O, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_O, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_O, PP_UNKNOWN,                 0, 'C',  }, /* 380 */
 		{ "C",  PP_O, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_O, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_O, PP_UNKNOWN,                 0, 'F',  }, /* 390 */
 		{ "Fn", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_O, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_O, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_O, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_O, PP_UNKNOWN,                 0, 'L',  }, /* 400 */
 		{ "L",  PP_O, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_O, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_O, PP_PKG_OPTION_NAME,         2, '\0', },
 		{ "Ov", PP_O, PP_PKG_OPTION_VALUE,        2, '\0', },
 		{ "O",  PP_O, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_O, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_O, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_O, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_O, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_O, PP_PKG_COMMENT,             1, '\0', }, /* 410 */
 		{ "dn", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_O, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_O, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_O, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_O, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_O, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_O, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_O, PP_PKG_ORIGIN,              1, '\0', }, /* 420 */
 		{ "p",  PP_O, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_O, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_O, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_O, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_O, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_O, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_O, PP_LITERAL_PERCENT,         1, '\0', }, /* 430 */
 		{ "x",  PP_O, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_U, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_U, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_U, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_U, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_U, PP_UNKNOWN,                 0, 'D',  }, /* 440 */
 		{ "Du", PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_U, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_U, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_U, PP_UNKNOWN,                 0, 'G',  }, /* 450 */
 		{ "Gn", PP_U, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_U, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_U, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_U, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_U, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_U, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_U, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_U, PP_PKG_USER_NAME,           2, '\0', }, /* 460 */
 		{ "Uu", PP_U, PP_PKG_USER_UIDSTR,         2, '\0', },
 		{ "U",  PP_U, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_U, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_U, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_U, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_U, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_U, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_U, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_U, PP_PKG_LOCK_STATUS,         1, '\0', }, /* 470 */
 		{ "l",  PP_U, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_U, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_U, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_U, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_U, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "ro", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_U, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_U, PP_PKG_FLATSIZE,            1, '\0', }, /* 480 */
 		{ "t",  PP_U, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_U, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_U, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_U, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_U, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_b, PP_UNKNOWN,                 0, 'B', },
 		{ "B",  PP_b, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_b, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_b, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_b, PP_UNKNOWN,                 0, 'D',  }, /* 60 */
 		{ "Dk", PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_b, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_b, PP_UNKNOWN,                 0, 'F',  }, /* 70 */
 		{ "Fs", PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_b, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_b, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_b, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_b, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_b, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_b, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_b, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_b, PP_PKG_MESSAGE,             1, '\0', }, /* 80 */
 		{ "On", PP_b, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_b, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_b, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_b, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_b, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_b, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_b, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_b, PP_PKG_SHLIB_PROVIDED_NAME, 2, '\0', },
 		{ "b",  PP_b, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_b, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_b, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_b, PP_UNKNOWN,                 0, 'd',  }, /* 90 */
 		{ "dv", PP_b, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_b, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_b, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_b, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_b, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_b, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_b, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_b, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_b, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_b, PP_UNKNOWN,                 0, 'r',  }, /* 100 */
 		{ "ro", PP_b, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_b, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_b, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_b, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_b, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_b, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_b, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_b, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_b, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_d, PP_UNKNOWN,                 0, 'B',  },
 		{ "B",  PP_d, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_d, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_d, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_d, PP_UNKNOWN,                 0, 'D',  }, /* 490 */
 		{ "Dk", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_d, PP_UNKNOWN,                 0, 'D',  },
 		{ "Fg", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_d, PP_UNKNOWN,                 0, 'F',  }, /* 500 */
 		{ "Fs", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_d, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_d, PP_UNKNOWN,                 0, 'G',  },
 		{ "I",  PP_d, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_d, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_d, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_d, PP_PKG_MESSAGE,             1, '\0', }, /* 510 */
 		{ "On", PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_d, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_d, PP_UNKNOWN,                 0, 'U',  },
 		{ "a",  PP_d, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_d, PP_UNKNOWN,                 0, 'b',  },
 		{ "b",  PP_d, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_d, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_d, PP_PKG_DEPENDENCY_NAME,     2, '\0', },
 		{ "do", PP_d, PP_PKG_DEPENDENCY_ORIGIN,   2, '\0', }, /* 520 */
 		{ "dv", PP_d, PP_PKG_DEPENDENCY_VERSION,  2, '\0', },
 		{ "d",  PP_d, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_d, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_d, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_d, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_d, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_d, PP_PKG_NAME,                1, '\0', },
 		{ "o",  PP_d, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_d, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_d, PP_UNKNOWN,                 0, 'r',  }, /* 530 */
 		{ "ro", PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "rv", PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "r",  PP_d, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_d, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_d, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_d, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_d, PP_PKG_HOME_PAGE,           1, '\0', },
 		{ "%",  PP_d, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_d, PP_UNKNOWN,                 0, 'x',  },
 		{ "Bn", PP_r, PP_UNKNOWN,                 0, 'B',  }, /* 540 */
 		{ "B",  PP_r, PP_UNKNOWN,                 0, 'B',  },
 		{ "Cn", PP_r, PP_UNKNOWN,                 0, 'C',  },
 		{ "C",  PP_r, PP_UNKNOWN,                 0, 'C',  },
 		{ "Dg", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dk", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dn", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dp", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Dt", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "Du", PP_r, PP_UNKNOWN,                 0, 'D',  },
 		{ "D",  PP_r, PP_UNKNOWN,                 0, 'D',  }, /* 550 */
 		{ "Fg", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fk", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fn", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fp", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fs", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Fu", PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "F",  PP_r, PP_UNKNOWN,                 0, 'F',  },
 		{ "Gg", PP_r, PP_UNKNOWN,                 0, 'G',  },
 		{ "Gn", PP_r, PP_UNKNOWN,                 0, 'G',  },
 		{ "G",  PP_r, PP_UNKNOWN,                 0, 'G',  }, /* 560 */
 		{ "I",  PP_r, PP_ROW_COUNTER,             1, '\0', },
 		{ "Ln", PP_r, PP_UNKNOWN,                 0, 'L',  },
 		{ "L",  PP_r, PP_UNKNOWN,                 0, 'L',  },
 		{ "M",  PP_r, PP_PKG_MESSAGE,             1, '\0', },
 		{ "On", PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "Ov", PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "O",  PP_r, PP_UNKNOWN,                 0, 'O',  },
 		{ "Un", PP_r, PP_UNKNOWN,                 0, 'U',  },
 		{ "Uu", PP_r, PP_UNKNOWN,                 0, 'U',  },
 		{ "U",  PP_r, PP_UNKNOWN,                 0, 'U',  }, /* 570 */
 		{ "a",  PP_r, PP_PKG_AUTOREMOVE,          1, '\0', },
 		{ "bn", PP_r, PP_UNKNOWN,                 0, 'b',  }, /* 540 */
 		{ "b",  PP_r, PP_UNKNOWN,                 0, 'b',  },
 		{ "c",  PP_r, PP_PKG_COMMENT,             1, '\0', },
 		{ "dn", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "do", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "dv", PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "d",  PP_r, PP_UNKNOWN,                 0, 'd',  },
 		{ "i",  PP_r, PP_PKG_ADDITIONAL_INFO,     1, '\0', },
 		{ "k",  PP_r, PP_PKG_LOCK_STATUS,         1, '\0', },
 		{ "l",  PP_r, PP_PKG_LICENSE_LOGIC,       1, '\0', },
 		{ "m",  PP_r, PP_PKG_MAINTAINER,          1, '\0', },
 		{ "n",  PP_r, PP_PKG_NAME,                1, '\0', }, /* 580 */
 		{ "o",  PP_r, PP_PKG_ORIGIN,              1, '\0', },
 		{ "p",  PP_r, PP_PKG_PREFIX,              1, '\0', },
 		{ "rn", PP_r, PP_PKG_REQUIREMENT_NAME,    2, '\0', },
 		{ "ro", PP_r, PP_PKG_REQUIREMENT_ORIGIN,  2, '\0', },
 		{ "rv", PP_r, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
 		{ "r",  PP_r, PP_UNKNOWN,                 0, 'r',  },
 		{ "s",  PP_r, PP_PKG_FLATSIZE,            1, '\0', },
 		{ "t",  PP_r, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
 		{ "v",  PP_r, PP_PKG_VERSION,             1, '\0', },
 		{ "w",  PP_r, PP_PKG_HOME_PAGE,           1, '\0', }, /* 590 */
 		{ "%",  PP_r, PP_LITERAL_PERCENT,         1, '\0', },
 		{ "x",  PP_r, PP_UNKNOWN,                 0, 'x',  },
 		{ NULL, 0,    0,                          0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; fc_test_vals[i].in != NULL; i++) {
 		p->width = 0;
 		f = format_code(fc_test_vals[i].in, fc_test_vals[i].context, p);
 		ATF_CHECK_EQ_MSG(p->fmt_code, fc_test_vals[i].fmt_code,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - fc_test_vals[i].in,
 				 fc_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, fc_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(format_trailer);
 ATF_TC_HEAD(format_trailer, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing format_trailer() format parsing routine");
 }
 ATF_TC_BODY(format_trailer, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct ft_test_vals {
 		const char *in;
 		const char *item;
 		const char *sep;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} ft_test_vals[] = {
 		{ "%{aaaaaaaa", "",   "",    0, '%',  },
 		{ "%{bb%|cccc", "",   "",    0, '%',  },
 		{ "ddd%|eee%}", "",   "",    0, 'd',  },
 		{ "%{ff%|gg%}", "ff", "gg", 10, '\0', },
 		{ "%{hh%}",     "hh", "",    6, '\0', },
 		{ "%{%|iii%}",  "",   "iii", 9, '\0', },
 		{ NULL,         NULL, NULL,  0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; ft_test_vals[i].in != NULL; i++) {
 		sbuf_clear(p->item_fmt);
 		sbuf_clear(p->sep_fmt);
 		f = format_trailer(ft_test_vals[i].in, p);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->item_fmt),
 				    ft_test_vals[i].item,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->sep_fmt),
 				    ft_test_vals[i].sep,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - ft_test_vals[i].in,
 				 ft_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, ft_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TC(parse_format);
 ATF_TC_HEAD(parse_format, tc)
 {
 	atf_tc_set_md_var(tc, "descr",
 	    "Testing parse_format() format parsing routine");
 }
 ATF_TC_BODY(parse_format, tc)
 {
 	struct percent_esc	*p;
 	const char		*f;
 	int		 	i;
 	struct pf_test_vals {
 		const char *in;
 		unsigned context;
 		unsigned flags;
 		int width;
 		fmt_code_t fmt_code;
 		const char *item;
 		const char *sep;
 		ptrdiff_t   fend_offset; /* Where f is left pointing */
 		char	    fend_val; /* expected first char in fend */
 	} pf_test_vals[] = {
 		{ "%n",    PP_PKG, 0,             0,  PP_PKG_NAME, "",   "",   2, '\0', },
 		{ "%-20n", PP_PKG, PP_LEFT_ALIGN, 20, PP_PKG_NAME, "",   "",   5, '\0', },
 		{ "%?B",   PP_PKG, PP_ALTERNATE_FORM1, 0, PP_PKG_SHLIBS_REQUIRED, "", "", 3, '\0', },
 		{ "%#F",   PP_PKG, PP_ALTERNATE_FORM2, 0, PP_PKG_FILES,  "", "", 3, '\0', },
 		{ "%L%{%Ln%| %l %}", PP_PKG, 0, 0, PP_PKG_LICENSES, "%Ln", " %l ", 15, '\0', },
 		{ "%Ln",   PP_L,   0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
 		{ "%l",    PP_L,   0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
 		{ "%Ln",   PP_PKG, 0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
 		{ "%l",    PP_PKG, 0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
 		{ "%I",    PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, 'I', },
 		{ "%^D",   PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, '^', },
 		{ NULL,    0,      0,             0,  0,           NULL, NULL, 0, '\0', },
 	};
 	p = new_percent_esc(NULL);
 	ATF_REQUIRE_EQ(p != NULL, true);
 	for (i = 0; pf_test_vals[i].in != NULL; i++) {
 		p = new_percent_esc(p);
 		f = parse_format(pf_test_vals[i].in, pf_test_vals[i].context,
 				 p);
 		ATF_CHECK_EQ_MSG(p->flags, pf_test_vals[i].flags,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(p->width, pf_test_vals[i].width,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(p->fmt_code, pf_test_vals[i].fmt_code,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->item_fmt),
 				    pf_test_vals[i].item,
 				    "(test %d)", i);
 		ATF_CHECK_STREQ_MSG(sbuf_data(p->sep_fmt),
 				    pf_test_vals[i].sep,
 				    "(test %d)", i);
 		ATF_CHECK_EQ_MSG(f - pf_test_vals[i].in,
 				 pf_test_vals[i].fend_offset,
 				 "(test %d)", i);
 		ATF_CHECK_EQ_MSG(*f, pf_test_vals[i].fend_val,
 				 "(test %d)", i);
 	}
 	free_percent_esc(p);
 }
 ATF_TP_ADD_TCS(tp)
 {
 	/* Output routines */
 	ATF_TP_ADD_TC(tp, gen_format);
 	ATF_TP_ADD_TC(tp, human_number);
 	ATF_TP_ADD_TC(tp, string_val);
 	ATF_TP_ADD_TC(tp, int_val);
 	ATF_TP_ADD_TC(tp, bool_val);
 	ATF_TP_ADD_TC(tp, mode_val);
 	ATF_TP_ADD_TC(tp, liclog_val);
 	ATF_TP_ADD_TC(tp, list_count);
 	/* Format string parsing routines */
 	ATF_TP_ADD_TC(tp, maybe_read_hex_byte);
 	ATF_TP_ADD_TC(tp, read_oct_byte);
 	ATF_TP_ADD_TC(tp, process_escape);
 	ATF_TP_ADD_TC(tp, field_modifier);
 	ATF_TP_ADD_TC(tp, field_width);
 	ATF_TP_ADD_TC(tp, format_code);
 	ATF_TP_ADD_TC(tp, format_trailer);
 	ATF_TP_ADD_TC(tp, parse_format);
 	return atf_no_error();
 }
 /*
  * That's All Folks!
  */