1
/* Test of u8_v[a]s[n]printf() function.
2
Copyright (C) 2007 Free Software Foundation, Inc.
4
This program is free software; you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; either version 2, or (at your option)
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
14
You should have received a copy of the GNU General Public License
15
along with this program; if not, write to the Free Software Foundation,
16
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18
/* Written by Bruno Haible <bruno@clisp.org>, 2007. */
21
test_xfunction (uint8_t * (*my_xasprintf) (const char *, ...))
23
/* Test support of size specifiers as in C99. */
27
my_xasprintf ("%ju %d", (uintmax_t) 12345671, 33, 44, 55);
28
static const uint8_t expected[] = "12345671 33";
29
ASSERT (result != NULL);
30
ASSERT (u8_strcmp (result, expected) == 0);
36
my_xasprintf ("%zu %d", (size_t) 12345672, 33, 44, 55);
37
static const uint8_t expected[] = "12345672 33";
38
ASSERT (result != NULL);
39
ASSERT (u8_strcmp (result, expected) == 0);
45
my_xasprintf ("%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
46
static const uint8_t expected[] = "12345673 33";
47
ASSERT (result != NULL);
48
ASSERT (u8_strcmp (result, expected) == 0);
54
my_xasprintf ("%Lg %d", (long double) 1.5, 33, 44, 55);
55
static const uint8_t expected[] = "1.5 33";
56
ASSERT (result != NULL);
57
ASSERT (u8_strcmp (result, expected) == 0);
61
/* Test the support of the 'U' conversion specifier for Unicode strings. */
64
static const uint8_t unicode_string[] = "Hello";
67
my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
68
static const uint8_t expected[] = "Hello 33";
69
ASSERT (result != NULL);
70
ASSERT (u8_strcmp (result, expected) == 0);
75
my_xasprintf ("%10U %d", unicode_string, 33, 44, 55);
76
static const uint8_t expected[] = " Hello 33";
77
ASSERT (result != NULL);
78
ASSERT (u8_strcmp (result, expected) == 0);
83
my_xasprintf ("%-10U %d", unicode_string, 33, 44, 55);
84
static const uint8_t expected[] = "Hello 33";
85
ASSERT (result != NULL);
86
ASSERT (u8_strcmp (result, expected) == 0);
89
{ /* FLAG_ZERO: no effect. */
91
my_xasprintf ("%010U %d", unicode_string, 33, 44, 55);
92
static const uint8_t expected[] = " Hello 33";
93
ASSERT (result != NULL);
94
ASSERT (u8_strcmp (result, expected) == 0);
100
static const uint16_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
103
my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
104
static const uint8_t expected[] = "Hello 33";
105
ASSERT (result != NULL);
106
ASSERT (u8_strcmp (result, expected) == 0);
111
my_xasprintf ("%10lU %d", unicode_string, 33, 44, 55);
112
static const uint8_t expected[] = " Hello 33";
113
ASSERT (result != NULL);
114
ASSERT (u8_strcmp (result, expected) == 0);
119
my_xasprintf ("%-10lU %d", unicode_string, 33, 44, 55);
120
static const uint8_t expected[] = "Hello 33";
121
ASSERT (result != NULL);
122
ASSERT (u8_strcmp (result, expected) == 0);
125
{ /* FLAG_ZERO: no effect. */
127
my_xasprintf ("%010lU %d", unicode_string, 33, 44, 55);
128
static const uint8_t expected[] = " Hello 33";
129
ASSERT (result != NULL);
130
ASSERT (u8_strcmp (result, expected) == 0);
136
static const uint32_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
139
my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
140
static const uint8_t expected[] = "Hello 33";
141
ASSERT (result != NULL);
142
ASSERT (u8_strcmp (result, expected) == 0);
147
my_xasprintf ("%10llU %d", unicode_string, 33, 44, 55);
148
static const uint8_t expected[] = " Hello 33";
149
ASSERT (result != NULL);
150
ASSERT (u8_strcmp (result, expected) == 0);
155
my_xasprintf ("%-10llU %d", unicode_string, 33, 44, 55);
156
static const uint8_t expected[] = "Hello 33";
157
ASSERT (result != NULL);
158
ASSERT (u8_strcmp (result, expected) == 0);
161
{ /* FLAG_ZERO: no effect. */
163
my_xasprintf ("%010llU %d", unicode_string, 33, 44, 55);
164
static const uint8_t expected[] = " Hello 33";
165
ASSERT (result != NULL);
166
ASSERT (u8_strcmp (result, expected) == 0);
171
/* Test the support of the 's' conversion specifier for strings. */
175
my_xasprintf ("Mr. %s %d", "Ronald Reagan", 33, 44, 55);
176
static const uint8_t expected[] = "Mr. Ronald Reagan 33";
177
ASSERT (result != NULL);
178
ASSERT (u8_strcmp (result, expected) == 0);
184
my_xasprintf ("Mr. %20s %d", "Ronald Reagan", 33, 44, 55);
185
static const uint8_t expected[] = "Mr. Ronald Reagan 33";
186
ASSERT (result != NULL);
187
ASSERT (u8_strcmp (result, expected) == 0);
193
my_xasprintf ("Mr. %-20s %d", "Ronald Reagan", 33, 44, 55);
194
static const uint8_t expected[] = "Mr. Ronald Reagan 33";
195
ASSERT (result != NULL);
196
ASSERT (u8_strcmp (result, expected) == 0);
200
{ /* FLAG_ZERO: no effect. */
202
my_xasprintf ("Mr. %020s %d", "Ronald Reagan", 33, 44, 55);
203
static const uint8_t expected[] = "Mr. Ronald Reagan 33";
204
ASSERT (result != NULL);
205
ASSERT (u8_strcmp (result, expected) == 0);
209
/* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
210
output of floating-point numbers. */
212
{ /* A positive number. */
214
my_xasprintf ("%a %d", 3.1416015625, 33, 44, 55);
215
static const uint8_t expected1[] = "0x1.922p+1 33";
216
static const uint8_t expected2[] = "0x3.244p+0 33";
217
static const uint8_t expected3[] = "0x6.488p-1 33";
218
static const uint8_t expected4[] = "0xc.91p-2 33";
219
ASSERT (result != NULL);
220
ASSERT (u8_strcmp (result, expected1) == 0
221
|| u8_strcmp (result, expected2) == 0
222
|| u8_strcmp (result, expected3) == 0
223
|| u8_strcmp (result, expected4) == 0);
229
my_xasprintf ("%10a %d", 1.75, 33, 44, 55);
230
static const uint8_t expected1[] = " 0x1.cp+0 33";
231
static const uint8_t expected2[] = " 0x3.8p-1 33";
232
static const uint8_t expected3[] = " 0x7p-2 33";
233
static const uint8_t expected4[] = " 0xep-3 33";
234
ASSERT (result != NULL);
235
ASSERT (u8_strcmp (result, expected1) == 0
236
|| u8_strcmp (result, expected2) == 0
237
|| u8_strcmp (result, expected3) == 0
238
|| u8_strcmp (result, expected4) == 0);
242
{ /* Small precision. */
244
my_xasprintf ("%.10a %d", 1.75, 33, 44, 55);
245
static const uint8_t expected1[] = "0x1.c000000000p+0 33";
246
static const uint8_t expected2[] = "0x3.8000000000p-1 33";
247
static const uint8_t expected3[] = "0x7.0000000000p-2 33";
248
static const uint8_t expected4[] = "0xe.0000000000p-3 33";
249
ASSERT (result != NULL);
250
ASSERT (u8_strcmp (result, expected1) == 0
251
|| u8_strcmp (result, expected2) == 0
252
|| u8_strcmp (result, expected3) == 0
253
|| u8_strcmp (result, expected4) == 0);
257
{ /* Large precision. */
259
my_xasprintf ("%.50a %d", 1.75, 33, 44, 55);
260
static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
261
static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
262
static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
263
static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
264
ASSERT (result != NULL);
265
ASSERT (u8_strcmp (result, expected1) == 0
266
|| u8_strcmp (result, expected2) == 0
267
|| u8_strcmp (result, expected3) == 0
268
|| u8_strcmp (result, expected4) == 0);
272
{ /* A positive number. */
274
my_xasprintf ("%La %d", 3.1416015625L, 33, 44, 55);
275
static const uint8_t expected1[] = "0x1.922p+1 33";
276
static const uint8_t expected2[] = "0x3.244p+0 33";
277
static const uint8_t expected3[] = "0x6.488p-1 33";
278
static const uint8_t expected4[] = "0xc.91p-2 33";
279
ASSERT (result != NULL);
280
ASSERT (u8_strcmp (result, expected1) == 0
281
|| u8_strcmp (result, expected2) == 0
282
|| u8_strcmp (result, expected3) == 0
283
|| u8_strcmp (result, expected4) == 0);
289
my_xasprintf ("%10La %d", 1.75L, 33, 44, 55);
290
static const uint8_t expected1[] = " 0x1.cp+0 33";
291
static const uint8_t expected2[] = " 0x3.8p-1 33";
292
static const uint8_t expected3[] = " 0x7p-2 33";
293
static const uint8_t expected4[] = " 0xep-3 33";
294
ASSERT (result != NULL);
295
ASSERT (u8_strcmp (result, expected1) == 0
296
|| u8_strcmp (result, expected2) == 0
297
|| u8_strcmp (result, expected3) == 0
298
|| u8_strcmp (result, expected4) == 0);
302
{ /* Small precision. */
304
my_xasprintf ("%.10La %d", 1.75L, 33, 44, 55);
305
static const uint8_t expected1[] = "0x1.c000000000p+0 33";
306
static const uint8_t expected2[] = "0x3.8000000000p-1 33";
307
static const uint8_t expected3[] = "0x7.0000000000p-2 33";
308
static const uint8_t expected4[] = "0xe.0000000000p-3 33";
309
ASSERT (result != NULL);
310
ASSERT (u8_strcmp (result, expected1) == 0
311
|| u8_strcmp (result, expected2) == 0
312
|| u8_strcmp (result, expected3) == 0
313
|| u8_strcmp (result, expected4) == 0);
317
{ /* Large precision. */
319
my_xasprintf ("%.50La %d", 1.75L, 33, 44, 55);
320
static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
321
static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
322
static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
323
static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
324
ASSERT (result != NULL);
325
ASSERT (u8_strcmp (result, expected1) == 0
326
|| u8_strcmp (result, expected2) == 0
327
|| u8_strcmp (result, expected3) == 0
328
|| u8_strcmp (result, expected4) == 0);
332
/* Test the support of the %f format directive. */
334
{ /* A positive number. */
336
my_xasprintf ("%f %d", 12.75, 33, 44, 55);
337
static const uint8_t expected[] = "12.750000 33";
338
ASSERT (result != NULL);
339
ASSERT (u8_strcmp (result, expected) == 0);
345
my_xasprintf ("%10f %d", 1.75, 33, 44, 55);
346
static const uint8_t expected[] = " 1.750000 33";
347
ASSERT (result != NULL);
348
ASSERT (u8_strcmp (result, expected) == 0);
354
my_xasprintf ("%.f %d", 1234.0, 33, 44, 55);
355
static const uint8_t expected[] = "1234 33";
356
ASSERT (result != NULL);
357
ASSERT (u8_strcmp (result, expected) == 0);
361
{ /* A positive number. */
363
my_xasprintf ("%Lf %d", 12.75L, 33, 44, 55);
364
static const uint8_t expected[] = "12.750000 33";
365
ASSERT (result != NULL);
366
ASSERT (u8_strcmp (result, expected) == 0);
372
my_xasprintf ("%10Lf %d", 1.75L, 33, 44, 55);
373
static const uint8_t expected[] = " 1.750000 33";
374
ASSERT (result != NULL);
375
ASSERT (u8_strcmp (result, expected) == 0);
381
my_xasprintf ("%.Lf %d", 1234.0L, 33, 44, 55);
382
static const uint8_t expected[] = "1234 33";
383
ASSERT (result != NULL);
384
ASSERT (u8_strcmp (result, expected) == 0);
388
/* Test the support of the %F format directive. */
390
{ /* A positive number. */
392
my_xasprintf ("%F %d", 12.75, 33, 44, 55);
393
static const uint8_t expected[] = "12.750000 33";
394
ASSERT (result != NULL);
395
ASSERT (u8_strcmp (result, expected) == 0);
401
my_xasprintf ("%.F %d", 1234.0, 33, 44, 55);
402
static const uint8_t expected[] = "1234 33";
403
ASSERT (result != NULL);
404
ASSERT (u8_strcmp (result, expected) == 0);
408
{ /* A positive number. */
410
my_xasprintf ("%LF %d", 12.75L, 33, 44, 55);
411
static const uint8_t expected[] = "12.750000 33";
412
ASSERT (result != NULL);
413
ASSERT (u8_strcmp (result, expected) == 0);
419
my_xasprintf ("%.LF %d", 1234.0L, 33, 44, 55);
420
static const uint8_t expected[] = "1234 33";
421
ASSERT (result != NULL);
422
ASSERT (u8_strcmp (result, expected) == 0);
426
/* Test the support of the %e format directive. */
428
{ /* A positive number. */
430
my_xasprintf ("%e %d", 12.75, 33, 44, 55);
431
static const uint8_t expected1[] = "1.275000e+01 33";
432
static const uint8_t expected2[] = "1.275000e+001 33";
433
ASSERT (result != NULL);
434
ASSERT (u8_strcmp (result, expected1) == 0
435
|| u8_strcmp (result, expected2) == 0);
441
my_xasprintf ("%15e %d", 1.75, 33, 44, 55);
442
static const uint8_t expected1[] = " 1.750000e+00 33";
443
static const uint8_t expected2[] = " 1.750000e+000 33";
444
ASSERT (result != NULL);
445
ASSERT (u8_strcmp (result, expected1) == 0
446
|| u8_strcmp (result, expected2) == 0);
452
my_xasprintf ("%.e %d", 1234.0, 33, 44, 55);
453
static const uint8_t expected1[] = "1e+03 33";
454
static const uint8_t expected2[] = "1e+003 33";
455
ASSERT (result != NULL);
456
ASSERT (u8_strcmp (result, expected1) == 0
457
|| u8_strcmp (result, expected2) == 0);
461
{ /* A positive number. */
463
my_xasprintf ("%Le %d", 12.75L, 33, 44, 55);
464
static const uint8_t expected[] = "1.275000e+01 33";
465
ASSERT (result != NULL);
466
ASSERT (u8_strcmp (result, expected) == 0);
472
my_xasprintf ("%15Le %d", 1.75L, 33, 44, 55);
473
static const uint8_t expected[] = " 1.750000e+00 33";
474
ASSERT (result != NULL);
475
ASSERT (u8_strcmp (result, expected) == 0);
481
my_xasprintf ("%.Le %d", 1234.0L, 33, 44, 55);
482
static const uint8_t expected[] = "1e+03 33";
483
ASSERT (result != NULL);
484
ASSERT (u8_strcmp (result, expected) == 0);
488
/* Test the support of the %g format directive. */
490
{ /* A positive number. */
492
my_xasprintf ("%g %d", 12.75, 33, 44, 55);
493
static const uint8_t expected[] = "12.75 33";
494
ASSERT (result != NULL);
495
ASSERT (u8_strcmp (result, expected) == 0);
501
my_xasprintf ("%10g %d", 1.75, 33, 44, 55);
502
static const uint8_t expected[] = " 1.75 33";
503
ASSERT (result != NULL);
504
ASSERT (u8_strcmp (result, expected) == 0);
510
my_xasprintf ("%.g %d", 1234.0, 33, 44, 55);
511
static const uint8_t expected1[] = "1e+03 33";
512
static const uint8_t expected2[] = "1e+003 33";
513
ASSERT (result != NULL);
514
ASSERT (u8_strcmp (result, expected1) == 0
515
|| u8_strcmp (result, expected2) == 0);
519
{ /* A positive number. */
521
my_xasprintf ("%Lg %d", 12.75L, 33, 44, 55);
522
static const uint8_t expected[] = "12.75 33";
523
ASSERT (result != NULL);
524
ASSERT (u8_strcmp (result, expected) == 0);
530
my_xasprintf ("%10Lg %d", 1.75L, 33, 44, 55);
531
static const uint8_t expected[] = " 1.75 33";
532
ASSERT (result != NULL);
533
ASSERT (u8_strcmp (result, expected) == 0);
539
my_xasprintf ("%.Lg %d", 1234.0L, 33, 44, 55);
540
static const uint8_t expected[] = "1e+03 33";
541
ASSERT (result != NULL);
542
ASSERT (u8_strcmp (result, expected) == 0);
546
/* Test the support of the %n format directive. */
551
my_xasprintf ("%d %n", 123, &count, 33, 44, 55);
552
static const uint8_t expected[] = "123 ";
553
ASSERT (result != NULL);
554
ASSERT (u8_strcmp (result, expected) == 0);
559
/* Test the support of the POSIX/XSI format strings with positions. */
563
my_xasprintf ("%2$d %1$d", 33, 55);
564
static const uint8_t expected[] = "55 33";
565
ASSERT (result != NULL);
566
ASSERT (u8_strcmp (result, expected) == 0);
570
/* Test the support of the grouping flag. */
574
my_xasprintf ("%'d %d", 1234567, 99);
575
ASSERT (result != NULL);
576
ASSERT (result[u8_strlen (result) - 1] == '9');
580
/* Test the support of the 'U' conversion specifier for Unicode strings. */
583
static const uint8_t unicode_string[] = "Rafa\305\202 Maszkowski"; /* Rafał Maszkowski */
586
my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
587
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
588
ASSERT (result != NULL);
589
ASSERT (u8_strcmp (result, expected) == 0);
594
my_xasprintf ("%20U %d", unicode_string, 33, 44, 55);
595
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
596
ASSERT (result != NULL);
597
ASSERT (u8_strcmp (result, expected) == 0);
602
my_xasprintf ("%-20U %d", unicode_string, 33, 44, 55);
603
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
604
ASSERT (result != NULL);
605
ASSERT (u8_strcmp (result, expected) == 0);
608
{ /* FLAG_ZERO: no effect. */
610
my_xasprintf ("%020U %d", unicode_string, 33, 44, 55);
611
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
612
ASSERT (result != NULL);
613
ASSERT (u8_strcmp (result, expected) == 0);
619
static const uint16_t unicode_string[] = /* Rafał Maszkowski */
621
'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
626
my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
627
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
628
ASSERT (result != NULL);
629
ASSERT (u8_strcmp (result, expected) == 0);
634
my_xasprintf ("%20lU %d", unicode_string, 33, 44, 55);
635
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
636
ASSERT (result != NULL);
637
ASSERT (u8_strcmp (result, expected) == 0);
642
my_xasprintf ("%-20lU %d", unicode_string, 33, 44, 55);
643
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
644
ASSERT (result != NULL);
645
ASSERT (u8_strcmp (result, expected) == 0);
648
{ /* FLAG_ZERO: no effect. */
650
my_xasprintf ("%020lU %d", unicode_string, 33, 44, 55);
651
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
652
ASSERT (result != NULL);
653
ASSERT (u8_strcmp (result, expected) == 0);
659
static const uint32_t unicode_string[] = /* Rafał Maszkowski */
661
'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
666
my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
667
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
668
ASSERT (result != NULL);
669
ASSERT (u8_strcmp (result, expected) == 0);
674
my_xasprintf ("%20llU %d", unicode_string, 33, 44, 55);
675
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
676
ASSERT (result != NULL);
677
ASSERT (u8_strcmp (result, expected) == 0);
682
my_xasprintf ("%-20llU %d", unicode_string, 33, 44, 55);
683
static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
684
ASSERT (result != NULL);
685
ASSERT (u8_strcmp (result, expected) == 0);
688
{ /* FLAG_ZERO: no effect. */
690
my_xasprintf ("%020llU %d", unicode_string, 33, 44, 55);
691
static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
692
ASSERT (result != NULL);
693
ASSERT (u8_strcmp (result, expected) == 0);
698
/* Test non-ASCII characters in the format string. */
702
my_xasprintf ("\304rger", 33, 44, 55);
703
ASSERT (result == NULL && errno == EINVAL);