CoCalc -- pkg_printf

GitHub Repository: freebsd/pkg
Path: blob/main/tests/lib/pkg_printf_test.c
²⁰⁶⁵ views
1
/*-
2
 * Copyright (c) 2012-2015 Matthew Seaman <[email protected]>
3
 * All rights reserved.
4
 * 
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 * 1. Redistributions of source code must retain the above copyright
9
 *    notice, this list of conditions and the following disclaimer
10
 *    in this position and unchanged.
11
 * 2. Redistributions in binary form must reproduce the above copyright
12
 *    notice, this list of conditions and the following disclaimer in the
13
 *    documentation and/or other materials provided with the distribution.
14
 * 
15
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25
 */
26

27
#include <string.h>
28

29
#include <atf-c.h>
30
#include <xstring.h>
31
#include <pkg.h>
32
#include <private/pkg_printf.h>
33

34
ATF_TC_WITHOUT_HEAD(gen_format);
35

36
ATF_TC_BODY(gen_format, tc)
37
{
38
	char		 buf[32];
39
	unsigned	 i;
40
	char		*tail = "x";
41

42
	struct gf_test_vals {
43
		const char *out;
44
		unsigned    flags;
45
	} gf_test_vals[] = {
46

47
		{ "%*x",     0, },
48

49
		{ "%*x",     PP_ALTERNATE_FORM1, }, /* Has no effect */
50

51
		{ "%#*x",    PP_ALTERNATE_FORM2, },
52
		{ "%-*x",    PP_LEFT_ALIGN, },
53
		{ "%#-*x",   PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
54
		{ "%+*x",    PP_EXPLICIT_PLUS, },
55
		{ "%#+*x",   PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
56
		{ "%-+*x",   PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
57
		{ "%#-+*x",  PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
58
		{ "% *x",    PP_SPACE_FOR_PLUS, },
59
		{ "%# *x",   PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
60
		{ "%- *x",   PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
61
		{ "%#- *x",  PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
62
		{ "%+*x",    PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
63
		{ "%#+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
64
		{ "%-+*x",   PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
65
		{ "%#-+*x",  PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
66
		{ "%0*x",    PP_ZERO_PAD, },
67
		{ "%#0*x",   PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
68
		{ "%-*x",    PP_ZERO_PAD|PP_LEFT_ALIGN, },
69
		{ "%#-*x",   PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
70
		{ "%0+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
71
		{ "%#0+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
72
		{ "%-+*x",   PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
73
		{ "%#-+*x",  PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
74
		{ "%0 *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
75
		{ "%#0 *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
76
		{ "%- *x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
77
		{ "%#- *x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
78
		{ "%0+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
79
		{ "%#0+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
80
		{ "%-+*x",   PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
81
		{ "%#-+*x",  PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
82
		{ "%'*x",    PP_THOUSANDS_SEP, },
83
		{ "%#'*x",   PP_THOUSANDS_SEP|PP_ALTERNATE_FORM2, },
84
		{ "%-'*x",   PP_THOUSANDS_SEP|PP_LEFT_ALIGN, },
85
		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
86
		{ "%+'*x",   PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS, },
87
		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
88
		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
89
		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
90
		{ "% '*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS, },
91
		{ "%# '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
92
		{ "%- '*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
93
		{ "%#- '*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
94
		{ "%+'*x",   PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
95
		{ "%#+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
96
		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
97
		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
98
		{ "%0'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD, },
99
		{ "%#0'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_ALTERNATE_FORM2, },
100
		{ "%-'*x",   PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN, },
101
		{ "%#-'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
102
		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS, },
103
		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
104
		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
105
		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
106
		{ "%0 '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS, },
107
		{ "%#0 '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_ALTERNATE_FORM2, },
108
		{ "%- '*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN, },
109
		{ "%#- '*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
110
		{ "%0+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS, },
111
		{ "%#0+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_ALTERNATE_FORM2, },
112
		{ "%-+'*x",  PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN, },
113
		{ "%#-+'*x", PP_THOUSANDS_SEP|PP_ZERO_PAD|PP_SPACE_FOR_PLUS|PP_EXPLICIT_PLUS|PP_LEFT_ALIGN|PP_ALTERNATE_FORM2, },
114

115
		{ NULL, 0, },
116
	};
117

118
	for (i = 0; gf_test_vals[i].out != NULL; i++) {
119
		ATF_CHECK_STREQ(gen_format(buf, sizeof(buf),
120
					   gf_test_vals[i].flags, tail),
121
				gf_test_vals[i].out);
122
	}
123
}
124

125
ATF_TC(human_number);
126
ATF_TC_HEAD(human_number, tc)
127
{
128
	atf_tc_set_md_var(tc, "descr",
129
			  "Testing human_number() output routine");
130
}
131
ATF_TC_BODY(human_number, tc)
132
{
133
	xstring		*buf = NULL;
134
	struct percent_esc	*p;
135
	int			 i;
136

137
	struct hn_test_vals {
138
		int64_t	in;
139
		const char *out;
140
		int width;
141
		unsigned flags;
142
	} hn_test_vals[] = {
143
		{ 0,                   "0.00",   0, 0, },
144
		{ 1,                   "1.00",   0, 0, },
145
		{ 10,                  "10.0",   0, 0, },
146
		{ 100,                 "100",    0, 0. },
147
		{ 1000,                "1.00k",  0, 0, },
148
		{ 10000,               "10.0k",  0, 0, },
149
		{ 100000,              "100k",   0, 0, },
150
		{ 1000000,             "1.00M",  0, 0, },
151
		{ 1000000000,          "1.00G",  0, 0, },
152
		{ 1000000000000,       "1.00T",  0, 0, },
153
		{ 1000000000000000,    "1.00P",  0, 0, },
154
		{ 1000000000000000000, "1.00E",  0, 0, },
155

156
		{ 999,                 "999",    0, 0, },
157
		{ 1001,                "1.00k",  0, 0, },
158
		{ 1010,                "1.01k",  0, 0, },
159
		{ 1490,                "1.49k",  0, 0, },
160
		{ 1499,                "1.50k",  0, 0, },
161
		{ 1500,                "1.50k",  0, 0, },
162

163
		{ -1,                  "-1.00",  0, 0, },
164
		{ -1234,               "-1.23k", 0, 0, },
165
		{ -1234567,            "-1.23M", 0, 0, },
166
		{ -1234567890,         "-1.23G", 0, 0, },
167
		{ -1234567890123,      "-1.23T", 0, 0, },
168
		{ -1234567890123456,   "-1.23P", 0, 0, },
169
		{ -1234567890123456789,"-1.23E", 0, 0, },
170

171
		{ 512,                 "512",    0, PP_ALTERNATE_FORM2, },
172
		{ 1024,                "1.00Ki", 0, PP_ALTERNATE_FORM2, },
173
		{ 1536,                "1.50Ki", 0, PP_ALTERNATE_FORM2, },
174
		{ 24576,               "24.0Ki", 0, PP_ALTERNATE_FORM2, },
175
		{ 393216,              "384Ki",  0, PP_ALTERNATE_FORM2, },
176
		{ 2359296,             "2.25Mi", 0, PP_ALTERNATE_FORM2, },
177
		{ 3623878656,          "3.38Gi", 0, PP_ALTERNATE_FORM2, },
178
		{ 5566277615616,       "5.06Ti", 0, PP_ALTERNATE_FORM2, },
179
		{ 8549802417586176,    "7.59Pi", 0, PP_ALTERNATE_FORM2, },
180
		{ 1313249651341236633, "1.14Ei", 0, PP_ALTERNATE_FORM2, },
181

182

183
		{ 123,     "123",          0, 0, },
184
		{ 123,     "123",          1, 0, },
185
		{ 123,     "123",          2, 0, },
186
		{ 123,     "123",          3, 0, },
187
		{ 123,     " 123",         4, 0, },
188
		{ 123,     "  123",        5, 0, },
189
		{ 123,     "   123",       6, 0, },
190
		{ 123,     "    123",      7, 0, },
191
		{ 123,     "     123",     8, 0, },
192
		{ 123,     "      123",    9, 0, },
193

194
		{ 123,     " 123",         0, PP_SPACE_FOR_PLUS, },
195
		{ 123,     " 123",         1, PP_SPACE_FOR_PLUS, },
196
		{ 123,     " 123",         2, PP_SPACE_FOR_PLUS, },
197
		{ 123,     " 123",         3, PP_SPACE_FOR_PLUS, },
198
		{ 123,     " 123",         4, PP_SPACE_FOR_PLUS, },
199
		{ 123,     "  123",        5, PP_SPACE_FOR_PLUS, },
200
		{ 123,     "   123",       6, PP_SPACE_FOR_PLUS, },
201
		{ 123,     "    123",      7, PP_SPACE_FOR_PLUS, },
202
		{ 123,     "     123",     8, PP_SPACE_FOR_PLUS, },
203
		{ 123,     "      123",    9, PP_SPACE_FOR_PLUS, },
204

205
		{ -123,    "-123",         0, 0, },
206
		{ -123,    "-123",         1, 0, },
207
		{ -123,    "-123",         2, 0, },
208
		{ -123,    "-123",         3, 0, },
209
		{ -123,    "-123",         4, 0, },
210
		{ -123,    " -123",        5, 0, },
211
		{ -123,    "  -123",       6, 0, },
212
		{ -123,    "   -123",      7, 0, },
213
		{ -123,    "    -123",     8, 0, },
214
		{ -123,    "     -123",    9, 0, },
215

216
		{ 123,     "123",          0, PP_ALTERNATE_FORM2, },
217
		{ 123,     "123",          1, PP_ALTERNATE_FORM2, },
218
		{ 123,     "123",          2, PP_ALTERNATE_FORM2, },
219
		{ 123,     "123",          3, PP_ALTERNATE_FORM2, },
220
		{ 123,     " 123",         4, PP_ALTERNATE_FORM2, },
221
		{ 123,     "  123",        5, PP_ALTERNATE_FORM2, },
222
		{ 123,     "   123",       6, PP_ALTERNATE_FORM2, },
223
		{ 123,     "    123",      7, PP_ALTERNATE_FORM2, },
224
		{ 123,     "     123",     8, PP_ALTERNATE_FORM2, },
225
		{ 123,     "      123",    9, PP_ALTERNATE_FORM2, },
226

227
		{ 1234567, "1.23M",        0, 0, },
228
		{ 1234567, "1M",           1, 0, },
229
		{ 1234567, "1M",           2, 0, },
230
		{ 1234567, " 1M",          3, 0, },
231
		{ 1234567, "1.2M",         4, 0, },
232
		{ 1234567, "1.23M",        5, 0, },
233
		{ 1234567, " 1.23M",       6, 0, },
234
		{ 1234567, "  1.23M",      7, 0, },
235
		{ 1234567, "   1.23M",     8, 0, },
236
		{ 1234567, "    1.23M",    9, 0, },
237

238
		{ 12345678, "12.3M",       0, 0, },
239
		{ 12345678, "12M",         1, 0, },
240
		{ 12345678, "12M",         2, 0, },
241
		{ 12345678, "12M",         3, 0, },
242
		{ 12345678, " 12M",        4, 0, },
243
		{ 12345678, "12.3M",       5, 0, },
244
		{ 12345678, " 12.3M",      6, 0, },
245
		{ 12345678, "  12.3M",     7, 0, },
246
		{ 12345678, "   12.3M",    8, 0, },
247
		{ 12345678, "    12.3M",   9, 0, },
248

249
		{ 123456789, "123M",       0, 0, },
250
		{ 123456789, "123M",       1, 0, },
251
		{ 123456789, "123M",       2, 0, },
252
		{ 123456789, "123M",       3, 0, },
253
		{ 123456789, "123M",       4, 0, },
254
		{ 123456789, " 123M",      5, 0, },
255
		{ 123456789, "  123M",     6, 0, },
256
		{ 123456789, "   123M",    7, 0, },
257
		{ 123456789, "    123M",   8, 0, },
258
		{ 123456789, "     123M",  9, 0, },
259

260
		{ 1234567, "1.18Mi",       0, PP_ALTERNATE_FORM2, },
261
		{ 1234567, "1Mi",          1, PP_ALTERNATE_FORM2, },
262
		{ 1234567, "1Mi",          2, PP_ALTERNATE_FORM2, },
263
		{ 1234567, "1Mi",          3, PP_ALTERNATE_FORM2, },
264
		{ 1234567, " 1Mi",         4, PP_ALTERNATE_FORM2, },
265
		{ 1234567, "1.2Mi",        5, PP_ALTERNATE_FORM2, },
266
		{ 1234567, "1.18Mi",       6, PP_ALTERNATE_FORM2, },
267
		{ 1234567, " 1.18Mi",      7, PP_ALTERNATE_FORM2, },
268
		{ 1234567, "  1.18Mi",     8, PP_ALTERNATE_FORM2, },
269
		{ 1234567, "   1.18Mi",    9, PP_ALTERNATE_FORM2, },
270

271
		{ 12345678, "11.8Mi",      0, PP_ALTERNATE_FORM2, },
272
		{ 12345678, "12Mi",        1, PP_ALTERNATE_FORM2, },
273
		{ 12345678, "12Mi",        2, PP_ALTERNATE_FORM2, },
274
		{ 12345678, "12Mi",        3, PP_ALTERNATE_FORM2, },
275
		{ 12345678, "12Mi",        4, PP_ALTERNATE_FORM2, },
276
		{ 12345678, " 12Mi",       5, PP_ALTERNATE_FORM2, },
277
		{ 12345678, "11.8Mi",      6, PP_ALTERNATE_FORM2, },
278
		{ 12345678, " 11.8Mi",     7, PP_ALTERNATE_FORM2, },
279
		{ 12345678, "  11.8Mi",    8, PP_ALTERNATE_FORM2, },
280
		{ 12345678, "   11.8Mi",   9, PP_ALTERNATE_FORM2, },
281

282
		{ 123456789, "118Mi",      0, PP_ALTERNATE_FORM2, },
283
		{ 123456789, "118Mi",      1, PP_ALTERNATE_FORM2, },
284
		{ 123456789, "118Mi",      2, PP_ALTERNATE_FORM2, },
285
		{ 123456789, "118Mi",      3, PP_ALTERNATE_FORM2, },
286
		{ 123456789, "118Mi",      4, PP_ALTERNATE_FORM2, },
287
		{ 123456789, "118Mi",      5, PP_ALTERNATE_FORM2, },
288
		{ 123456789, " 118Mi",     6, PP_ALTERNATE_FORM2, },
289
		{ 123456789, "  118Mi",    7, PP_ALTERNATE_FORM2, },
290
		{ 123456789, "   118Mi",   8, PP_ALTERNATE_FORM2, },
291
		{ 123456789, "    118Mi",  9, PP_ALTERNATE_FORM2, },
292

293
		{  1234567, "1.23M",  0, PP_ALTERNATE_FORM1, },
294
		{  1234567, "1.18Mi", 0, PP_ALTERNATE_FORM2, },
295
		{  1234567, "1.23 M", 6, PP_LEFT_ALIGN, },
296
		{  1234567, "+1.23M", 0, PP_EXPLICIT_PLUS, },
297
		{ -1234567, "-1.23M", 0, PP_EXPLICIT_PLUS, },
298
		{  1234567, " 1.23M", 0, PP_SPACE_FOR_PLUS, },
299
		{ -1234567, "-1.23M", 0, PP_SPACE_FOR_PLUS, },
300
		{  1234567, "01.23M", 6, PP_ZERO_PAD, },
301
		{  1234567, "1.23M",  0, PP_THOUSANDS_SEP, },
302
		{  1023,"1023", 0, PP_ALTERNATE_FORM2|PP_THOUSANDS_SEP, },
303

304
		{ -1,                  NULL,     0, 0, },
305
	};
306

307
	p = new_percent_esc();
308

309
	ATF_REQUIRE_EQ(p != NULL, true);
310

311
	for (i = 0; hn_test_vals[i].out != NULL; i++) {
312
		xstring_renew(buf);
313
		p->width = hn_test_vals[i].width;
314
		p->flags = hn_test_vals[i].flags;
315
		buf = human_number(buf, hn_test_vals[i].in, p);
316
		fflush(buf->fp);
317
		ATF_CHECK_STREQ(buf->buf, hn_test_vals[i].out);
318
	}
319

320
	free_percent_esc(p);
321
	xstring_free(buf);
322
}
323

324
ATF_TC(string_val);
325
ATF_TC_HEAD(string_val, tc)
326
{
327
	atf_tc_set_md_var(tc, "descr",
328
			  "Testing string_val() output routine");
329
}
330
ATF_TC_BODY(string_val, tc)
331
{
332
	xstring		*buf = NULL;
333
	struct percent_esc	*p;
334
	int			 i;
335

336
	struct sv_test_vals {
337
		const char *in;
338
		const char *out;
339
		int width;
340
		unsigned flags;
341
	} sv_test_vals[] = {
342
		{ "xxx", "xxx",    0, 0, },
343
		{ "xxx", "xxx",    1, 0, },
344
		{ "xxx", "xxx",    2, 0, },
345
		{ "xxx", "xxx",    3, 0, },
346
		{ "xxx", " xxx",   4, 0, },
347
		{ "xxx", "  xxx",  5, 0, },
348
		{ "xxx", "   xxx", 6, 0, },
349

350
		{ "xxy", "xxy",    0, PP_LEFT_ALIGN, },
351
		{ "xxy", "xxy",    1, PP_LEFT_ALIGN, },
352
		{ "xxy", "xxy",    2, PP_LEFT_ALIGN, },
353
		{ "xxy", "xxy",    3, PP_LEFT_ALIGN, },
354
		{ "xxy", "xxy ",   4, PP_LEFT_ALIGN, },
355
		{ "xxy", "xxy  ",  5, PP_LEFT_ALIGN, },
356
		{ "xxy", "xxy   ", 6, PP_LEFT_ALIGN, },
357

358
		/* Zero padding a string is non-portable, so ignore 
359
		   that flag when printing string values */
360

361
		{ "xxz", "xxz",    0, PP_ZERO_PAD, },
362
		{ "xxz", "xxz",    1, PP_ZERO_PAD, },
363
		{ "xxz", "xxz",    2, PP_ZERO_PAD, },
364
		{ "xxz", "xxz",    3, PP_ZERO_PAD, },
365
		{ "xxz", " xxz",   4, PP_ZERO_PAD, },
366
		{ "xxz", "  xxz",  5, PP_ZERO_PAD, },
367
		{ "xxz", "   xxz", 6, PP_ZERO_PAD, },
368

369
		/* Seems you can't zero pad on the RHS of a string */
370

371
		{ "xyx", "xyx",    0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
372
		{ "xyx", "xyx",    1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
373
		{ "xyx", "xyx",    2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
374
		{ "xyx", "xyx",    3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
375
		{ "xyx", "xyx ",   4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
376
		{ "xyx", "xyx  ",  5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
377
		{ "xyx", "xyx   ", 6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
378

379
		/* Most of the format modifiers don't affect strings */
380

381
		{ "aaa", "aaa", 0, PP_ALTERNATE_FORM1, },
382
		{ "bbb", "bbb", 0, PP_ALTERNATE_FORM2, },
383
		{ "ccc", "ccc", 0, PP_EXPLICIT_PLUS, },
384
		{ "ddd", "ddd", 0, PP_SPACE_FOR_PLUS, },
385
		{ "eee", "eee", 0, PP_THOUSANDS_SEP, },
386

387
		{ NULL, NULL, 0, 0, },
388
	};
389

390
	p = new_percent_esc();
391

392
	ATF_REQUIRE_EQ(p != NULL, true);
393

394
	for (i = 0; sv_test_vals[i].out != NULL; i++) {
395
		xstring_renew(buf);
396
		p->width = sv_test_vals[i].width;
397
		p->flags = sv_test_vals[i].flags;
398
		buf = string_val(buf, sv_test_vals[i].in, p);
399
		fflush(buf->fp);
400
		ATF_CHECK_STREQ(buf->buf, sv_test_vals[i].out);
401
	}
402

403
	free_percent_esc(p);
404
	xstring_free(buf);
405
}
406

407
ATF_TC(int_val);
408
ATF_TC_HEAD(int_val, tc)
409
{
410
	atf_tc_set_md_var(tc, "descr",
411
			  "Testing int_val() output routine");
412
}
413
ATF_TC_BODY(int_val, tc)
414
{
415
	xstring		*buf = NULL;
416
	struct percent_esc	*p;
417
	int			 i;
418

419
	struct iv_test_vals {
420
		int64_t in;
421
		const char *out;
422
		int width;
423
		unsigned flags;
424
	} iv_test_vals[] = {
425
		{ 0,      "0",   0, 0, },
426

427
		{ 1,      "1",   0, 0, },
428
		{ -1,     "-1",  0, 0, },
429

430
		{ 340,    "340",       0, 0, },
431
		{ 341,    "341",       1, 0, },
432
		{ 342,    "342",       2, 0, },
433
		{ 343,    "343",       3, 0, },
434
		{ 344,    " 344",      4, 0, },
435
		{ 345,    "  345",     5, 0, },
436
		{ 346,    "   346",    6, 0, },
437
		{ 347,    "    347",   7, 0, },
438
		{ 348,    "     348",  8, 0, },
439
		{ 349,    "      349", 9, 0, },
440

441
		{ 350,    "350",       0, PP_LEFT_ALIGN, },
442
		{ 351,    "351",       1, PP_LEFT_ALIGN, },
443
		{ 352,    "352",       2, PP_LEFT_ALIGN, },
444
		{ 353,    "353",       3, PP_LEFT_ALIGN, },
445
		{ 354,    "354 ",      4, PP_LEFT_ALIGN, },
446
		{ 355,    "355  ",     5, PP_LEFT_ALIGN, },
447
		{ 356,    "356   ",    6, PP_LEFT_ALIGN, },
448
		{ 357,    "357    ",   7, PP_LEFT_ALIGN, },
449
		{ 358,    "358     ",  8, PP_LEFT_ALIGN, },
450
		{ 359,    "359      ", 9, PP_LEFT_ALIGN, },
451

452
		{ 360,    "+360",      0, PP_EXPLICIT_PLUS, },
453
		{ 361,    "+361",      1, PP_EXPLICIT_PLUS, },
454
		{ 362,    "+362",      2, PP_EXPLICIT_PLUS, },
455
		{ 363,    "+363",      3, PP_EXPLICIT_PLUS, },
456
		{ 364,    "+364",      4, PP_EXPLICIT_PLUS, },
457
		{ 365,    " +365",     5, PP_EXPLICIT_PLUS, },
458
		{ 366,    "  +366",    6, PP_EXPLICIT_PLUS, },
459
		{ 367,    "   +367",   7, PP_EXPLICIT_PLUS, },
460
		{ 368,    "    +368",  8, PP_EXPLICIT_PLUS, },
461
		{ 369,    "     +369", 9, PP_EXPLICIT_PLUS, },
462

463
		{ -370,   "-370",      0, PP_EXPLICIT_PLUS, },
464
		{ -371,   "-371",      1, PP_EXPLICIT_PLUS, },
465
		{ -372,   "-372",      2, PP_EXPLICIT_PLUS, },
466
		{ -373,   "-373",      3, PP_EXPLICIT_PLUS, },
467
		{ -374,   "-374",      4, PP_EXPLICIT_PLUS, },
468
		{ -375,   " -375",     5, PP_EXPLICIT_PLUS, },
469
		{ -376,   "  -376",    6, PP_EXPLICIT_PLUS, },
470
		{ -377,   "   -377",   7, PP_EXPLICIT_PLUS, },
471
		{ -378,   "    -378",  8, PP_EXPLICIT_PLUS, },
472
		{ -379,   "     -379", 9, PP_EXPLICIT_PLUS, },
473

474
		{ 380,    " 380",      0, PP_SPACE_FOR_PLUS, },
475
		{ 381,    " 381",      1, PP_SPACE_FOR_PLUS, },
476
		{ 382,    " 382",      2, PP_SPACE_FOR_PLUS, },
477
		{ 383,    " 383",      3, PP_SPACE_FOR_PLUS, },
478
		{ 384,    " 384",      4, PP_SPACE_FOR_PLUS, },
479
		{ 385,    "  385",     5, PP_SPACE_FOR_PLUS, },
480
		{ 386,    "   386",    6, PP_SPACE_FOR_PLUS, },
481
		{ 387,    "    387",   7, PP_SPACE_FOR_PLUS, },
482
		{ 388,    "     388",  8, PP_SPACE_FOR_PLUS, },
483
		{ 389,    "      389", 9, PP_SPACE_FOR_PLUS, },
484

485
		{ -390,   "-390",      0, PP_SPACE_FOR_PLUS, },
486
		{ -391,   "-391",      1, PP_SPACE_FOR_PLUS, },
487
		{ -392,   "-392",      2, PP_SPACE_FOR_PLUS, },
488
		{ -393,   "-393",      3, PP_SPACE_FOR_PLUS, },
489
		{ -394,   "-394",      4, PP_SPACE_FOR_PLUS, },
490
		{ -395,   " -395",     5, PP_SPACE_FOR_PLUS, },
491
		{ -396,   "  -396",    6, PP_SPACE_FOR_PLUS, },
492
		{ -397,   "   -397",   7, PP_SPACE_FOR_PLUS, },
493
		{ -398,   "    -398",  8, PP_SPACE_FOR_PLUS, },
494
		{ -399,   "     -399", 9, PP_SPACE_FOR_PLUS, },
495

496
		{ 400,    "+400",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
497
		{ 401,    "+401",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
498
		{ 402,    "+402",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
499
		{ 403,    "+403",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
500
		{ 404,    "+404",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
501
		{ 405,    "+405 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
502
		{ 406,    "+406  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
503
		{ 407,    "+407   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
504
		{ 408,    "+408    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
505
		{ 409,    "+409     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
506

507
		{ -410,   "-410",      0, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
508
		{ -411,   "-411",      1, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
509
		{ -412,   "-412",      2, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
510
		{ -413,   "-413",      3, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
511
		{ -414,   "-414",      4, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
512
		{ -415,   "-415 ",     5, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
513
		{ -416,   "-416  ",    6, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
514
		{ -417,   "-417   ",   7, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
515
		{ -418,   "-418    ",  8, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
516
		{ -419,   "-419     ", 9, PP_LEFT_ALIGN|PP_EXPLICIT_PLUS, },
517

518
		{ 420,    " 420",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
519
		{ 421,    " 421",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
520
		{ 422,    " 422",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
521
		{ 423,    " 423",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
522
		{ 424,    " 424",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
523
		{ 425,    " 425 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
524
		{ 426,    " 426  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
525
		{ 427,    " 427   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
526
		{ 428,    " 428    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
527
		{ 429,    " 429     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
528

529
		{ -430,   "-430",      0, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
530
		{ -431,   "-431",      1, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
531
		{ -432,   "-432",      2, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
532
		{ -433,   "-433",      3, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
533
		{ -434,   "-434",      4, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
534
		{ -435,   "-435 ",     5, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
535
		{ -436,   "-436  ",    6, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
536
		{ -437,   "-437   ",   7, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
537
		{ -438,   "-438    ",  8, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
538
		{ -439,   "-439     ", 9, PP_LEFT_ALIGN|PP_SPACE_FOR_PLUS, },
539

540
		{ 440,    "440",       0, PP_ZERO_PAD, },
541
		{ 441,    "441",       1, PP_ZERO_PAD, },
542
		{ 442,    "442",       2, PP_ZERO_PAD, },
543
		{ 443,    "443",       3, PP_ZERO_PAD, },
544
		{ 444,    "0444",      4, PP_ZERO_PAD, },
545
		{ 445,    "00445",     5, PP_ZERO_PAD, },
546
		{ 446,    "000446",    6, PP_ZERO_PAD, },
547
		{ 447,    "0000447",   7, PP_ZERO_PAD, },
548
		{ 448,    "00000448",  8, PP_ZERO_PAD, },
549
		{ 449,    "000000449", 9, PP_ZERO_PAD, },
550

551
		{ -450,    "-450",      0, PP_ZERO_PAD, },
552
		{ -451,    "-451",      1, PP_ZERO_PAD, },
553
		{ -452,    "-452",      2, PP_ZERO_PAD, },
554
		{ -453,    "-453",      3, PP_ZERO_PAD, },
555
		{ -454,    "-454",      4, PP_ZERO_PAD, },
556
		{ -455,    "-0455",     5, PP_ZERO_PAD, },
557
		{ -456,    "-00456",    6, PP_ZERO_PAD, },
558
		{ -457,    "-000457",   7, PP_ZERO_PAD, },
559
		{ -458,    "-0000458",  8, PP_ZERO_PAD, },
560
		{ -459,    "-00000459", 9, PP_ZERO_PAD, },
561

562
		{ 460,    "+460",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
563
		{ 461,    "+461",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
564
		{ 462,    "+462",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
565
		{ 463,    "+463",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
566
		{ 464,    "+464",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
567
		{ 465,    "+0465",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
568
		{ 466,    "+00466",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
569
		{ 467,    "+000467",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
570
		{ 468,    "+0000468",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
571
		{ 469,    "+00000469", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
572

573
		{ -470,    "-470",      0, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
574
		{ -471,    "-471",      1, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
575
		{ -472,    "-472",      2, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
576
		{ -473,    "-473",      3, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
577
		{ -474,    "-474",      4, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
578
		{ -475,    "-0475",     5, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
579
		{ -476,    "-00476",    6, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
580
		{ -477,    "-000477",   7, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
581
		{ -478,    "-0000478",  8, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
582
		{ -479,    "-00000479", 9, PP_EXPLICIT_PLUS|PP_ZERO_PAD, },
583

584
		{ 480,    " 480",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
585
		{ 481,    " 481",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
586
		{ 482,    " 482",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
587
		{ 483,    " 483",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
588
		{ 484,    " 484",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
589
		{ 485,    " 0485",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
590
		{ 486,    " 00486",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
591
		{ 487,    " 000487",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
592
		{ 488,    " 0000488",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
593
		{ 489,    " 00000489", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
594

595
		{ -490,    "-490",      0, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
596
		{ -491,    "-491",      1, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
597
		{ -492,    "-492",      2, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
598
		{ -493,    "-493",      3, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
599
		{ -494,    "-494",      4, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
600
		{ -495,    "-0495",     5, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
601
		{ -496,    "-00496",    6, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
602
		{ -497,    "-000497",   7, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
603
		{ -498,    "-0000498",  8, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
604
		{ -499,    "-00000499", 9, PP_SPACE_FOR_PLUS|PP_ZERO_PAD, },
605

606
		/* PP_LEFT_ALIGN beats PP_ZERO_PAD */
607

608
		{ 500,    "500",       0, PP_ZERO_PAD|PP_LEFT_ALIGN, },
609
		{ 501,    "501",       1, PP_ZERO_PAD|PP_LEFT_ALIGN, },
610
		{ 502,    "502",       2, PP_ZERO_PAD|PP_LEFT_ALIGN, },
611
		{ 503,    "503",       3, PP_ZERO_PAD|PP_LEFT_ALIGN, },
612
		{ 504,    "504 ",      4, PP_ZERO_PAD|PP_LEFT_ALIGN, },
613
		{ 505,    "505  ",     5, PP_ZERO_PAD|PP_LEFT_ALIGN, },
614
		{ 506,    "506   ",    6, PP_ZERO_PAD|PP_LEFT_ALIGN, },
615
		{ 507,    "507    ",   7, PP_ZERO_PAD|PP_LEFT_ALIGN, },
616
		{ 508,    "508     ",  8, PP_ZERO_PAD|PP_LEFT_ALIGN, },
617
		{ 509,    "509      ", 9, PP_ZERO_PAD|PP_LEFT_ALIGN, },
618

619
		/* PP_EXPLICIT_PLUS beats PP_SPACE_FOR_PLUS */
620

621
		{ 700,    "+700",       0, PP_EXPLICIT_PLUS|PP_SPACE_FOR_PLUS, },
622

623
		/* See human_number for comprehensive tests of
624
		   PP_ALTERNATE_FORM1 and PP_ALTERNATE_FORM2 */
625

626
		{ -1, NULL, 0, 0, },
627
	}; 
628

629
	p = new_percent_esc();
630

631
	ATF_REQUIRE_EQ(p != NULL, true);
632

633
	for (i = 0; iv_test_vals[i].out != NULL; i++) {
634
		xstring_renew(buf);
635
		p->width = iv_test_vals[i].width;
636
		p->flags = iv_test_vals[i].flags;
637
		buf = int_val(buf, iv_test_vals[i].in, p);
638
		fflush(buf->fp);
639
		ATF_CHECK_STREQ(buf->buf, iv_test_vals[i].out);
640
	}
641

642
	free_percent_esc(p);
643
	xstring_free(buf);
644
}
645

646
ATF_TC(bool_val);
647
ATF_TC_HEAD(bool_val, tc)
648
{
649
	atf_tc_set_md_var(tc, "descr",
650
			  "Testing bool_val() output routine");
651
}
652
ATF_TC_BODY(bool_val, tc)
653
{
654
	xstring		*buf = NULL;
655
	struct percent_esc	*p;
656
	int			 i;
657

658
	struct bv_test_vals {
659
		bool in;
660
		const char *out;
661
		int width;
662
		unsigned flags;
663
	} bv_test_vals[] = {
664
		{ false, "false", 0, 0, },
665
		{ true,  "true",  0, 0, },
666

667
		{ false, "no",    0, PP_ALTERNATE_FORM1, },
668
		{ true,  "yes",   0, PP_ALTERNATE_FORM1, },
669

670
		{ false, "",      0, PP_ALTERNATE_FORM2, },
671
		{ true,  "(*)",   0, PP_ALTERNATE_FORM2, },
672

673
		/*
674
		 * See string_val() for tests on field-width and
675
		 * left-align
676
		 */
677

678
		{ false, NULL, 0, 0, },
679
	};
680

681
	p = new_percent_esc();
682

683
	ATF_REQUIRE_EQ(p != NULL, true);
684

685
	for (i = 0; bv_test_vals[i].out != NULL; i++) {
686
		xstring_renew(buf);
687
		p->width = bv_test_vals[i].width;
688
		p->flags = bv_test_vals[i].flags;
689
		buf = bool_val(buf, bv_test_vals[i].in, p);
690
		fflush(buf->fp);
691
		ATF_CHECK_STREQ(buf->buf, bv_test_vals[i].out);
692
	}
693

694
	free_percent_esc(p);
695
	xstring_free(buf);
696
}
697

698
ATF_TC(mode_val);
699
ATF_TC_HEAD(mode_val, tc)
700
{
701
	atf_tc_set_md_var(tc, "descr",
702
			  "Testing mode_val() output routine");
703
}
704
ATF_TC_BODY(mode_val, tc)
705
{
706
	xstring		*buf = NULL;
707
	struct percent_esc	*p;
708
	int			 i;
709

710
	struct mv_test_vals {
711
		int64_t in;
712
		const char *out;
713
		int width;
714
		unsigned flags;
715
	} mv_test_vals[] = {
716
		{ 00000, "0",          0, 0, },
717
		{ 00007, "7",          0, 0, },
718
		{ 00070, "70",         0, 0, },
719
		{ 00700, "700",        0, 0, },
720
		{ 07000, "7000",       0, 0, },
721

722
		{ 00000, "    0",      5, 0, },
723
		{ 00007, "    7",      5, 0, },
724
		{ 00070, "   70",      5, 0, },
725
		{ 00700, "  700",      5, 0, },
726
		{ 07000, " 7000",      5, 0, },
727

728
		{ 00000, "        0",  9, 0, },
729
		{ 00007, "        7",  9, 0, },
730
		{ 00070, "       70",  9, 0, },
731
		{ 00700, "      700",  9, 0, },
732
		{ 07000, "     7000",  9, 0, },
733

734
		/*
735
                 * Shows a ? character for 'unknown inode type'.  Note
736
		 * the trailing space.
737
		 */
738

739
		{ 00000, "?--------- ", 0, PP_ALTERNATE_FORM1, },
740
		{ 00007, "?------rwx ", 0, PP_ALTERNATE_FORM1, },
741
		{ 00070, "?---rwx--- ", 0, PP_ALTERNATE_FORM1, },
742
		{ 00700, "?rwx------ ", 0, PP_ALTERNATE_FORM1, },
743
		{ 07000, "?--S--S--T ", 0, PP_ALTERNATE_FORM1, },
744
		{ 07111, "?--s--s--t ", 0, PP_ALTERNATE_FORM1, },
745

746
		{ 00000, "0",          0, PP_ALTERNATE_FORM2, },
747
		{ 00007, "07",         0, PP_ALTERNATE_FORM2, },
748
		{ 00070, "070",        0, PP_ALTERNATE_FORM2, },
749
		{ 00700, "0700",       0, PP_ALTERNATE_FORM2, },
750
		{ 07000, "07000",      0, PP_ALTERNATE_FORM2, },
751

752
		{ 00000, "    0",      5, PP_ALTERNATE_FORM2, },
753
		{ 00007, "   07",      5, PP_ALTERNATE_FORM2, },
754
		{ 00070, "  070",      5, PP_ALTERNATE_FORM2, },
755
		{ 00700, " 0700",      5, PP_ALTERNATE_FORM2, },
756
		{ 07000, "07000",      5, PP_ALTERNATE_FORM2, },
757

758
		{ 00000, "        0",  9, PP_ALTERNATE_FORM2, },
759
		{ 00007, "       07",  9, PP_ALTERNATE_FORM2, },
760
		{ 00070, "      070",  9, PP_ALTERNATE_FORM2, },
761
		{ 00700, "     0700",  9, PP_ALTERNATE_FORM2, },
762
		{ 07000, "    07000",  9, PP_ALTERNATE_FORM2, },
763

764
		/*
765
		 * The device type bits: 0170000
766
		 */
767

768
		{ 0010000, "0", 0, 0, }, /* FIFO */
769
		{ 0020000, "0", 0, 0, }, /* Char special */
770
		{ 0060000, "0", 0, 0, }, /* Block special */
771
		{ 0100000, "0", 0, 0, }, /* Regular file */
772
		{ 0120000, "0", 0, 0, }, /* Sym-link */
773
		{ 0140000, "0", 0, 0, }, /* socket */
774
		{ 0160000, "0", 0, 0, }, /* whiteout */
775

776
		{ 0010000, "p--------- ", 0, PP_ALTERNATE_FORM1, }, /* FIFO */
777
		{ 0020000, "c--------- ", 0, PP_ALTERNATE_FORM1, }, /* Char special */
778
		{ 0060000, "b--------- ", 0, PP_ALTERNATE_FORM1, }, /* Block special */
779
		{ 0100000, "---------- ", 0, PP_ALTERNATE_FORM1, }, /* Regular file */
780
		{ 0120000, "l--------- ", 0, PP_ALTERNATE_FORM1, }, /* Sym-link */
781
		{ 0140000, "s--------- ", 0, PP_ALTERNATE_FORM1, }, /* socket */
782
#ifndef __linux__
783
		{ 0160000, "w--------- ", 0, PP_ALTERNATE_FORM1, }, /* whiteout */
784
#else
785
		{ 0160000, "?--------- ", 0, PP_ALTERNATE_FORM1, }, /* whiteout */
786
#endif
787

788
		{ 0010000, "10000",  0, PP_EXPLICIT_PLUS, }, /* FIFO */
789
		{ 0020000, "20000",  0, PP_EXPLICIT_PLUS, }, /* Char special */
790
		{ 0060000, "60000",  0, PP_EXPLICIT_PLUS, }, /* Block special */
791
		{ 0100000, "100000", 0, PP_EXPLICIT_PLUS, }, /* Regular file */
792
		{ 0120000, "120000", 0, PP_EXPLICIT_PLUS, }, /* Sym-link */
793
		{ 0140000, "140000", 0, PP_EXPLICIT_PLUS, }, /* socket */
794
		{ 0160000, "160000", 0, PP_EXPLICIT_PLUS, }, /* whiteout */
795

796
		{ 0, NULL, 0, 0, },
797
	};
798

799
	p = new_percent_esc();
800

801
	ATF_REQUIRE_EQ(p != NULL, true);
802

803
	for (i = 0; mv_test_vals[i].out != NULL; i++) {
804
		xstring_renew(buf);
805
		p->width = mv_test_vals[i].width;
806
		p->flags = mv_test_vals[i].flags;
807
		buf = mode_val(buf, mv_test_vals[i].in, p);
808
		fflush(buf->fp);
809
		ATF_CHECK_STREQ(buf->buf, mv_test_vals[i].out);
810
	}
811

812
	free_percent_esc(p);
813
	xstring_free(buf);
814
}
815

816
ATF_TC(liclog_val);
817
ATF_TC_HEAD(liclog_val, tc)
818
{
819
	atf_tc_set_md_var(tc, "descr",
820
			  "Testing liclog_val() output routine");
821
}
822
ATF_TC_BODY(liclog_val, tc)
823
{
824
	xstring		*buf = NULL;
825
	struct percent_esc	*p;
826
	int			 i;
827

828
	struct lv_test_vals {
829
		lic_t in;
830
		const char *out;
831
		int width;
832
		unsigned flags;
833
	} lv_test_vals[] = {
834
		{ LICENSE_SINGLE, "single", 0, 0, },
835
		{ LICENSE_OR,     "or",     0, 0, },
836
		{ LICENSE_AND,    "and",    0, 0, },
837

838
		{ LICENSE_SINGLE, "",       0, PP_ALTERNATE_FORM1, },
839
		{ LICENSE_OR,     "|",      0, PP_ALTERNATE_FORM1, },
840
		{ LICENSE_AND,    "&",      0, PP_ALTERNATE_FORM1, },
841

842
		{ LICENSE_SINGLE, "==",     0, PP_ALTERNATE_FORM2, },
843
		{ LICENSE_OR,     "||",     0, PP_ALTERNATE_FORM2, },
844
		{ LICENSE_AND,    "&&",     0, PP_ALTERNATE_FORM2, },
845

846
		/*
847
		 * See string_val() for tests on field-width and
848
		 * left-align
849
		 */
850

851
		{ 0, NULL, 0, 0, },
852
	};
853

854
	p = new_percent_esc();
855

856
	ATF_REQUIRE_EQ(p != NULL, true);
857

858
	for (i = 0; lv_test_vals[i].out != NULL; i++) {
859
		xstring_renew(buf);
860
		p->width = lv_test_vals[i].width;
861
		p->flags = lv_test_vals[i].flags;
862
		buf = liclog_val(buf, lv_test_vals[i].in, p);
863
		fflush(buf->fp);
864
		ATF_CHECK_STREQ(buf->buf, lv_test_vals[i].out);
865
	}
866

867
	free_percent_esc(p);
868
	xstring_free(buf);
869
}
870

871
ATF_TC(list_count);
872
ATF_TC_HEAD(list_count, tc)
873
{
874
	atf_tc_set_md_var(tc, "descr",
875
			  "Testing list_count() output routine");
876
}
877
ATF_TC_BODY(list_count, tc)
878
{
879
	xstring		*buf = NULL;
880
	struct percent_esc	*p;
881
	int			 i;
882

883
	struct lc_test_vals {
884
		int64_t in;
885
		const char *out;
886
		int width;
887
		unsigned flags;
888
	} lc_test_vals[] = {
889
		{ 10, "10", 0, 0, },
890
		{ 20, "1",  0, PP_ALTERNATE_FORM1, },
891
		{ 30, "30", 0, PP_ALTERNATE_FORM2, },
892

893
		/*
894
		 * See int_val() for tests on field-width and
895
		 * left-align
896
		 */
897

898
		{ 0, NULL, 0, 0, },
899
	};
900

901
	p = new_percent_esc();
902

903
	ATF_REQUIRE_EQ(p != NULL, true);
904

905
	for (i = 0; lc_test_vals[i].out != NULL; i++) {
906
		xstring_renew(buf);
907
		p->width = lc_test_vals[i].width;
908
		p->flags = lc_test_vals[i].flags;
909
		buf = list_count(buf, lc_test_vals[i].in, p);
910
		fflush(buf->fp);
911
		ATF_CHECK_STREQ(buf->buf, lc_test_vals[i].out);
912
	}
913

914
	free_percent_esc(p);
915
	xstring_free(buf);
916
}
917

918
ATF_TC(maybe_read_hex_byte);
919
ATF_TC_HEAD(maybe_read_hex_byte, tc)
920
{
921
	atf_tc_set_md_var(tc, "descr",
922
	    "Testing maybe_read_hex_byte() format parsing routine");
923
}
924
ATF_TC_BODY(maybe_read_hex_byte, tc)
925
{
926
	xstring	*buf = NULL;
927
	const char	*f;
928
	int		 i;
929

930
	struct mrhb_test_vals {
931
		const char *in;
932
		const char *out; /* What gets written to the buf */
933
		ptrdiff_t   fend_offset; /* Where f is left pointing */
934
		char	    fend_val; /* expected first char in fend */
935
	} mrhb_test_vals[] = {
936
		{ "x61",   "a",    3, '\0', },
937
		{ "x",     "\\x",  1, '\0', },
938
		{ "xg",    "\\x",  1, 'g',  },
939
		{ "xf",    "\\x",  1, 'f',  },
940
		{ "xfg",   "\\x",  1, 'f',  },
941
		{ "xff",   "\xff", 3, '\0', },
942
		{ "xffg",  "\xff", 3, 'g',  },
943
		{ "xfffg", "\xff", 3, 'f',  },
944

945
		{ "x00",   "\0",   3, '\0', },
946
		{ "x01",   "\x01", 3, '\0', },
947
		{ "x02",   "\x02", 3, '\0', },
948
		{ "x03",   "\x03", 3, '\0', },
949
		{ "x04",   "\x04", 3, '\0', },
950
		{ "x05",   "\x05", 3, '\0', },
951
		{ "x06",   "\x06", 3, '\0', },
952
		{ "x07",   "\x07", 3, '\0', },
953
		{ "x08",   "\x08", 3, '\0', },
954
		{ "x09",   "\x09", 3, '\0', },
955
		{ "x0a",   "\x0a", 3, '\0', },
956
		{ "x0b",   "\x0b", 3, '\0', },
957
		{ "x0c",   "\x0c", 3, '\0', },
958
		{ "x0d",   "\x0d", 3, '\0', },
959
		{ "x0e",   "\x0e", 3, '\0', },
960
		{ "x0f",   "\x0f", 3, '\0', },
961

962
		{ "x0A",   "\x0a", 3, '\0', },
963
		{ "x0B",   "\x0b", 3, '\0', },
964
		{ "x0C",   "\x0c", 3, '\0', },
965
		{ "x0D",   "\x0d", 3, '\0', },
966
		{ "x0E",   "\x0e", 3, '\0', },
967
		{ "x0F",   "\x0f", 3, '\0', },
968

969
		{ "x10",   "\x10", 3, '\0', },
970
		{ "x20",   "\x20", 3, '\0', },
971
		{ "x30",   "\x30", 3, '\0', },
972
		{ "x40",   "\x40", 3, '\0', },
973
		{ "x50",   "\x50", 3, '\0', },
974
		{ "x60",   "\x60", 3, '\0', },
975
		{ "x70",   "\x70", 3, '\0', },
976
		{ "x80",   "\x80", 3, '\0', },
977
		{ "x90",   "\x90", 3, '\0', },
978
		{ "xa0",   "\xa0", 3, '\0', },
979
		{ "xb0",   "\xb0", 3, '\0', },
980
		{ "xc0",   "\xc0", 3, '\0', },
981
		{ "xd0",   "\xd0", 3, '\0', },
982
		{ "xe0",   "\xe0", 3, '\0', },
983
		{ "xf0",   "\xf0", 3, '\0', },
984

985
		{ "xA0",   "\xa0", 3, '\0', },
986
		{ "xB0",   "\xb0", 3, '\0', },
987
		{ "xC0",   "\xc0", 3, '\0', },
988
		{ "xD0",   "\xd0", 3, '\0', },
989
		{ "xE0",   "\xe0", 3, '\0', },
990
		{ "xF0",   "\xf0", 3, '\0', },
991

992
		{ NULL,   NULL,    0, '\0', },
993
	};
994

995
	for (i = 0; mrhb_test_vals[i].in != NULL; i++) {
996
		xstring_renew(buf);
997
		f = maybe_read_hex_byte(buf, mrhb_test_vals[i].in);
998
		fflush(buf->fp);
999

1000
		ATF_CHECK_STREQ_MSG(buf->buf, mrhb_test_vals[i].out,
1001
				    "(test %d)", i);
1002
		ATF_CHECK_EQ_MSG(f - mrhb_test_vals[i].in,
1003
				 mrhb_test_vals[i].fend_offset,
1004
				 "(test %d)", i);
1005
		ATF_CHECK_EQ_MSG(*f, mrhb_test_vals[i].fend_val,
1006
				 "(test %d)", i);
1007
	}
1008

1009
	xstring_free(buf);
1010
}
1011

1012

1013
ATF_TC(read_oct_byte);
1014
ATF_TC_HEAD(read_oct_byte, tc)
1015
{
1016
	atf_tc_set_md_var(tc, "descr",
1017
	    "Testing read_oct_byte() format parsing routine");
1018
}
1019
ATF_TC_BODY(read_oct_byte, tc)
1020
{
1021
	xstring	*buf = NULL;
1022
	const char	*f;
1023
	int		 i;
1024

1025
	struct rob_test_vals {
1026
		const char *in;
1027
		const char *out; /* What gets written to the buf */
1028
		ptrdiff_t   fend_offset; /* Where f is left pointing */
1029
		char	    fend_val; /* expected first char in fend */
1030
	} rob_test_vals[] = {
1031
		{ "141",    "a",   3, '\0', },
1032
		{ "0",      "\0",  1, '\0', },
1033
		{ "08",     "\0",  1, '8',  },
1034
		{ "008",    "\0",  2, '8',  },
1035
		{ "0008",   "\0",  3, '8',  },
1036
		{ "00008",  "\0",  3, '0',  },
1037

1038
		{ "1",     "\001", 1, '\0', },
1039
		{ "2",     "\002", 1, '\0', },
1040
		{ "3",     "\003", 1, '\0', },
1041
		{ "4",     "\004", 1, '\0', },
1042
		{ "5",     "\005", 1, '\0', },
1043
		{ "6",     "\006", 1, '\0', },
1044
		{ "7",     "\007", 1, '\0', },
1045

1046
		{ "00",    "\000", 2, '\0', },
1047
		{ "01",    "\001", 2, '\0', },
1048
		{ "02",    "\002", 2, '\0', },
1049
		{ "03",    "\003", 2, '\0', },
1050
		{ "04",    "\004", 2, '\0', },
1051
		{ "05",    "\005", 2, '\0', },
1052
		{ "06",    "\006", 2, '\0', },
1053
		{ "07",    "\007", 2, '\0', },
1054

1055
		{ "000",   "\000", 3, '\0', },
1056
		{ "001",   "\001", 3, '\0', },
1057
		{ "002",   "\002", 3, '\0', },
1058
		{ "003",   "\003", 3, '\0', },
1059
		{ "004",   "\004", 3, '\0', },
1060
		{ "005",   "\005", 3, '\0', },
1061
		{ "006",   "\006", 3, '\0', },
1062
		{ "007",   "\007", 3, '\0', },
1063

1064
		{ "10",    "\010", 2, '\0', },
1065
		{ "20",    "\020", 2, '\0', },
1066
		{ "30",    "\030", 2, '\0', },
1067
		{ "40",    "\040", 2, '\0', },
1068
		{ "50",    "\050", 2, '\0', },
1069
		{ "60",    "\060", 2, '\0', },
1070
		{ "70",    "\070", 2, '\0', },
1071

1072
		{ "010",   "\010", 3, '\0', },
1073
		{ "020",   "\020", 3, '\0', },
1074
		{ "030",   "\030", 3, '\0', },
1075
		{ "040",   "\040", 3, '\0', },
1076
		{ "050",   "\050", 3, '\0', },
1077
		{ "060",   "\060", 3, '\0', },
1078
		{ "070",   "\070", 3, '\0', },
1079

1080
		{ "100",   "\100", 3, '\0', },
1081
		{ "200",   "\200", 3, '\0', },
1082
		{ "300",   "\300", 3, '\0', },
1083

1084
		{ "370",   "\370", 3, '\0', },
1085
		{ "371",   "\371", 3, '\0', },
1086
		{ "372",   "\372", 3, '\0', },
1087
		{ "373",   "\373", 3, '\0', },
1088
		{ "374",   "\374", 3, '\0', },
1089
		{ "375",   "\375", 3, '\0', },
1090
		{ "376",   "\376", 3, '\0', },
1091
		{ "377",   "\377", 3, '\0', },
1092
		{ "400",   "\040", 2, '0',  },
1093

1094
		{ NULL,   NULL,    0, '\0', },
1095
	};
1096

1097
	for (i = 0; rob_test_vals[i].in != NULL; i++) {
1098
		xstring_renew(buf);
1099
		f = read_oct_byte(buf, rob_test_vals[i].in);
1100
		fflush(buf->fp);
1101

1102
		ATF_CHECK_STREQ_MSG(buf->buf, rob_test_vals[i].out,
1103
				    "(test %d)", i);
1104
		ATF_CHECK_EQ_MSG(f - rob_test_vals[i].in,
1105
				 rob_test_vals[i].fend_offset,
1106
				 "(test %d)", i);
1107
		ATF_CHECK_EQ_MSG(*f, rob_test_vals[i].fend_val,
1108
				 "(test %d)", i);
1109
	}
1110

1111
	xstring_free(buf);
1112
}
1113

1114
ATF_TC(process_escape);
1115
ATF_TC_HEAD(process_escape, tc)
1116
{
1117
	atf_tc_set_md_var(tc, "descr",
1118
	    "Testing process_escape() format parsing routine");
1119
}
1120
ATF_TC_BODY(process_escape, tc)
1121
{
1122
	xstring	*buf = NULL;
1123
	const char	*f;
1124
	int		 i;
1125

1126
	struct pe_test_vals {
1127
		const char *in;
1128
		const char *out; /* What gets written to the buf */
1129
		ptrdiff_t   fend_offset; /* Where f is left pointing */
1130
		char	    fend_val; /* expected first char in fend */
1131
	} pe_test_vals[] = {
1132
		{ "\\a",   "\a",   2, '\0', },
1133
		{ "\\b",   "\b",   2, '\0', },
1134
		{ "\\f",   "\f",   2, '\0', },
1135
		{ "\\n",   "\n",   2, '\0', },
1136
		{ "\\t",   "\t",   2, '\0', },
1137
		{ "\\v",   "\v",   2, '\0', },
1138
		{ "\\'",   "'",    2, '\0', },
1139
		{ "\\\"",  "\"",   2, '\0', },
1140
		{ "\\\\",  "\\",   2, '\0', },
1141

1142
		{ "\\q",   "\\",   1, 'q',  },
1143

1144
		/* See read_oct_byte() for more comprehensive tests on
1145
		   octal number escapes */
1146

1147
		{ "\\1234",  "S",   4, '4',  },
1148
		{ "\\89",    "\\",  1, '8',  },
1149

1150
		/* See maybe_read_hex_byte() for more comprehensive
1151
		   tests on hexadecimal number escapes */
1152

1153
		{ "\\x4cd",  "L",   4, 'd', },
1154
		{ "\\xGG",   "\\x", 2, 'G', },
1155

1156
		{ NULL,   NULL,    0, '\0', },
1157
	};
1158

1159
	for (i = 0; pe_test_vals[i].in != NULL; i++) {
1160
		xstring_renew(buf);
1161
		f = process_escape(buf, pe_test_vals[i].in);
1162
		fflush(buf->fp);
1163

1164
		ATF_CHECK_STREQ_MSG(buf->buf, pe_test_vals[i].out,
1165
				    "(test %d)", i);
1166
		ATF_CHECK_EQ_MSG(f - pe_test_vals[i].in,
1167
				 pe_test_vals[i].fend_offset,
1168
				 "(test %d)", i);
1169
		ATF_CHECK_EQ_MSG(*f, pe_test_vals[i].fend_val,
1170
				 "(test %d)", i);
1171
	}
1172

1173
	xstring_free(buf);
1174
}
1175

1176
ATF_TC(field_modifier);
1177
ATF_TC_HEAD(field_modifier, tc)
1178
{
1179
	atf_tc_set_md_var(tc, "descr",
1180
	    "Testing field_modifier() format parsing routine");
1181
}
1182
ATF_TC_BODY(field_modifier, tc)
1183
{
1184
	struct percent_esc	*p;
1185
	const char		*f;
1186
	int		 	i;
1187

1188
	struct fm_test_vals {
1189
		const char *in;
1190
		unsigned flags; 
1191
		ptrdiff_t   fend_offset; /* Where f is left pointing */
1192
		char	    fend_val; /* expected first char in fend */
1193
	} fm_test_vals[] = {
1194
		{ "?",  PP_ALTERNATE_FORM1, 1, '\0', },
1195
		{ "#",  PP_ALTERNATE_FORM2, 1, '\0', },
1196
		{ "-",  PP_LEFT_ALIGN,      1, '\0', },
1197
		{ "+",  PP_EXPLICIT_PLUS,   1, '\0', },
1198
		{ " ",  PP_SPACE_FOR_PLUS,  1, '\0', },
1199
		{ "0",  PP_ZERO_PAD,        1, '\0', },
1200
		{ "\'", PP_THOUSANDS_SEP,   1, '\0', },
1201

1202
		/* Not a format modifier... */
1203
		{ "z",  0,  0, 'z', },
1204
		{ "*",  0,  0, '*', },
1205
		{ "1",  0,  0, '1', },
1206

1207
		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
1208
		{ "##",   PP_ALTERNATE_FORM2, 2, '\0', },
1209
		{ "###",  PP_ALTERNATE_FORM2, 3, '\0', },
1210
		{ "####", PP_ALTERNATE_FORM2, 4, '\0', },
1211

1212
		{ "#z",    PP_ALTERNATE_FORM2, 1, 'z', },
1213
		{ "##z",   PP_ALTERNATE_FORM2, 2, 'z', },
1214
		{ "###z",  PP_ALTERNATE_FORM2, 3, 'z', },
1215
		{ "####z", PP_ALTERNATE_FORM2, 4, 'z', },
1216

1217
		{ "#",    PP_ALTERNATE_FORM2, 1, '\0', },
1218
		{ "#?",   PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 2, '\0', },
1219
		{ "#?#",  PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 3, '\0', },
1220
		{ "#?#?", PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2, 4, '\0', },
1221

1222
		{ NULL,   0,    0, '\0', },
1223
	};
1224

1225
	p = new_percent_esc();
1226

1227
	ATF_REQUIRE_EQ(p != NULL, true);
1228

1229
	for (i = 0; fm_test_vals[i].in != NULL; i++) {
1230
		p->flags = 0;
1231
		f = field_modifier(fm_test_vals[i].in, p);
1232

1233
		ATF_CHECK_EQ_MSG(p->flags, fm_test_vals[i].flags,
1234
				    "(test %d)", i);
1235
		ATF_CHECK_EQ_MSG(f - fm_test_vals[i].in,
1236
				 fm_test_vals[i].fend_offset,
1237
				 "(test %d)", i);
1238
		ATF_CHECK_EQ_MSG(*f, fm_test_vals[i].fend_val,
1239
				 "(test %d)", i);
1240
	}
1241

1242
	free_percent_esc(p);
1243
}
1244

1245
ATF_TC(field_width);
1246
ATF_TC_HEAD(field_width, tc)
1247
{
1248
	atf_tc_set_md_var(tc, "descr",
1249
	    "Testing field_width() format parsing routine");
1250
}
1251
ATF_TC_BODY(field_width, tc)
1252
{
1253
	struct percent_esc	*p;
1254
	const char		*f;
1255
	int		 	i;
1256

1257
	struct fw_test_vals {
1258
		const char *in;
1259
		int width; 
1260
		ptrdiff_t   fend_offset; /* Where f is left pointing */
1261
		char	    fend_val; /* expected first char in fend */
1262
	} fw_test_vals[] = {
1263
		{  "0",  0, 1, '\0', },
1264
		{  "1",  1, 1, '\0', },
1265
		{  "2",  2, 1, '\0', },
1266
		{  "3",  3, 1, '\0', },
1267
		{  "4",  4, 1, '\0', },
1268
		{  "5",  5, 1, '\0', },
1269
		{  "6",  6, 1, '\0', },
1270
		{  "7",  7, 1, '\0', },
1271
		{  "8",  8, 1, '\0', },
1272
		{  "9",  9, 1, '\0', },
1273

1274
		{ "10", 10, 2, '\0', },
1275
		{ "11", 11, 2, '\0', },
1276
		{ "12", 12, 2, '\0', },
1277

1278
		{ "23", 23, 2, '\0', },
1279
		{ "34", 34, 2, '\0', },
1280
		{ "45", 45, 2, '\0', },
1281
		{ "56", 56, 2, '\0', },
1282
		{ "67", 67, 2, '\0', },
1283
		{ "78", 78, 2, '\0', },
1284
		{ "89", 89, 2, '\0', },
1285
		{ "90", 90, 2, '\0', },
1286

1287
		{ "00",  0, 2, '\0', },
1288
		{ "001", 1, 3, '\0', },
1289
		{ "x",   0, 0, 'x',  },
1290
		{ "0x",  0, 1, 'x',  },
1291

1292
		{ NULL,  0, 0, '\0', },
1293
	};
1294

1295
	p = new_percent_esc();
1296

1297
	ATF_REQUIRE_EQ(p != NULL, true);
1298

1299
	for (i = 0; fw_test_vals[i].in != NULL; i++) {
1300
		p->width = 0;
1301
		f = field_width(fw_test_vals[i].in, p);
1302

1303
		ATF_CHECK_EQ_MSG(p->width, fw_test_vals[i].width,
1304
				    "(test %d)", i);
1305
		ATF_CHECK_EQ_MSG(f - fw_test_vals[i].in,
1306
				 fw_test_vals[i].fend_offset,
1307
				 "(test %d)", i);
1308
		ATF_CHECK_EQ_MSG(*f, fw_test_vals[i].fend_val,
1309
				 "(test %d)", i);
1310
	}
1311

1312
	free_percent_esc(p);
1313
}
1314

1315
ATF_TC(format_code);
1316
ATF_TC_HEAD(format_code, tc)
1317
	
1318
{
1319
	atf_tc_set_md_var(tc, "descr",
1320
	    "Testing format_code() format parsing routine");
1321
}
1322
ATF_TC_BODY(format_code, tc)
1323
{
1324
	struct percent_esc	*p;
1325
	const char		*f;
1326
	int		 	i;
1327

1328
	struct fc_test_vals {
1329
		const char *in;
1330
		unsigned context;
1331
		fmt_code_t fmt_code; 
1332
		ptrdiff_t   fend_offset; /* Where f is left pointing */
1333
		char	    fend_val; /* expected first char in fend */
1334
	} fc_test_vals[] = {
1335
		{ "Bn", PP_PKG, PP_PKG_SHLIB_REQUIRED_NAME, 2, '\0', },
1336
		{ "B",  PP_PKG, PP_PKG_SHLIBS_REQUIRED,     1, '\0', },
1337
		{ "Cn", PP_PKG, PP_PKG_CATEGORY_NAME,       2, '\0', },
1338
		{ "C",  PP_PKG, PP_PKG_CATEGORIES,          1, '\0', },
1339
		{ "Dg", PP_PKG, PP_PKG_DIRECTORY_GROUP,     2, '\0', },
1340
		{ "Dn", PP_PKG, PP_PKG_DIRECTORY_PATH,      2, '\0', },
1341
		{ "Dp", PP_PKG, PP_PKG_DIRECTORY_PERMS,     2, '\0', },
1342
		{ "Du", PP_PKG, PP_PKG_DIRECTORY_USER,      2, '\0', },
1343
		{ "D",  PP_PKG, PP_PKG_DIRECTORIES,         1, '\0', },
1344
		{ "Fg", PP_PKG, PP_PKG_FILE_GROUP,          2, '\0', },
1345
		{ "Fn", PP_PKG, PP_PKG_FILE_PATH,           2, '\0', },
1346
		{ "Fp", PP_PKG, PP_PKG_FILE_PERMS,          2, '\0', },
1347
		{ "Fs", PP_PKG, PP_PKG_FILE_SHA256,         2, '\0', },
1348
		{ "Fu", PP_PKG, PP_PKG_FILE_USER,           2, '\0', },
1349
		{ "F",  PP_PKG, PP_PKG_FILES,               1, '\0', },
1350
		{ "Gn", PP_PKG, PP_PKG_GROUP_NAME,          2, '\0', },
1351
		{ "G",  PP_PKG, PP_PKG_GROUPS,              1, '\0', },
1352
		{ "I",  PP_PKG, PP_UNKNOWN,                 0, 'I',  },
1353
		{ "Ln", PP_PKG, PP_PKG_LICENSE_NAME,        2, '\0', },
1354
		{ "L",  PP_PKG, PP_PKG_LICENSES,            1, '\0', },
1355
		{ "M",  PP_PKG, PP_PKG_MESSAGE,             1, '\0', },
1356
		{ "N",  PP_PKG, PP_PKG_REPO_IDENT,          1, '\0', },
1357
		{ "On", PP_PKG, PP_PKG_OPTION_NAME,         2, '\0', },
1358
		{ "Ov", PP_PKG, PP_PKG_OPTION_VALUE,        2, '\0', },
1359
		{ "Od", PP_PKG, PP_PKG_OPTION_DEFAULT,      2, '\0', },
1360
		{ "OD", PP_PKG, PP_PKG_OPTION_DESCRIPTION,  2, '\0', },
1361
		{ "O",  PP_PKG, PP_PKG_OPTIONS,             1, '\0', },
1362
		{ "R",  PP_PKG, PP_PKG_REPO_PATH,           1, '\0', },
1363
		{ "S",  PP_PKG, PP_PKG_CHAR_STRING,         1, '\0', },
1364
		{ "Un", PP_PKG, PP_PKG_USER_NAME,           2, '\0', },
1365
		{ "U",  PP_PKG, PP_PKG_USERS,               1, '\0', },
1366
		{ "V",  PP_PKG, PP_PKG_OLD_VERSION,         1, '\0', },
1367
		{ "a",  PP_PKG, PP_PKG_AUTOREMOVE,          1, '\0', },
1368
		{ "bn", PP_PKG, PP_PKG_SHLIB_PROVIDED_NAME, 2, '\0', },
1369
		{ "b",  PP_PKG, PP_PKG_SHLIBS_PROVIDED,     1, '\0', },
1370
		{ "c",  PP_PKG, PP_PKG_COMMENT,             1, '\0', },
1371
		{ "dk", PP_PKG, PP_PKG_DEPENDENCY_LOCK,     2, '\0', },
1372
		{ "dn", PP_PKG, PP_PKG_DEPENDENCY_NAME,     2, '\0', },
1373
		{ "do", PP_PKG, PP_PKG_DEPENDENCY_ORIGIN,   2, '\0', },
1374
		{ "dv", PP_PKG, PP_PKG_DEPENDENCY_VERSION,  2, '\0', },
1375
		{ "d",  PP_PKG, PP_PKG_DEPENDENCIES,        1, '\0', },
1376
		{ "e",  PP_PKG, PP_PKG_DESCRIPTION,         1, '\0', },
1377
		{ "k",  PP_PKG, PP_PKG_LOCK_STATUS,         1, '\0', },
1378
		{ "l",  PP_PKG, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1379
		{ "m",  PP_PKG, PP_PKG_MAINTAINER,          1, '\0', },
1380
		{ "n",  PP_PKG, PP_PKG_NAME,                1, '\0', },
1381
		{ "o",  PP_PKG, PP_PKG_ORIGIN,              1, '\0', },
1382
		{ "p",  PP_PKG, PP_PKG_PREFIX,              1, '\0', },
1383
		{ "q",  PP_PKG, PP_PKG_ARCHITECTURE,        1, '\0', },
1384
		{ "rk", PP_PKG, PP_PKG_REQUIREMENT_LOCK,    2, '\0', },
1385
		{ "rn", PP_PKG, PP_PKG_REQUIREMENT_NAME,    2, '\0', },
1386
		{ "ro", PP_PKG, PP_PKG_REQUIREMENT_ORIGIN,  2, '\0', },
1387
		{ "rv", PP_PKG, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
1388
		{ "r",  PP_PKG, PP_PKG_REQUIREMENTS,        1, '\0', },
1389
		{ "s",  PP_PKG, PP_PKG_FLATSIZE,            1, '\0', },
1390
		{ "t",  PP_PKG, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1391
		{ "u",  PP_PKG, PP_PKG_CHECKSUM,            1, '\0', },
1392
		{ "v",  PP_PKG, PP_PKG_VERSION,             1, '\0', },
1393
		{ "w",  PP_PKG, PP_PKG_HOME_PAGE,           1, '\0', },
1394
		{ "x",  PP_PKG, PP_PKG_PKGSIZE,             1, '\0', },
1395
		{ "z",  PP_PKG, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1396
		{ "%",  PP_PKG, PP_LITERAL_PERCENT,         1, '\0', },
1397
		{ "Z",  PP_PKG, PP_UNKNOWN,                 0, 'Z',  },
1398

1399
		{ "Bn", PP_B, PP_PKG_SHLIB_REQUIRED_NAME, 2, '\0', },
1400
		{ "B",  PP_B, PP_UNKNOWN,                 0, 'B',  },
1401
		{ "Cn", PP_B, PP_UNKNOWN,                 0, 'C',  },
1402
		{ "C",  PP_B, PP_UNKNOWN,                 0, 'C',  },
1403
		{ "Dg", PP_B, PP_UNKNOWN,                 0, 'D',  },
1404
		{ "Dk", PP_B, PP_UNKNOWN,                 0, 'D',  },
1405
		{ "Dn", PP_B, PP_UNKNOWN,                 0, 'D',  },
1406
		{ "Dp", PP_B, PP_UNKNOWN,                 0, 'D',  },
1407
		{ "Dt", PP_B, PP_UNKNOWN,                 0, 'D',  },
1408
		{ "Du", PP_B, PP_UNKNOWN,                 0, 'D',  },
1409
		{ "D",  PP_B, PP_UNKNOWN,                 0, 'D',  },
1410
		{ "Fg", PP_B, PP_UNKNOWN,                 0, 'F',  },
1411
		{ "Fk", PP_B, PP_UNKNOWN,                 0, 'F',  },
1412
		{ "Fn", PP_B, PP_UNKNOWN,                 0, 'F',  },
1413
		{ "Fp", PP_B, PP_UNKNOWN,                 0, 'F',  },
1414
		{ "Fs", PP_B, PP_UNKNOWN,                 0, 'F',  },
1415
		{ "Fu", PP_B, PP_UNKNOWN,                 0, 'F',  },
1416
		{ "F",  PP_B, PP_UNKNOWN,                 0, 'F',  },
1417
		{ "Gn", PP_B, PP_UNKNOWN,                 0, 'G',  },
1418
		{ "G",  PP_B, PP_UNKNOWN,                 0, 'G',  },
1419
		{ "I",  PP_B, PP_ROW_COUNTER,             1, '\0', },
1420
		{ "Ln", PP_B, PP_UNKNOWN,                 0, 'L',  },
1421
		{ "L",  PP_B, PP_UNKNOWN,                 0, 'L',  },
1422
		{ "M",  PP_B, PP_PKG_MESSAGE,             1, '\0', },
1423
		{ "N",  PP_B, PP_PKG_REPO_IDENT,          1, '\0', },
1424
		{ "On", PP_B, PP_UNKNOWN,                 0, 'O',  },
1425
		{ "Ov", PP_B, PP_UNKNOWN,                 0, 'O',  },
1426
		{ "Od", PP_B, PP_UNKNOWN,                 0, 'O',  },
1427
		{ "OD", PP_B, PP_UNKNOWN,                 0, 'O',  },
1428
		{ "O",  PP_B, PP_UNKNOWN,                 0, 'O',  },
1429
		{ "R",  PP_B, PP_PKG_REPO_PATH,           1, '\0', },
1430
		{ "S",  PP_B, PP_UNKNOWN,                 0, 'S',  },
1431
		{ "Un", PP_B, PP_UNKNOWN,                 0, 'U',  },
1432
		{ "U",  PP_B, PP_UNKNOWN,                 0, 'U',  },
1433
		{ "V",  PP_B, PP_PKG_OLD_VERSION,         1, '\0', },
1434
		{ "a",  PP_B, PP_PKG_AUTOREMOVE,          1, '\0', },
1435
		{ "bn", PP_B, PP_UNKNOWN,                 0, 'b',  },
1436
		{ "b",  PP_B, PP_UNKNOWN,                 0, 'b',  },
1437
		{ "c",  PP_B, PP_PKG_COMMENT,             1, '\0', },
1438
		{ "dk", PP_B, PP_UNKNOWN,                 0, 'd',  },
1439
		{ "dn", PP_B, PP_UNKNOWN,                 0, 'd',  },
1440
		{ "do", PP_B, PP_UNKNOWN,                 0, 'd',  },
1441
		{ "dv", PP_B, PP_UNKNOWN,                 0, 'd',  },
1442
		{ "d",  PP_B, PP_UNKNOWN,                 0, 'd',  },
1443
		{ "e",  PP_B, PP_PKG_DESCRIPTION,         1, '\0', },
1444
		{ "k",  PP_B, PP_PKG_LOCK_STATUS,         1, '\0', },
1445
		{ "l",  PP_B, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1446
		{ "m",  PP_B, PP_PKG_MAINTAINER,          1, '\0', },
1447
		{ "n",  PP_B, PP_PKG_NAME,                1, '\0', },
1448
		{ "o",  PP_B, PP_PKG_ORIGIN,              1, '\0', },
1449
		{ "p",  PP_B, PP_PKG_PREFIX,              1, '\0', },
1450
		{ "q",  PP_B, PP_PKG_ARCHITECTURE,        1, '\0', },
1451
		{ "rk", PP_B, PP_UNKNOWN,                 0, 'r',  },
1452
		{ "rn", PP_B, PP_UNKNOWN,                 0, 'r',  },
1453
		{ "ro", PP_B, PP_UNKNOWN,                 0, 'r',  },
1454
		{ "rv", PP_B, PP_UNKNOWN,                 0, 'r',  },
1455
		{ "r",  PP_B, PP_UNKNOWN,                 0, 'r',  },
1456
		{ "s",  PP_B, PP_PKG_FLATSIZE,            1, '\0', },
1457
		{ "t",  PP_B, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1458
		{ "u",  PP_B, PP_PKG_CHECKSUM,            1, '\0', },
1459
		{ "v",  PP_B, PP_PKG_VERSION,             1, '\0', },
1460
		{ "w",  PP_B, PP_PKG_HOME_PAGE,           1, '\0', },
1461
		{ "x",  PP_B, PP_PKG_PKGSIZE,             1, '\0', },
1462
		{ "z",  PP_B, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1463
		{ "%",  PP_B, PP_LITERAL_PERCENT,         1, '\0', },
1464
		{ "Z",  PP_B, PP_UNKNOWN,                 0, 'Z',  },
1465

1466
		{ "Bn", PP_C, PP_UNKNOWN,                 0, 'B',  },
1467
		{ "B",  PP_C, PP_UNKNOWN,                 0, 'B',  },
1468
		{ "Cn", PP_C, PP_PKG_CATEGORY_NAME,       2, '\0', },
1469
		{ "C",  PP_C, PP_UNKNOWN,                 0, 'C',  },
1470
		{ "Dg", PP_C, PP_UNKNOWN,                 0, 'D',  },
1471
		{ "Dk", PP_C, PP_UNKNOWN,                 0, 'D',  },
1472
		{ "Dn", PP_C, PP_UNKNOWN,                 0, 'D',  },
1473
		{ "Dp", PP_C, PP_UNKNOWN,                 0, 'D',  },
1474
		{ "Dt", PP_C, PP_UNKNOWN,                 0, 'D',  },
1475
		{ "Du", PP_C, PP_UNKNOWN,                 0, 'D',  },
1476
		{ "D",  PP_C, PP_UNKNOWN,                 0, 'D',  },
1477
		{ "Fg", PP_C, PP_UNKNOWN,                 0, 'F',  },
1478
		{ "Fk", PP_C, PP_UNKNOWN,                 0, 'F',  },
1479
		{ "Fn", PP_C, PP_UNKNOWN,                 0, 'F',  },
1480
		{ "Fp", PP_C, PP_UNKNOWN,                 0, 'F',  },
1481
		{ "Fs", PP_C, PP_UNKNOWN,                 0, 'F',  },
1482
		{ "Fu", PP_C, PP_UNKNOWN,                 0, 'F',  },
1483
		{ "F",  PP_C, PP_UNKNOWN,                 0, 'F',  },
1484
		{ "Gn", PP_C, PP_UNKNOWN,                 0, 'G',  },
1485
		{ "G",  PP_C, PP_UNKNOWN,                 0, 'G',  },
1486
		{ "I",  PP_C, PP_ROW_COUNTER,             1, '\0', },
1487
		{ "Ln", PP_C, PP_UNKNOWN,                 0, 'L',  },
1488
		{ "L",  PP_C, PP_UNKNOWN,                 0, 'L',  },
1489
		{ "M",  PP_C, PP_PKG_MESSAGE,             1, '\0', },
1490
		{ "N",  PP_C, PP_PKG_REPO_IDENT,          1, '\0', },
1491
		{ "On", PP_C, PP_UNKNOWN,                 0, 'O',  },
1492
		{ "Ov", PP_C, PP_UNKNOWN,                 0, 'O',  },
1493
		{ "Od", PP_C, PP_UNKNOWN,                 0, 'O',  },
1494
		{ "OD", PP_C, PP_UNKNOWN,                 0, 'O',  },
1495
		{ "O",  PP_C, PP_UNKNOWN,                 0, 'O',  },
1496
		{ "R",  PP_C, PP_PKG_REPO_PATH,           1, '\0', },
1497
		{ "S",  PP_C, PP_UNKNOWN,                 0, 'S',  },
1498
		{ "Un", PP_C, PP_UNKNOWN,                 0, 'U',  },
1499
		{ "U",  PP_C, PP_UNKNOWN,                 0, 'U',  },
1500
		{ "V",  PP_C, PP_PKG_OLD_VERSION,         1, '\0', },
1501
		{ "a",  PP_C, PP_PKG_AUTOREMOVE,          1, '\0', },
1502
		{ "bn", PP_C, PP_UNKNOWN,                 0, 'b',  },
1503
		{ "b",  PP_C, PP_UNKNOWN,                 0, 'b',  },
1504
		{ "c",  PP_C, PP_PKG_COMMENT,             1, '\0', },
1505
		{ "dk", PP_C, PP_UNKNOWN,                 0, 'd',  },
1506
		{ "dn", PP_C, PP_UNKNOWN,                 0, 'd',  },
1507
		{ "do", PP_C, PP_UNKNOWN,                 0, 'd',  },
1508
		{ "dv", PP_C, PP_UNKNOWN,                 0, 'd',  },
1509
		{ "d",  PP_C, PP_UNKNOWN,                 0, 'd',  },
1510
		{ "e",  PP_C, PP_PKG_DESCRIPTION,         1, '\0', },
1511
		{ "k",  PP_C, PP_PKG_LOCK_STATUS,         1, '\0', },
1512
		{ "l",  PP_C, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1513
		{ "m",  PP_C, PP_PKG_MAINTAINER,          1, '\0', },
1514
		{ "n",  PP_C, PP_PKG_NAME,                1, '\0', },
1515
		{ "o",  PP_C, PP_PKG_ORIGIN,              1, '\0', },
1516
		{ "p",  PP_C, PP_PKG_PREFIX,              1, '\0', },
1517
		{ "q",  PP_C, PP_PKG_ARCHITECTURE,        1, '\0', },
1518
		{ "rk", PP_C, PP_UNKNOWN,                 0, 'r',  },
1519
		{ "rn", PP_C, PP_UNKNOWN,                 0, 'r',  },
1520
		{ "ro", PP_C, PP_UNKNOWN,                 0, 'r',  },
1521
		{ "rv", PP_C, PP_UNKNOWN,                 0, 'r',  },
1522
		{ "r",  PP_C, PP_UNKNOWN,                 0, 'r',  },
1523
		{ "s",  PP_C, PP_PKG_FLATSIZE,            1, '\0', },
1524
		{ "t",  PP_C, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1525
		{ "u",  PP_C, PP_PKG_CHECKSUM,            1, '\0', },
1526
		{ "v",  PP_C, PP_PKG_VERSION,             1, '\0', },
1527
		{ "w",  PP_C, PP_PKG_HOME_PAGE,           1, '\0', },
1528
		{ "x",  PP_C, PP_PKG_PKGSIZE,             1, '\0', },
1529
		{ "z",  PP_C, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1530
		{ "%",  PP_C, PP_LITERAL_PERCENT,         1, '\0', },
1531
		{ "Z",  PP_C, PP_UNKNOWN,                 0, 'Z',  },
1532

1533
		{ "Bn", PP_D, PP_UNKNOWN,                 0, 'B',  },
1534
		{ "B",  PP_D, PP_UNKNOWN,                 0, 'B',  },
1535
		{ "Cn", PP_D, PP_UNKNOWN,                 0, 'C',  },
1536
		{ "C",  PP_D, PP_UNKNOWN,                 0, 'C',  },
1537
		{ "Dg", PP_D, PP_PKG_DIRECTORY_GROUP,     2, '\0', },
1538
		{ "Dn", PP_D, PP_PKG_DIRECTORY_PATH,      2, '\0', },
1539
		{ "Dp", PP_D, PP_PKG_DIRECTORY_PERMS,     2, '\0', },
1540
		{ "Du", PP_D, PP_PKG_DIRECTORY_USER,      2, '\0', },
1541
		{ "D",  PP_D, PP_UNKNOWN,                 0, 'D',  },
1542
		{ "Fg", PP_D, PP_UNKNOWN,                 0, 'F',  },
1543
		{ "Fk", PP_D, PP_UNKNOWN,                 0, 'F',  },
1544
		{ "Fn", PP_D, PP_UNKNOWN,                 0, 'F',  },
1545
		{ "Fp", PP_D, PP_UNKNOWN,                 0, 'F',  },
1546
		{ "Fs", PP_D, PP_UNKNOWN,                 0, 'F',  },
1547
		{ "Fu", PP_D, PP_UNKNOWN,                 0, 'F',  },
1548
		{ "F",  PP_D, PP_UNKNOWN,                 0, 'F',  },
1549
		{ "Gn", PP_D, PP_UNKNOWN,                 0, 'G',  },
1550
		{ "G",  PP_D, PP_UNKNOWN,                 0, 'G',  },
1551
		{ "I",  PP_D, PP_ROW_COUNTER,             1, '\0', },
1552
		{ "Ln", PP_D, PP_UNKNOWN,                 0, 'L',  },
1553
		{ "L",  PP_D, PP_UNKNOWN,                 0, 'L',  },
1554
		{ "M",  PP_D, PP_PKG_MESSAGE,             1, '\0', },
1555
		{ "N",  PP_D, PP_PKG_REPO_IDENT,          1, '\0', },
1556
		{ "On", PP_D, PP_UNKNOWN,                 0, 'O',  },
1557
		{ "Ov", PP_D, PP_UNKNOWN,                 0, 'O',  },
1558
		{ "Od", PP_D, PP_UNKNOWN,                 0, 'O',  },
1559
		{ "OD", PP_D, PP_UNKNOWN,                 0, 'O',  },
1560
		{ "O",  PP_D, PP_UNKNOWN,                 0, 'O',  },
1561
		{ "R",  PP_D, PP_PKG_REPO_PATH,           1, '\0', },
1562
		{ "S",  PP_D, PP_UNKNOWN,                 0, 'S',  },
1563
		{ "Un", PP_D, PP_UNKNOWN,                 0, 'U',  },
1564
		{ "U",  PP_D, PP_UNKNOWN,                 0, 'U',  },
1565
		{ "V",  PP_D, PP_PKG_OLD_VERSION,         1, '\0', },
1566
		{ "a",  PP_D, PP_PKG_AUTOREMOVE,          1, '\0', },
1567
		{ "bn", PP_D, PP_UNKNOWN,                 0, 'b',  },
1568
		{ "b",  PP_D, PP_UNKNOWN,                 0, 'b',  },
1569
		{ "c",  PP_D, PP_PKG_COMMENT,             1, '\0', },
1570
		{ "dk", PP_D, PP_UNKNOWN,                 0, 'd',  },
1571
		{ "dn", PP_D, PP_UNKNOWN,                 0, 'd',  },
1572
		{ "do", PP_D, PP_UNKNOWN,                 0, 'd',  },
1573
		{ "dv", PP_D, PP_UNKNOWN,                 0, 'd',  },
1574
		{ "d",  PP_D, PP_UNKNOWN,                 0, 'd',  },
1575
		{ "e",  PP_D, PP_PKG_DESCRIPTION,         1, '\0', },
1576
		{ "k",  PP_D, PP_PKG_LOCK_STATUS,         1, '\0', },
1577
		{ "l",  PP_D, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1578
		{ "m",  PP_D, PP_PKG_MAINTAINER,          1, '\0', },
1579
		{ "n",  PP_D, PP_PKG_NAME,                1, '\0', },
1580
		{ "o",  PP_D, PP_PKG_ORIGIN,              1, '\0', },
1581
		{ "p",  PP_D, PP_PKG_PREFIX,              1, '\0', },
1582
		{ "q",  PP_D, PP_PKG_ARCHITECTURE,        1, '\0', },
1583
		{ "rk", PP_D, PP_UNKNOWN,                 0, 'r',  },
1584
		{ "rn", PP_D, PP_UNKNOWN,                 0, 'r',  },
1585
		{ "ro", PP_D, PP_UNKNOWN,                 0, 'r',  },
1586
		{ "rv", PP_D, PP_UNKNOWN,                 0, 'r',  },
1587
		{ "r",  PP_D, PP_UNKNOWN,                 0, 'r',  },
1588
		{ "s",  PP_D, PP_PKG_FLATSIZE,            1, '\0', },
1589
		{ "t",  PP_D, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1590
		{ "u",  PP_D, PP_PKG_CHECKSUM,            1, '\0', },
1591
		{ "v",  PP_D, PP_PKG_VERSION,             1, '\0', },
1592
		{ "w",  PP_D, PP_PKG_HOME_PAGE,           1, '\0', },
1593
		{ "x",  PP_D, PP_PKG_PKGSIZE,             1, '\0', },
1594
		{ "z",  PP_D, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1595
		{ "%",  PP_D, PP_LITERAL_PERCENT,         1, '\0', },
1596
		{ "Z",  PP_D, PP_UNKNOWN,                 0, 'Z',  },
1597

1598
		{ "Bn", PP_F, PP_UNKNOWN,                 0, 'B',  },
1599
		{ "B",  PP_F, PP_UNKNOWN,                 0, 'B',  },
1600
		{ "Cn", PP_F, PP_UNKNOWN,                 0, 'C',  },
1601
		{ "C",  PP_F, PP_UNKNOWN,                 0, 'C',  },
1602
		{ "Dg", PP_F, PP_UNKNOWN,                 0, 'D',  },
1603
		{ "Dk", PP_F, PP_UNKNOWN,                 0, 'D',  },
1604
		{ "Dn", PP_F, PP_UNKNOWN,                 0, 'D',  },
1605
		{ "Dp", PP_F, PP_UNKNOWN,                 0, 'D',  },
1606
		{ "Dt", PP_F, PP_UNKNOWN,                 0, 'D',  },
1607
		{ "Du", PP_F, PP_UNKNOWN,                 0, 'D',  },
1608
		{ "D",  PP_F, PP_UNKNOWN,                 0, 'D',  },
1609
		{ "Fg", PP_F, PP_PKG_FILE_GROUP,          2, '\0', },
1610
		{ "Fn", PP_F, PP_PKG_FILE_PATH,           2, '\0', },
1611
		{ "Fp", PP_F, PP_PKG_FILE_PERMS,          2, '\0', },
1612
		{ "Fs", PP_F, PP_PKG_FILE_SHA256,         2, '\0', },
1613
		{ "Fu", PP_F, PP_PKG_FILE_USER,           2, '\0', },
1614
		{ "F",  PP_F, PP_UNKNOWN,                 0, 'F',  },
1615
		{ "Gn", PP_F, PP_UNKNOWN,                 0, 'G',  },
1616
		{ "G",  PP_F, PP_UNKNOWN,                 0, 'G',  },
1617
		{ "I",  PP_F, PP_ROW_COUNTER,             1, '\0', },
1618
		{ "Ln", PP_F, PP_UNKNOWN,                 0, 'L',  },
1619
		{ "L",  PP_F, PP_UNKNOWN,                 0, 'L',  },
1620
		{ "M",  PP_F, PP_PKG_MESSAGE,             1, '\0', },
1621
		{ "N",  PP_F, PP_PKG_REPO_IDENT,          1, '\0', },
1622
		{ "On", PP_F, PP_UNKNOWN,                 0, 'O',  },
1623
		{ "Ov", PP_F, PP_UNKNOWN,                 0, 'O',  },
1624
		{ "Od", PP_F, PP_UNKNOWN,                 0, 'O',  },
1625
		{ "OD", PP_F, PP_UNKNOWN,                 0, 'O',  },
1626
		{ "O",  PP_F, PP_UNKNOWN,                 0, 'O',  },
1627
		{ "R",  PP_F, PP_PKG_REPO_PATH,           1, '\0', },
1628
		{ "S",  PP_F, PP_UNKNOWN,                 0, 'S',  },
1629
		{ "Un", PP_F, PP_UNKNOWN,                 0, 'U',  },
1630
		{ "U",  PP_F, PP_UNKNOWN,                 0, 'U',  },
1631
		{ "V",  PP_F, PP_PKG_OLD_VERSION,         1, '\0', },
1632
		{ "a",  PP_F, PP_PKG_AUTOREMOVE,          1, '\0', },
1633
		{ "bn", PP_F, PP_UNKNOWN,                 0, 'b',  },
1634
		{ "b",  PP_F, PP_UNKNOWN,                 0, 'b',  },
1635
		{ "c",  PP_F, PP_PKG_COMMENT,             1, '\0', },
1636
		{ "dk", PP_F, PP_UNKNOWN,                 0, 'd',  },
1637
		{ "dn", PP_F, PP_UNKNOWN,                 0, 'd',  },
1638
		{ "do", PP_F, PP_UNKNOWN,                 0, 'd',  },
1639
		{ "dv", PP_F, PP_UNKNOWN,                 0, 'd',  },
1640
		{ "d",  PP_F, PP_UNKNOWN,                 0, 'd',  },
1641
		{ "e",  PP_F, PP_PKG_DESCRIPTION,         1, '\0', },
1642
		{ "k",  PP_F, PP_PKG_LOCK_STATUS,         1, '\0', },
1643
		{ "l",  PP_F, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1644
		{ "m",  PP_F, PP_PKG_MAINTAINER,          1, '\0', },
1645
		{ "n",  PP_F, PP_PKG_NAME,                1, '\0', },
1646
		{ "o",  PP_F, PP_PKG_ORIGIN,              1, '\0', },
1647
		{ "p",  PP_F, PP_PKG_PREFIX,              1, '\0', },
1648
		{ "q",  PP_F, PP_PKG_ARCHITECTURE,        1, '\0', },
1649
		{ "rk", PP_F, PP_UNKNOWN,                 0, 'r',  },
1650
		{ "rn", PP_F, PP_UNKNOWN,                 0, 'r',  },
1651
		{ "ro", PP_F, PP_UNKNOWN,                 0, 'r',  },
1652
		{ "rv", PP_F, PP_UNKNOWN,                 0, 'r',  },
1653
		{ "r",  PP_F, PP_UNKNOWN,                 0, 'r',  },
1654
		{ "s",  PP_F, PP_PKG_FLATSIZE,            1, '\0', },
1655
		{ "t",  PP_F, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1656
		{ "u",  PP_F, PP_PKG_CHECKSUM,            1, '\0', },
1657
		{ "v",  PP_F, PP_PKG_VERSION,             1, '\0', },
1658
		{ "w",  PP_F, PP_PKG_HOME_PAGE,           1, '\0', },
1659
		{ "x",  PP_F, PP_PKG_PKGSIZE,             1, '\0', },
1660
		{ "z",  PP_F, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1661
		{ "%",  PP_F, PP_LITERAL_PERCENT,         1, '\0', },
1662
		{ "Z",  PP_F, PP_UNKNOWN,                 0, 'Z',  },
1663

1664
		{ "Bn", PP_G, PP_UNKNOWN,                 0, 'B',  },
1665
		{ "B",  PP_G, PP_UNKNOWN,                 0, 'B',  },
1666
		{ "Cn", PP_G, PP_UNKNOWN,                 0, 'C',  },
1667
		{ "C",  PP_G, PP_UNKNOWN,                 0, 'C',  },
1668
		{ "Dg", PP_G, PP_UNKNOWN,                 0, 'D',  },
1669
		{ "Dk", PP_G, PP_UNKNOWN,                 0, 'D',  },
1670
		{ "Dn", PP_G, PP_UNKNOWN,                 0, 'D',  },
1671
		{ "Dp", PP_G, PP_UNKNOWN,                 0, 'D',  },
1672
		{ "Dt", PP_G, PP_UNKNOWN,                 0, 'D',  },
1673
		{ "Du", PP_G, PP_UNKNOWN,                 0, 'D',  },
1674
		{ "D",  PP_G, PP_UNKNOWN,                 0, 'D',  },
1675
		{ "Fg", PP_G, PP_UNKNOWN,                 0, 'F',  },
1676
		{ "Fk", PP_G, PP_UNKNOWN,                 0, 'F',  },
1677
		{ "Fn", PP_G, PP_UNKNOWN,                 0, 'F',  },
1678
		{ "Fp", PP_G, PP_UNKNOWN,                 0, 'F',  },
1679
		{ "Fs", PP_G, PP_UNKNOWN,                 0, 'F',  },
1680
		{ "Fu", PP_G, PP_UNKNOWN,                 0, 'F',  },
1681
		{ "F",  PP_G, PP_UNKNOWN,                 0, 'F',  },
1682
		{ "Gn", PP_G, PP_PKG_GROUP_NAME,          2, '\0', },
1683
		{ "G",  PP_G, PP_UNKNOWN,                 0, 'G',  },
1684
		{ "I",  PP_G, PP_ROW_COUNTER,             1, '\0', },
1685
		{ "Ln", PP_G, PP_UNKNOWN,                 0, 'L',  },
1686
		{ "L",  PP_G, PP_UNKNOWN,                 0, 'L',  },
1687
		{ "M",  PP_G, PP_PKG_MESSAGE,             1, '\0', },
1688
		{ "N",  PP_G, PP_PKG_REPO_IDENT,          1, '\0', },
1689
		{ "On", PP_G, PP_UNKNOWN,                 0, 'O',  },
1690
		{ "Ov", PP_G, PP_UNKNOWN,                 0, 'O',  },
1691
		{ "Od", PP_G, PP_UNKNOWN,                 0, 'O',  },
1692
		{ "OD", PP_G, PP_UNKNOWN,                 0, 'O',  },
1693
		{ "O",  PP_G, PP_UNKNOWN,                 0, 'O',  },
1694
		{ "R",  PP_G, PP_PKG_REPO_PATH,           1, '\0', },
1695
		{ "S",  PP_G, PP_UNKNOWN,                 0, 'S',  },
1696
		{ "Un", PP_G, PP_UNKNOWN,                 0, 'U',  },
1697
		{ "U",  PP_G, PP_UNKNOWN,                 0, 'U',  },
1698
		{ "V",  PP_G, PP_PKG_OLD_VERSION,         1, '\0', },
1699
		{ "a",  PP_G, PP_PKG_AUTOREMOVE,          1, '\0', },
1700
		{ "bn", PP_G, PP_UNKNOWN,                 0, 'b',  },
1701
		{ "b",  PP_G, PP_UNKNOWN,                 0, 'b',  },
1702
		{ "c",  PP_G, PP_PKG_COMMENT,             1, '\0', },
1703
		{ "dk", PP_G, PP_UNKNOWN,                 0, 'd',  },
1704
		{ "dn", PP_G, PP_UNKNOWN,                 0, 'd',  },
1705
		{ "do", PP_G, PP_UNKNOWN,                 0, 'd',  },
1706
		{ "dv", PP_G, PP_UNKNOWN,                 0, 'd',  },
1707
		{ "d",  PP_G, PP_UNKNOWN,                 0, 'd',  },
1708
		{ "e",  PP_G, PP_PKG_DESCRIPTION,         1, '\0', },
1709
		{ "k",  PP_G, PP_PKG_LOCK_STATUS,         1, '\0', },
1710
		{ "l",  PP_G, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1711
		{ "m",  PP_G, PP_PKG_MAINTAINER,          1, '\0', },
1712
		{ "n",  PP_G, PP_PKG_NAME,                1, '\0', },
1713
		{ "o",  PP_G, PP_PKG_ORIGIN,              1, '\0', },
1714
		{ "p",  PP_G, PP_PKG_PREFIX,              1, '\0', },
1715
		{ "q",  PP_G, PP_PKG_ARCHITECTURE,        1, '\0', },
1716
		{ "rk", PP_G, PP_UNKNOWN,                 0, 'r',  },
1717
		{ "rn", PP_G, PP_UNKNOWN,                 0, 'r',  },
1718
		{ "ro", PP_G, PP_UNKNOWN,                 0, 'r',  },
1719
		{ "rv", PP_G, PP_UNKNOWN,                 0, 'r',  },
1720
		{ "r",  PP_G, PP_UNKNOWN,                 0, 'r',  },
1721
		{ "s",  PP_G, PP_PKG_FLATSIZE,            1, '\0', },
1722
		{ "t",  PP_G, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1723
		{ "u",  PP_G, PP_PKG_CHECKSUM,            1, '\0', },
1724
		{ "v",  PP_G, PP_PKG_VERSION,             1, '\0', },
1725
		{ "w",  PP_G, PP_PKG_HOME_PAGE,           1, '\0', },
1726
		{ "x",  PP_G, PP_PKG_PKGSIZE,             1, '\0', },
1727
		{ "z",  PP_G, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1728
		{ "%",  PP_G, PP_LITERAL_PERCENT,         1, '\0', },
1729
		{ "Z",  PP_G, PP_UNKNOWN,                 0, 'Z',  },
1730

1731
		{ "Bn", PP_L, PP_UNKNOWN,                 0, 'B',  },
1732
		{ "B",  PP_L, PP_UNKNOWN,                 0, 'B',  },
1733
		{ "Cn", PP_L, PP_UNKNOWN,                 0, 'C',  },
1734
		{ "C",  PP_L, PP_UNKNOWN,                 0, 'C',  },
1735
		{ "Dg", PP_L, PP_UNKNOWN,                 0, 'D',  },
1736
		{ "Dk", PP_L, PP_UNKNOWN,                 0, 'D',  },
1737
		{ "Dn", PP_L, PP_UNKNOWN,                 0, 'D',  },
1738
		{ "Dp", PP_L, PP_UNKNOWN,                 0, 'D',  },
1739
		{ "Dt", PP_L, PP_UNKNOWN,                 0, 'D',  },
1740
		{ "Du", PP_L, PP_UNKNOWN,                 0, 'D',  },
1741
		{ "D",  PP_L, PP_UNKNOWN,                 0, 'D',  },
1742
		{ "Fg", PP_L, PP_UNKNOWN,                 0, 'F',  },
1743
		{ "Fk", PP_L, PP_UNKNOWN,                 0, 'F',  },
1744
		{ "Fn", PP_L, PP_UNKNOWN,                 0, 'F',  },
1745
		{ "Fp", PP_L, PP_UNKNOWN,                 0, 'F',  },
1746
		{ "Fs", PP_L, PP_UNKNOWN,                 0, 'F',  },
1747
		{ "Fu", PP_L, PP_UNKNOWN,                 0, 'F',  },
1748
		{ "F",  PP_L, PP_UNKNOWN,                 0, 'F',  },
1749
		{ "Gn", PP_L, PP_UNKNOWN,                 0, 'G',  },
1750
		{ "G",  PP_L, PP_UNKNOWN,                 0, 'G',  },
1751
		{ "I",  PP_L, PP_ROW_COUNTER,             1, '\0', },
1752
		{ "Ln", PP_L, PP_PKG_LICENSE_NAME,        2, '\0', },
1753
		{ "L",  PP_L, PP_UNKNOWN,                 0, 'L',  },
1754
		{ "M",  PP_L, PP_PKG_MESSAGE,             1, '\0', },
1755
		{ "N",  PP_L, PP_PKG_REPO_IDENT,          1, '\0', },
1756
		{ "On", PP_L, PP_UNKNOWN,                 0, 'O',  },
1757
		{ "Ov", PP_L, PP_UNKNOWN,                 0, 'O',  },
1758
		{ "Od", PP_L, PP_UNKNOWN,                 0, 'O',  },
1759
		{ "OD", PP_L, PP_UNKNOWN,                 0, 'O',  },
1760
		{ "O",  PP_L, PP_UNKNOWN,                 0, 'O',  },
1761
		{ "R",  PP_L, PP_PKG_REPO_PATH,           1, '\0', },
1762
		{ "S",  PP_L, PP_UNKNOWN,                 0, 'S',  },
1763
		{ "Un", PP_L, PP_UNKNOWN,                 0, 'U',  },
1764
		{ "U",  PP_L, PP_UNKNOWN,                 0, 'U',  },
1765
		{ "V",  PP_L, PP_PKG_OLD_VERSION,         1, '\0', },
1766
		{ "a",  PP_L, PP_PKG_AUTOREMOVE,          1, '\0', },
1767
		{ "bn", PP_L, PP_UNKNOWN,                 0, 'b',  },
1768
		{ "b",  PP_L, PP_UNKNOWN,                 0, 'b',  },
1769
		{ "c",  PP_L, PP_PKG_COMMENT,             1, '\0', },
1770
		{ "dk", PP_L, PP_UNKNOWN,                 0, 'd',  },
1771
		{ "dn", PP_L, PP_UNKNOWN,                 0, 'd',  },
1772
		{ "do", PP_L, PP_UNKNOWN,                 0, 'd',  },
1773
		{ "dv", PP_L, PP_UNKNOWN,                 0, 'd',  },
1774
		{ "d",  PP_L, PP_UNKNOWN,                 0, 'd',  },
1775
		{ "e",  PP_L, PP_PKG_DESCRIPTION,         1, '\0', },
1776
		{ "k",  PP_L, PP_PKG_LOCK_STATUS,         1, '\0', },
1777
		{ "l",  PP_L, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1778
		{ "m",  PP_L, PP_PKG_MAINTAINER,          1, '\0', },
1779
		{ "n",  PP_L, PP_PKG_NAME,                1, '\0', },
1780
		{ "o",  PP_L, PP_PKG_ORIGIN,              1, '\0', },
1781
		{ "p",  PP_L, PP_PKG_PREFIX,              1, '\0', },
1782
		{ "q",  PP_L, PP_PKG_ARCHITECTURE,        1, '\0', },
1783
		{ "rk", PP_L, PP_UNKNOWN,                 0, 'r',  },
1784
		{ "rn", PP_L, PP_UNKNOWN,                 0, 'r',  },
1785
		{ "ro", PP_L, PP_UNKNOWN,                 0, 'r',  },
1786
		{ "rv", PP_L, PP_UNKNOWN,                 0, 'r',  },
1787
		{ "r",  PP_L, PP_UNKNOWN,                 0, 'r',  },
1788
		{ "s",  PP_L, PP_PKG_FLATSIZE,            1, '\0', },
1789
		{ "t",  PP_L, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1790
		{ "u",  PP_L, PP_PKG_CHECKSUM,            1, '\0', },
1791
		{ "v",  PP_L, PP_PKG_VERSION,             1, '\0', },
1792
		{ "w",  PP_L, PP_PKG_HOME_PAGE,           1, '\0', },
1793
		{ "x",  PP_L, PP_PKG_PKGSIZE,             1, '\0', },
1794
		{ "z",  PP_L, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1795
		{ "%",  PP_L, PP_LITERAL_PERCENT,         1, '\0', },
1796
		{ "Z",  PP_L, PP_UNKNOWN,                 0, 'Z',  },
1797

1798
		{ "Bn", PP_O, PP_UNKNOWN,                 0, 'B',  },
1799
		{ "B",  PP_O, PP_UNKNOWN,                 0, 'B',  },
1800
		{ "Cn", PP_O, PP_UNKNOWN,                 0, 'C',  },
1801
		{ "C",  PP_O, PP_UNKNOWN,                 0, 'C',  },
1802
		{ "Dg", PP_O, PP_UNKNOWN,                 0, 'D',  },
1803
		{ "Dk", PP_O, PP_UNKNOWN,                 0, 'D',  },
1804
		{ "Dn", PP_O, PP_UNKNOWN,                 0, 'D',  },
1805
		{ "Dp", PP_O, PP_UNKNOWN,                 0, 'D',  },
1806
		{ "Dt", PP_O, PP_UNKNOWN,                 0, 'D',  },
1807
		{ "Du", PP_O, PP_UNKNOWN,                 0, 'D',  },
1808
		{ "D",  PP_O, PP_UNKNOWN,                 0, 'D',  },
1809
		{ "Fg", PP_O, PP_UNKNOWN,                 0, 'F',  },
1810
		{ "Fk", PP_O, PP_UNKNOWN,                 0, 'F',  },
1811
		{ "Fn", PP_O, PP_UNKNOWN,                 0, 'F',  },
1812
		{ "Fp", PP_O, PP_UNKNOWN,                 0, 'F',  },
1813
		{ "Fs", PP_O, PP_UNKNOWN,                 0, 'F',  },
1814
		{ "Fu", PP_O, PP_UNKNOWN,                 0, 'F',  },
1815
		{ "F",  PP_O, PP_UNKNOWN,                 0, 'F',  },
1816
		{ "Gn", PP_O, PP_UNKNOWN,                 0, 'G',  },
1817
		{ "G",  PP_O, PP_UNKNOWN,                 0, 'G',  },
1818
		{ "I",  PP_O, PP_ROW_COUNTER,             1, '\0', },
1819
		{ "Ln", PP_O, PP_UNKNOWN,                 0, 'L',  },
1820
		{ "L",  PP_O, PP_UNKNOWN,                 0, 'L',  },
1821
		{ "M",  PP_O, PP_PKG_MESSAGE,             1, '\0', },
1822
		{ "N",  PP_O, PP_PKG_REPO_IDENT,          1, '\0', },
1823
		{ "On", PP_O, PP_PKG_OPTION_NAME,         2, '\0', },
1824
		{ "Ov", PP_O, PP_PKG_OPTION_VALUE,        2, '\0', },
1825
		{ "Od", PP_O, PP_PKG_OPTION_DEFAULT,      2, '\0', },
1826
		{ "OD", PP_O, PP_PKG_OPTION_DESCRIPTION,  2, '\0', },
1827
		{ "O",  PP_O, PP_UNKNOWN,                 0, 'O',  },
1828
		{ "R",  PP_O, PP_PKG_REPO_PATH,           1, '\0', },
1829
		{ "S",  PP_O, PP_UNKNOWN,                 0, 'S',  },
1830
		{ "Un", PP_O, PP_UNKNOWN,                 0, 'U',  },
1831
		{ "U",  PP_O, PP_UNKNOWN,                 0, 'U',  },
1832
		{ "V",  PP_O, PP_PKG_OLD_VERSION,         1, '\0', },
1833
		{ "a",  PP_O, PP_PKG_AUTOREMOVE,          1, '\0', },
1834
		{ "bn", PP_O, PP_UNKNOWN,                 0, 'b',  },
1835
		{ "b",  PP_O, PP_UNKNOWN,                 0, 'b',  },
1836
		{ "c",  PP_O, PP_PKG_COMMENT,             1, '\0', },
1837
		{ "dk", PP_O, PP_UNKNOWN,                 0, 'd',  },
1838
		{ "dn", PP_O, PP_UNKNOWN,                 0, 'd',  },
1839
		{ "do", PP_O, PP_UNKNOWN,                 0, 'd',  },
1840
		{ "dv", PP_O, PP_UNKNOWN,                 0, 'd',  },
1841
		{ "d",  PP_O, PP_UNKNOWN,                 0, 'd',  },
1842
		{ "e",  PP_O, PP_PKG_DESCRIPTION,         1, '\0', },
1843
		{ "k",  PP_O, PP_PKG_LOCK_STATUS,         1, '\0', },
1844
		{ "l",  PP_O, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1845
		{ "m",  PP_O, PP_PKG_MAINTAINER,          1, '\0', },
1846
		{ "n",  PP_O, PP_PKG_NAME,                1, '\0', },
1847
		{ "o",  PP_O, PP_PKG_ORIGIN,              1, '\0', },
1848
		{ "p",  PP_O, PP_PKG_PREFIX,              1, '\0', },
1849
		{ "q",  PP_O, PP_PKG_ARCHITECTURE,        1, '\0', },
1850
		{ "rk", PP_O, PP_UNKNOWN,                 0, 'r',  },
1851
		{ "rn", PP_O, PP_UNKNOWN,                 0, 'r',  },
1852
		{ "ro", PP_O, PP_UNKNOWN,                 0, 'r',  },
1853
		{ "rv", PP_O, PP_UNKNOWN,                 0, 'r',  },
1854
		{ "r",  PP_O, PP_UNKNOWN,                 0, 'r',  },
1855
		{ "s",  PP_O, PP_PKG_FLATSIZE,            1, '\0', },
1856
		{ "t",  PP_O, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1857
		{ "u",  PP_O, PP_PKG_CHECKSUM,            1, '\0', },
1858
		{ "v",  PP_O, PP_PKG_VERSION,             1, '\0', },
1859
		{ "w",  PP_O, PP_PKG_HOME_PAGE,           1, '\0', },
1860
		{ "x",  PP_O, PP_PKG_PKGSIZE,             1, '\0', },
1861
		{ "z",  PP_O, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1862
		{ "%",  PP_O, PP_LITERAL_PERCENT,         1, '\0', },
1863
		{ "Z",  PP_O, PP_UNKNOWN,                 0, 'Z',  },
1864

1865
		{ "Bn", PP_U, PP_UNKNOWN,                 0, 'B',  },
1866
		{ "B",  PP_U, PP_UNKNOWN,                 0, 'B',  },
1867
		{ "Cn", PP_U, PP_UNKNOWN,                 0, 'C',  },
1868
		{ "C",  PP_U, PP_UNKNOWN,                 0, 'C',  },
1869
		{ "Dg", PP_U, PP_UNKNOWN,                 0, 'D',  },
1870
		{ "Dk", PP_U, PP_UNKNOWN,                 0, 'D',  },
1871
		{ "Dn", PP_U, PP_UNKNOWN,                 0, 'D',  },
1872
		{ "Dp", PP_U, PP_UNKNOWN,                 0, 'D',  },
1873
		{ "Dt", PP_U, PP_UNKNOWN,                 0, 'D',  },
1874
		{ "Du", PP_U, PP_UNKNOWN,                 0, 'D',  },
1875
		{ "D",  PP_U, PP_UNKNOWN,                 0, 'D',  },
1876
		{ "Fg", PP_U, PP_UNKNOWN,                 0, 'F',  },
1877
		{ "Fk", PP_U, PP_UNKNOWN,                 0, 'F',  },
1878
		{ "Fn", PP_U, PP_UNKNOWN,                 0, 'F',  },
1879
		{ "Fp", PP_U, PP_UNKNOWN,                 0, 'F',  },
1880
		{ "Fs", PP_U, PP_UNKNOWN,                 0, 'F',  },
1881
		{ "Fu", PP_U, PP_UNKNOWN,                 0, 'F',  },
1882
		{ "F",  PP_U, PP_UNKNOWN,                 0, 'F',  },
1883
		{ "Gn", PP_U, PP_UNKNOWN,                 0, 'G',  },
1884
		{ "G",  PP_U, PP_UNKNOWN,                 0, 'G',  },
1885
		{ "I",  PP_U, PP_ROW_COUNTER,             1, '\0', },
1886
		{ "Ln", PP_U, PP_UNKNOWN,                 0, 'L',  },
1887
		{ "L",  PP_U, PP_UNKNOWN,                 0, 'L',  },
1888
		{ "M",  PP_U, PP_PKG_MESSAGE,             1, '\0', },
1889
		{ "N",  PP_U, PP_PKG_REPO_IDENT,          1, '\0', },
1890
		{ "On", PP_U, PP_UNKNOWN,                 0, 'O',  },
1891
		{ "Ov", PP_U, PP_UNKNOWN,                 0, 'O',  },
1892
		{ "Od", PP_U, PP_UNKNOWN,                 0, 'O',  },
1893
		{ "OD", PP_U, PP_UNKNOWN,                 0, 'O',  },
1894
		{ "O",  PP_U, PP_UNKNOWN,                 0, 'O',  },
1895
		{ "R",  PP_U, PP_PKG_REPO_PATH,           1, '\0', },
1896
		{ "S",  PP_U, PP_UNKNOWN,                 0, 'S',  },
1897
		{ "Un", PP_U, PP_PKG_USER_NAME,           2, '\0', },
1898
		{ "U",  PP_U, PP_UNKNOWN,                 0, 'U',  },
1899
		{ "V",  PP_U, PP_PKG_OLD_VERSION,         1, '\0', },
1900
		{ "a",  PP_U, PP_PKG_AUTOREMOVE,          1, '\0', },
1901
		{ "bn", PP_U, PP_UNKNOWN,                 0, 'b',  },
1902
		{ "b",  PP_U, PP_UNKNOWN,                 0, 'b',  },
1903
		{ "c",  PP_U, PP_PKG_COMMENT,             1, '\0', },
1904
		{ "dk", PP_U, PP_UNKNOWN,                 0, 'd',  },
1905
		{ "dn", PP_U, PP_UNKNOWN,                 0, 'd',  },
1906
		{ "do", PP_U, PP_UNKNOWN,                 0, 'd',  },
1907
		{ "dv", PP_U, PP_UNKNOWN,                 0, 'd',  },
1908
		{ "d",  PP_U, PP_UNKNOWN,                 0, 'd',  },
1909
		{ "e",  PP_U, PP_PKG_DESCRIPTION,         1, '\0', },
1910
		{ "k",  PP_U, PP_PKG_LOCK_STATUS,         1, '\0', },
1911
		{ "l",  PP_U, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1912
		{ "m",  PP_U, PP_PKG_MAINTAINER,          1, '\0', },
1913
		{ "n",  PP_U, PP_PKG_NAME,                1, '\0', },
1914
		{ "o",  PP_U, PP_PKG_ORIGIN,              1, '\0', },
1915
		{ "p",  PP_U, PP_PKG_PREFIX,              1, '\0', },
1916
		{ "q",  PP_U, PP_PKG_ARCHITECTURE,        1, '\0', },
1917
		{ "rk", PP_U, PP_UNKNOWN,                 0, 'r',  },
1918
		{ "rn", PP_U, PP_UNKNOWN,                 0, 'r',  },
1919
		{ "ro", PP_U, PP_UNKNOWN,                 0, 'r',  },
1920
		{ "rv", PP_U, PP_UNKNOWN,                 0, 'r',  },
1921
		{ "r",  PP_U, PP_UNKNOWN,                 0, 'r',  },
1922
		{ "s",  PP_U, PP_PKG_FLATSIZE,            1, '\0', },
1923
		{ "t",  PP_U, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1924
		{ "u",  PP_U, PP_PKG_CHECKSUM,            1, '\0', },
1925
		{ "v",  PP_U, PP_PKG_VERSION,             1, '\0', },
1926
		{ "w",  PP_U, PP_PKG_HOME_PAGE,           1, '\0', },
1927
		{ "x",  PP_U, PP_PKG_PKGSIZE,             1, '\0', },
1928
		{ "z",  PP_U, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1929
		{ "%",  PP_U, PP_LITERAL_PERCENT,         1, '\0', },
1930
		{ "Z",  PP_U, PP_UNKNOWN,                 0, 'Z',  },
1931

1932
		{ "Bn", PP_b, PP_UNKNOWN,                 0, 'B', },
1933
		{ "B",  PP_b, PP_UNKNOWN,                 0, 'B',  },
1934
		{ "Cn", PP_b, PP_UNKNOWN,                 0, 'C',  },
1935
		{ "C",  PP_b, PP_UNKNOWN,                 0, 'C',  },
1936
		{ "Dg", PP_b, PP_UNKNOWN,                 0, 'D',  },
1937
		{ "Dk", PP_b, PP_UNKNOWN,                 0, 'D',  },
1938
		{ "Dn", PP_b, PP_UNKNOWN,                 0, 'D',  },
1939
		{ "Dp", PP_b, PP_UNKNOWN,                 0, 'D',  },
1940
		{ "Dt", PP_b, PP_UNKNOWN,                 0, 'D',  },
1941
		{ "Du", PP_b, PP_UNKNOWN,                 0, 'D',  },
1942
		{ "D",  PP_b, PP_UNKNOWN,                 0, 'D',  },
1943
		{ "Fg", PP_b, PP_UNKNOWN,                 0, 'F',  },
1944
		{ "Fk", PP_b, PP_UNKNOWN,                 0, 'F',  },
1945
		{ "Fn", PP_b, PP_UNKNOWN,                 0, 'F',  },
1946
		{ "Fp", PP_b, PP_UNKNOWN,                 0, 'F',  },
1947
		{ "Fs", PP_b, PP_UNKNOWN,                 0, 'F',  },
1948
		{ "Fu", PP_b, PP_UNKNOWN,                 0, 'F',  },
1949
		{ "F",  PP_b, PP_UNKNOWN,                 0, 'F',  },
1950
		{ "Gn", PP_b, PP_UNKNOWN,                 0, 'G',  },
1951
		{ "G",  PP_b, PP_UNKNOWN,                 0, 'G',  },
1952
		{ "I",  PP_b, PP_ROW_COUNTER,             1, '\0', },
1953
		{ "Ln", PP_b, PP_UNKNOWN,                 0, 'L',  },
1954
		{ "L",  PP_b, PP_UNKNOWN,                 0, 'L',  },
1955
		{ "M",  PP_b, PP_PKG_MESSAGE,             1, '\0', },
1956
		{ "N",  PP_b, PP_PKG_REPO_IDENT,          1, '\0', },
1957
		{ "On", PP_b, PP_UNKNOWN,                 0, 'O',  },
1958
		{ "Ov", PP_b, PP_UNKNOWN,                 0, 'O',  },
1959
		{ "Od", PP_b, PP_UNKNOWN,                 0, 'O',  },
1960
		{ "OD", PP_b, PP_UNKNOWN,                 0, 'O',  },
1961
		{ "O",  PP_b, PP_UNKNOWN,                 0, 'O',  },
1962
		{ "R",  PP_b, PP_PKG_REPO_PATH,           1, '\0', },
1963
		{ "S",  PP_b, PP_UNKNOWN,                 0, 'S',  },
1964
		{ "Un", PP_b, PP_UNKNOWN,                 0, 'U',  },
1965
		{ "U",  PP_b, PP_UNKNOWN,                 0, 'U',  },
1966
		{ "V",  PP_b, PP_PKG_OLD_VERSION,         1, '\0', },
1967
		{ "a",  PP_b, PP_PKG_AUTOREMOVE,          1, '\0', },
1968
		{ "bn", PP_b, PP_PKG_SHLIB_PROVIDED_NAME, 2, '\0', },
1969
		{ "b",  PP_b, PP_UNKNOWN,                 0, 'b',  },
1970
		{ "c",  PP_b, PP_PKG_COMMENT,             1, '\0', },
1971
		{ "dk", PP_b, PP_UNKNOWN,                 0, 'd',  },
1972
		{ "dn", PP_b, PP_UNKNOWN,                 0, 'd',  },
1973
		{ "do", PP_b, PP_UNKNOWN,                 0, 'd',  },
1974
		{ "dv", PP_b, PP_UNKNOWN,                 0, 'd',  },
1975
		{ "d",  PP_b, PP_UNKNOWN,                 0, 'd',  },
1976
		{ "e",  PP_b, PP_PKG_DESCRIPTION,         1, '\0', },
1977
		{ "k",  PP_b, PP_PKG_LOCK_STATUS,         1, '\0', },
1978
		{ "l",  PP_b, PP_PKG_LICENSE_LOGIC,       1, '\0', },
1979
		{ "m",  PP_b, PP_PKG_MAINTAINER,          1, '\0', },
1980
		{ "n",  PP_b, PP_PKG_NAME,                1, '\0', },
1981
		{ "o",  PP_b, PP_PKG_ORIGIN,              1, '\0', },
1982
		{ "p",  PP_b, PP_PKG_PREFIX,              1, '\0', },
1983
		{ "q",  PP_b, PP_PKG_ARCHITECTURE,        1, '\0', },
1984
		{ "rk", PP_b, PP_UNKNOWN,                 0, 'r',  },
1985
		{ "rn", PP_b, PP_UNKNOWN,                 0, 'r',  },
1986
		{ "ro", PP_b, PP_UNKNOWN,                 0, 'r',  },
1987
		{ "rv", PP_b, PP_UNKNOWN,                 0, 'r',  },
1988
		{ "r",  PP_b, PP_UNKNOWN,                 0, 'r',  },
1989
		{ "s",  PP_b, PP_PKG_FLATSIZE,            1, '\0', },
1990
		{ "t",  PP_b, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
1991
		{ "u",  PP_b, PP_PKG_CHECKSUM,            1, '\0', },
1992
		{ "v",  PP_b, PP_PKG_VERSION,             1, '\0', },
1993
		{ "w",  PP_b, PP_PKG_HOME_PAGE,           1, '\0', },
1994
		{ "x",  PP_b, PP_PKG_PKGSIZE,             1, '\0', },
1995
		{ "z",  PP_b, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
1996
		{ "%",  PP_b, PP_LITERAL_PERCENT,         1, '\0', },
1997
		{ "Z",  PP_b, PP_UNKNOWN,                 0, 'Z',  },
1998

1999
		{ "Bn", PP_d, PP_UNKNOWN,                 0, 'B',  },
2000
		{ "B",  PP_d, PP_UNKNOWN,                 0, 'B',  },
2001
		{ "Cn", PP_d, PP_UNKNOWN,                 0, 'C',  },
2002
		{ "C",  PP_d, PP_UNKNOWN,                 0, 'C',  },
2003
		{ "Dg", PP_d, PP_UNKNOWN,                 0, 'D',  },
2004
		{ "Dk", PP_d, PP_UNKNOWN,                 0, 'D',  },
2005
		{ "Dn", PP_d, PP_UNKNOWN,                 0, 'D',  },
2006
		{ "Dp", PP_d, PP_UNKNOWN,                 0, 'D',  },
2007
		{ "Dt", PP_d, PP_UNKNOWN,                 0, 'D',  },
2008
		{ "Du", PP_d, PP_UNKNOWN,                 0, 'D',  },
2009
		{ "D",  PP_d, PP_UNKNOWN,                 0, 'D',  },
2010
		{ "Fg", PP_d, PP_UNKNOWN,                 0, 'F',  },
2011
		{ "Fk", PP_d, PP_UNKNOWN,                 0, 'F',  },
2012
		{ "Fn", PP_d, PP_UNKNOWN,                 0, 'F',  },
2013
		{ "Fp", PP_d, PP_UNKNOWN,                 0, 'F',  },
2014
		{ "Fs", PP_d, PP_UNKNOWN,                 0, 'F',  },
2015
		{ "Fu", PP_d, PP_UNKNOWN,                 0, 'F',  },
2016
		{ "F",  PP_d, PP_UNKNOWN,                 0, 'F',  },
2017
		{ "Gn", PP_d, PP_UNKNOWN,                 0, 'G',  },
2018
		{ "G",  PP_d, PP_UNKNOWN,                 0, 'G',  },
2019
		{ "I",  PP_d, PP_ROW_COUNTER,             1, '\0', },
2020
		{ "Ln", PP_d, PP_UNKNOWN,                 0, 'L',  },
2021
		{ "L",  PP_d, PP_UNKNOWN,                 0, 'L',  },
2022
		{ "M",  PP_d, PP_PKG_MESSAGE,             1, '\0', },
2023
		{ "N",  PP_d, PP_PKG_REPO_IDENT,          1, '\0', },
2024
		{ "On", PP_d, PP_UNKNOWN,                 0, 'O',  },
2025
		{ "Ov", PP_d, PP_UNKNOWN,                 0, 'O',  },
2026
		{ "Od", PP_d, PP_UNKNOWN,                 0, 'O',  },
2027
		{ "OD", PP_d, PP_UNKNOWN,                 0, 'O',  },
2028
		{ "O",  PP_d, PP_UNKNOWN,                 0, 'O',  },
2029
		{ "R",  PP_d, PP_PKG_REPO_PATH,           1, '\0', },
2030
		{ "S",  PP_d, PP_UNKNOWN,                 0, 'S',  },
2031
		{ "Un", PP_d, PP_UNKNOWN,                 0, 'U',  },
2032
		{ "U",  PP_d, PP_UNKNOWN,                 0, 'U',  },
2033
		{ "V",  PP_d, PP_PKG_OLD_VERSION,         1, '\0', },
2034
		{ "a",  PP_d, PP_PKG_AUTOREMOVE,          1, '\0', },
2035
		{ "bn", PP_d, PP_UNKNOWN,                 0, 'b',  },
2036
		{ "b",  PP_d, PP_UNKNOWN,                 0, 'b',  },
2037
		{ "c",  PP_d, PP_PKG_COMMENT,             1, '\0', },
2038
		{ "dk", PP_d, PP_PKG_DEPENDENCY_LOCK,     2, '\0', },
2039
		{ "dn", PP_d, PP_PKG_DEPENDENCY_NAME,     2, '\0', },
2040
		{ "do", PP_d, PP_PKG_DEPENDENCY_ORIGIN,   2, '\0', },
2041
		{ "dv", PP_d, PP_PKG_DEPENDENCY_VERSION,  2, '\0', },
2042
		{ "d",  PP_d, PP_UNKNOWN,                 0, 'd',  },
2043
		{ "e",  PP_d, PP_PKG_DESCRIPTION,         1, '\0', },
2044
		{ "k",  PP_d, PP_PKG_LOCK_STATUS,         1, '\0', },
2045
		{ "l",  PP_d, PP_PKG_LICENSE_LOGIC,       1, '\0', },
2046
		{ "m",  PP_d, PP_PKG_MAINTAINER,          1, '\0', },
2047
		{ "n",  PP_d, PP_PKG_NAME,                1, '\0', },
2048
		{ "o",  PP_d, PP_PKG_ORIGIN,              1, '\0', },
2049
		{ "p",  PP_d, PP_PKG_PREFIX,              1, '\0', },
2050
		{ "q",  PP_d, PP_PKG_ARCHITECTURE,        1, '\0', },
2051
		{ "rk", PP_d, PP_UNKNOWN,                 0, 'r',  },
2052
		{ "rn", PP_d, PP_UNKNOWN,                 0, 'r',  },
2053
		{ "ro", PP_d, PP_UNKNOWN,                 0, 'r',  },
2054
		{ "rv", PP_d, PP_UNKNOWN,                 0, 'r',  },
2055
		{ "r",  PP_d, PP_UNKNOWN,                 0, 'r',  },
2056
		{ "s",  PP_d, PP_PKG_FLATSIZE,            1, '\0', },
2057
		{ "t",  PP_d, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
2058
		{ "u",  PP_d, PP_PKG_CHECKSUM,            1, '\0', },
2059
		{ "v",  PP_d, PP_PKG_VERSION,             1, '\0', },
2060
		{ "w",  PP_d, PP_PKG_HOME_PAGE,           1, '\0', },
2061
		{ "x",  PP_d, PP_PKG_PKGSIZE,             1, '\0', },
2062
		{ "z",  PP_d, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
2063
		{ "%",  PP_d, PP_LITERAL_PERCENT,         1, '\0', },
2064
		{ "Z",  PP_d, PP_UNKNOWN,                 0, 'Z',  },
2065

2066
		{ "Bn", PP_r, PP_UNKNOWN,                 0, 'B',  },
2067
		{ "B",  PP_r, PP_UNKNOWN,                 0, 'B',  },
2068
		{ "Cn", PP_r, PP_UNKNOWN,                 0, 'C',  },
2069
		{ "C",  PP_r, PP_UNKNOWN,                 0, 'C',  },
2070
		{ "Dg", PP_r, PP_UNKNOWN,                 0, 'D',  },
2071
		{ "Dk", PP_r, PP_UNKNOWN,                 0, 'D',  },
2072
		{ "Dn", PP_r, PP_UNKNOWN,                 0, 'D',  },
2073
		{ "Dp", PP_r, PP_UNKNOWN,                 0, 'D',  },
2074
		{ "Dt", PP_r, PP_UNKNOWN,                 0, 'D',  },
2075
		{ "Du", PP_r, PP_UNKNOWN,                 0, 'D',  },
2076
		{ "D",  PP_r, PP_UNKNOWN,                 0, 'D',  },
2077
		{ "Fg", PP_r, PP_UNKNOWN,                 0, 'F',  },
2078
		{ "Fk", PP_r, PP_UNKNOWN,                 0, 'F',  },
2079
		{ "Fn", PP_r, PP_UNKNOWN,                 0, 'F',  },
2080
		{ "Fp", PP_r, PP_UNKNOWN,                 0, 'F',  },
2081
		{ "Fs", PP_r, PP_UNKNOWN,                 0, 'F',  },
2082
		{ "Fu", PP_r, PP_UNKNOWN,                 0, 'F',  },
2083
		{ "F",  PP_r, PP_UNKNOWN,                 0, 'F',  },
2084
		{ "Gn", PP_r, PP_UNKNOWN,                 0, 'G',  },
2085
		{ "G",  PP_r, PP_UNKNOWN,                 0, 'G',  },
2086
		{ "I",  PP_r, PP_ROW_COUNTER,             1, '\0', },
2087
		{ "Ln", PP_r, PP_UNKNOWN,                 0, 'L',  },
2088
		{ "L",  PP_r, PP_UNKNOWN,                 0, 'L',  },
2089
		{ "M",  PP_r, PP_PKG_MESSAGE,             1, '\0', },
2090
		{ "N",  PP_r, PP_PKG_REPO_IDENT,          1, '\0', },
2091
		{ "On", PP_r, PP_UNKNOWN,                 0, 'O',  },
2092
		{ "Ov", PP_r, PP_UNKNOWN,                 0, 'O',  },
2093
		{ "Od", PP_r, PP_UNKNOWN,                 0, 'O',  },
2094
		{ "OD", PP_r, PP_UNKNOWN,                 0, 'O',  },
2095
		{ "O",  PP_r, PP_UNKNOWN,                 0, 'O',  },
2096
		{ "R",  PP_r, PP_PKG_REPO_PATH,           1, '\0', },
2097
		{ "S",  PP_r, PP_UNKNOWN,                 0, 'S',  },
2098
		{ "Un", PP_r, PP_UNKNOWN,                 0, 'U',  },
2099
		{ "U",  PP_r, PP_UNKNOWN,                 0, 'U',  },
2100
		{ "V",  PP_r, PP_PKG_OLD_VERSION,         1, '\0', },
2101
		{ "a",  PP_r, PP_PKG_AUTOREMOVE,          1, '\0', },
2102
		{ "bn", PP_r, PP_UNKNOWN,                 0, 'b',  },
2103
		{ "b",  PP_r, PP_UNKNOWN,                 0, 'b',  },
2104
		{ "c",  PP_r, PP_PKG_COMMENT,             1, '\0', },
2105
		{ "dk", PP_r, PP_UNKNOWN,                 0, 'd',  },
2106
		{ "dn", PP_r, PP_UNKNOWN,                 0, 'd',  },
2107
		{ "do", PP_r, PP_UNKNOWN,                 0, 'd',  },
2108
		{ "dv", PP_r, PP_UNKNOWN,                 0, 'd',  },
2109
		{ "d",  PP_r, PP_UNKNOWN,                 0, 'd',  },
2110
		{ "e",  PP_r, PP_PKG_DESCRIPTION,         1, '\0', },
2111
		{ "k",  PP_r, PP_PKG_LOCK_STATUS,         1, '\0', },
2112
		{ "l",  PP_r, PP_PKG_LICENSE_LOGIC,       1, '\0', },
2113
		{ "m",  PP_r, PP_PKG_MAINTAINER,          1, '\0', },
2114
		{ "n",  PP_r, PP_PKG_NAME,                1, '\0', },
2115
		{ "o",  PP_r, PP_PKG_ORIGIN,              1, '\0', },
2116
		{ "p",  PP_r, PP_PKG_PREFIX,              1, '\0', },
2117
		{ "q",  PP_r, PP_PKG_ARCHITECTURE,        1, '\0', },
2118
		{ "rk", PP_r, PP_PKG_REQUIREMENT_LOCK,    2, '\0', },
2119
		{ "rn", PP_r, PP_PKG_REQUIREMENT_NAME,    2, '\0', },
2120
		{ "ro", PP_r, PP_PKG_REQUIREMENT_ORIGIN,  2, '\0', },
2121
		{ "rv", PP_r, PP_PKG_REQUIREMENT_VERSION, 2, '\0', },
2122
		{ "r",  PP_r, PP_UNKNOWN,                 0, 'r',  },
2123
		{ "s",  PP_r, PP_PKG_FLATSIZE,            1, '\0', },
2124
		{ "t",  PP_r, PP_PKG_INSTALL_TIMESTAMP,   1, '\0', },
2125
		{ "u",  PP_r, PP_PKG_CHECKSUM,            1, '\0', },
2126
		{ "v",  PP_r, PP_PKG_VERSION,             1, '\0', },
2127
		{ "w",  PP_r, PP_PKG_HOME_PAGE,           1, '\0', },
2128
		{ "x",  PP_r, PP_PKG_PKGSIZE,             1, '\0', },
2129
		{ "z",  PP_r, PP_PKG_SHORT_CHECKSUM,      1, '\0', },
2130
		{ "%",  PP_r, PP_LITERAL_PERCENT,         1, '\0', },
2131
		{ "Z",  PP_r, PP_UNKNOWN,                 0, 'Z',  },
2132

2133
		{ NULL, 0,    0,                          0, '\0', },
2134
	};
2135

2136
	p = new_percent_esc();
2137

2138
	ATF_REQUIRE_EQ(p != NULL, true);
2139

2140
	for (i = 0; fc_test_vals[i].in != NULL; i++) {
2141
		p->width = 0;
2142
		f = format_code(fc_test_vals[i].in, fc_test_vals[i].context, p);
2143

2144
		ATF_CHECK_EQ_MSG(p->fmt_code, fc_test_vals[i].fmt_code,
2145
				    "(test %d: %d != %d)", i,
2146
				    p->fmt_code, fc_test_vals[i].fmt_code);
2147
		ATF_CHECK_EQ_MSG(f - fc_test_vals[i].in,
2148
				 fc_test_vals[i].fend_offset,
2149
				 "(test %d)", i);
2150
		ATF_CHECK_EQ_MSG(*f, fc_test_vals[i].fend_val,
2151
				 "(test %d)", i);
2152
	}
2153

2154
	free_percent_esc(p);
2155
}
2156

2157
ATF_TC(format_trailer);
2158
ATF_TC_HEAD(format_trailer, tc)
2159
{
2160
	atf_tc_set_md_var(tc, "descr",
2161
	    "Testing format_trailer() format parsing routine");
2162
}
2163
ATF_TC_BODY(format_trailer, tc)
2164
{
2165
	struct percent_esc	*p;
2166
	const char		*f;
2167
	int		 	i;
2168

2169
	struct ft_test_vals {
2170
		const char *in;
2171
		const char *item;
2172
		const char *sep;
2173
		ptrdiff_t   fend_offset; /* Where f is left pointing */
2174
		char	    fend_val; /* expected first char in fend */
2175
	} ft_test_vals[] = {
2176
		{ "%{aaaaaaaa", "",   "",    0, '%',  },
2177
		{ "%{bb%|cccc", "",   "",    0, '%',  },
2178
		{ "ddd%|eee%}", "",   "",    0, 'd',  },
2179
		{ "%{ff%|gg%}", "ff", "gg", 10, '\0', },
2180
		{ "%{hh%}",     "hh", "",    6, '\0', },
2181
		{ "%{%|iii%}",  "",   "iii", 9, '\0', },
2182

2183
		{ NULL,         NULL, NULL,  0, '\0', },
2184
	};
2185

2186
	p = new_percent_esc();
2187

2188
	ATF_REQUIRE_EQ(p != NULL, true);
2189

2190
	for (i = 0; ft_test_vals[i].in != NULL; i++) {
2191
		clear_percent_esc(p);
2192

2193
		f = format_trailer(ft_test_vals[i].in, p);
2194
		fflush(p->item_fmt->fp);
2195
		fflush(p->sep_fmt->fp);
2196

2197
		ATF_CHECK_STREQ_MSG(p->item_fmt->buf,
2198
				    ft_test_vals[i].item,
2199
				    "(test %d)", i);
2200
		ATF_CHECK_STREQ_MSG(p->sep_fmt->buf,
2201
				    ft_test_vals[i].sep,
2202
				    "(test %d)", i);
2203
		ATF_CHECK_EQ_MSG(f - ft_test_vals[i].in,
2204
				 ft_test_vals[i].fend_offset,
2205
				 "(test %d)", i);
2206
		ATF_CHECK_EQ_MSG(*f, ft_test_vals[i].fend_val,
2207
				 "(test %d)", i);
2208
	}
2209

2210
	free_percent_esc(p);
2211
}
2212

2213
ATF_TC(parse_format);
2214
ATF_TC_HEAD(parse_format, tc)
2215
{
2216
	atf_tc_set_md_var(tc, "descr",
2217
	    "Testing parse_format() format parsing routine");
2218
}
2219
ATF_TC_BODY(parse_format, tc)
2220
{
2221
	struct percent_esc	*p;
2222
	const char		*f;
2223
	int		 	i;
2224

2225
	struct pf_test_vals {
2226
		const char *in;
2227
		unsigned context;
2228

2229
		unsigned flags;
2230
		int width;
2231
		fmt_code_t fmt_code;
2232
		const char *item;
2233
		const char *sep;
2234
		ptrdiff_t   fend_offset; /* Where f is left pointing */
2235
		char	    fend_val; /* expected first char in fend */
2236
	} pf_test_vals[] = {
2237
		{ "%n",    PP_PKG, 0,             0,  PP_PKG_NAME, "",   "",   2, '\0', },
2238
		{ "%-20n", PP_PKG, PP_LEFT_ALIGN, 20, PP_PKG_NAME, "",   "",   5, '\0', },
2239
		{ "%?B",   PP_PKG, PP_ALTERNATE_FORM1, 0, PP_PKG_SHLIBS_REQUIRED, "", "", 3, '\0', },
2240
		{ "%#F",   PP_PKG, PP_ALTERNATE_FORM2, 0, PP_PKG_FILES,  "", "", 3, '\0', },
2241

2242
		{ "%L%{%Ln%| %l %}", PP_PKG, 0, 0, PP_PKG_LICENSES, "%Ln", " %l ", 15, '\0', },
2243
		{ "%Ln",   PP_L,   0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
2244
		{ "%l",    PP_L,   0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
2245

2246
		{ "%Ln",   PP_PKG, 0,             0,  PP_PKG_LICENSE_NAME,  "", "", 3, '\0', },
2247
		{ "%l",    PP_PKG, 0,             0,  PP_PKG_LICENSE_LOGIC, "", "", 2, '\0', },
2248

2249
		{ "%I",    PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, 'I', },
2250

2251
		{ "%^D",   PP_PKG, 0,             0,  PP_UNKNOWN,          "", "", 1, '^', },
2252

2253
		{ NULL,    0,      0,             0,  0,           NULL, NULL, 0, '\0', },
2254
	};
2255

2256
	p = new_percent_esc();
2257

2258
	ATF_REQUIRE(p != NULL);
2259

2260
	for (i = 0; pf_test_vals[i].in != NULL; i++) {
2261
		f = parse_format(pf_test_vals[i].in, pf_test_vals[i].context,
2262
				 p);
2263

2264
		ATF_CHECK_EQ_MSG(p->flags, pf_test_vals[i].flags,
2265
				    "(test %d)", i);
2266
		ATF_CHECK_EQ_MSG(p->width, pf_test_vals[i].width,
2267
				    "(test %d)", i);
2268
		ATF_CHECK_EQ_MSG(p->fmt_code, pf_test_vals[i].fmt_code,
2269
				    "(test %d)", i);
2270

2271
		fflush(p->item_fmt->fp);
2272
		fflush(p->sep_fmt->fp);
2273
		ATF_CHECK_STREQ_MSG(p->item_fmt->buf,
2274
				    pf_test_vals[i].item,
2275
				    "(test %d)", i);
2276
		ATF_CHECK_STREQ_MSG(p->sep_fmt->buf,
2277
				    pf_test_vals[i].sep,
2278
				    "(test %d)", i);
2279
		ATF_CHECK_EQ_MSG(f - pf_test_vals[i].in,
2280
				 pf_test_vals[i].fend_offset,
2281
				 "(test %d)", i);
2282
		ATF_CHECK_EQ_MSG(*f, pf_test_vals[i].fend_val,
2283
				 "(test %d)", i);
2284

2285
		p = clear_percent_esc(p);
2286
	}
2287

2288
	free_percent_esc(p);
2289
}
2290

2291

2292

2293
ATF_TP_ADD_TCS(tp)
2294
{
2295
	/* Output routines */
2296
	ATF_TP_ADD_TC(tp, gen_format);
2297
	ATF_TP_ADD_TC(tp, human_number);
2298
	ATF_TP_ADD_TC(tp, string_val);
2299
	ATF_TP_ADD_TC(tp, int_val);
2300
	ATF_TP_ADD_TC(tp, bool_val);
2301
	ATF_TP_ADD_TC(tp, mode_val);
2302
	ATF_TP_ADD_TC(tp, liclog_val);
2303
	ATF_TP_ADD_TC(tp, list_count);
2304

2305
	/* Format string parsing routines */
2306
	ATF_TP_ADD_TC(tp, maybe_read_hex_byte);
2307
	ATF_TP_ADD_TC(tp, read_oct_byte);
2308
	ATF_TP_ADD_TC(tp, process_escape);
2309

2310
	ATF_TP_ADD_TC(tp, field_modifier);
2311
	ATF_TP_ADD_TC(tp, field_width);
2312
	ATF_TP_ADD_TC(tp, format_code);
2313
	ATF_TP_ADD_TC(tp, format_trailer);
2314
	ATF_TP_ADD_TC(tp, parse_format);
2315

2316

2317
	return atf_no_error();
2318
}
2319
/*
2320
 * That's All Folks!
2321
 */
2322

2323
Product

Resources

Company
