1/* Test of u8_v[a]s[n]printf() function.
2   Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
3
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 3 of the License, or
7   (at your option) any later version.
8
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.
13
14   You should have received a copy of the GNU General Public License
15   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
16
17/* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
18
19static void
20test_xfunction (uint8_t * (*my_xasprintf) (const char *, ...))
21{
22  /* Test support of size specifiers as in C99.  */
23
24  {
25    uint8_t *result =
26      my_xasprintf ("%ju %d", (uintmax_t) 12345671, 33, 44, 55);
27    static const uint8_t expected[] = "12345671 33";
28    ASSERT (result != NULL);
29    ASSERT (u8_strcmp (result, expected) == 0);
30    free (result);
31  }
32
33  {
34    uint8_t *result =
35      my_xasprintf ("%zu %d", (size_t) 12345672, 33, 44, 55);
36    static const uint8_t expected[] = "12345672 33";
37    ASSERT (result != NULL);
38    ASSERT (u8_strcmp (result, expected) == 0);
39    free (result);
40  }
41
42  {
43    uint8_t *result =
44      my_xasprintf ("%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
45    static const uint8_t expected[] = "12345673 33";
46    ASSERT (result != NULL);
47    ASSERT (u8_strcmp (result, expected) == 0);
48    free (result);
49  }
50
51  {
52    uint8_t *result =
53      my_xasprintf ("%Lg %d", (long double) 1.5, 33, 44, 55);
54    static const uint8_t expected[] = "1.5 33";
55    ASSERT (result != NULL);
56    ASSERT (u8_strcmp (result, expected) == 0);
57    free (result);
58  }
59
60  /* Test the support of the 'U' conversion specifier for Unicode strings.  */
61
62  {
63    static const uint8_t unicode_string[] = "Hello";
64    {
65      uint8_t *result =
66        my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
67      static const uint8_t expected[] = "Hello 33";
68      ASSERT (result != NULL);
69      ASSERT (u8_strcmp (result, expected) == 0);
70      free (result);
71    }
72    { /* Width.  */
73      uint8_t *result =
74        my_xasprintf ("%10U %d", unicode_string, 33, 44, 55);
75      static const uint8_t expected[] = "     Hello 33";
76      ASSERT (result != NULL);
77      ASSERT (u8_strcmp (result, expected) == 0);
78      free (result);
79    }
80    { /* FLAG_LEFT.  */
81      uint8_t *result =
82        my_xasprintf ("%-10U %d", unicode_string, 33, 44, 55);
83      static const uint8_t expected[] = "Hello      33";
84      ASSERT (result != NULL);
85      ASSERT (u8_strcmp (result, expected) == 0);
86      free (result);
87    }
88    { /* FLAG_ZERO: no effect.  */
89      uint8_t *result =
90        my_xasprintf ("%010U %d", unicode_string, 33, 44, 55);
91      static const uint8_t expected[] = "     Hello 33";
92      ASSERT (result != NULL);
93      ASSERT (u8_strcmp (result, expected) == 0);
94      free (result);
95    }
96  }
97
98  {
99    static const uint16_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
100    {
101      uint8_t *result =
102        my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
103      static const uint8_t expected[] = "Hello 33";
104      ASSERT (result != NULL);
105      ASSERT (u8_strcmp (result, expected) == 0);
106      free (result);
107    }
108    { /* Width.  */
109      uint8_t *result =
110        my_xasprintf ("%10lU %d", unicode_string, 33, 44, 55);
111      static const uint8_t expected[] = "     Hello 33";
112      ASSERT (result != NULL);
113      ASSERT (u8_strcmp (result, expected) == 0);
114      free (result);
115    }
116    { /* FLAG_LEFT.  */
117      uint8_t *result =
118        my_xasprintf ("%-10lU %d", unicode_string, 33, 44, 55);
119      static const uint8_t expected[] = "Hello      33";
120      ASSERT (result != NULL);
121      ASSERT (u8_strcmp (result, expected) == 0);
122      free (result);
123    }
124    { /* FLAG_ZERO: no effect.  */
125      uint8_t *result =
126        my_xasprintf ("%010lU %d", unicode_string, 33, 44, 55);
127      static const uint8_t expected[] = "     Hello 33";
128      ASSERT (result != NULL);
129      ASSERT (u8_strcmp (result, expected) == 0);
130      free (result);
131    }
132  }
133
134  {
135    static const uint32_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
136    {
137      uint8_t *result =
138        my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
139      static const uint8_t expected[] = "Hello 33";
140      ASSERT (result != NULL);
141      ASSERT (u8_strcmp (result, expected) == 0);
142      free (result);
143    }
144    { /* Width.  */
145      uint8_t *result =
146        my_xasprintf ("%10llU %d", unicode_string, 33, 44, 55);
147      static const uint8_t expected[] = "     Hello 33";
148      ASSERT (result != NULL);
149      ASSERT (u8_strcmp (result, expected) == 0);
150      free (result);
151    }
152    { /* FLAG_LEFT.  */
153      uint8_t *result =
154        my_xasprintf ("%-10llU %d", unicode_string, 33, 44, 55);
155      static const uint8_t expected[] = "Hello      33";
156      ASSERT (result != NULL);
157      ASSERT (u8_strcmp (result, expected) == 0);
158      free (result);
159    }
160    { /* FLAG_ZERO: no effect.  */
161      uint8_t *result =
162        my_xasprintf ("%010llU %d", unicode_string, 33, 44, 55);
163      static const uint8_t expected[] = "     Hello 33";
164      ASSERT (result != NULL);
165      ASSERT (u8_strcmp (result, expected) == 0);
166      free (result);
167    }
168  }
169
170  /* Test the support of the 's' conversion specifier for strings.  */
171
172  {
173    uint8_t *result =
174      my_xasprintf ("Mr. %s %d", "Ronald Reagan", 33, 44, 55);
175    static const uint8_t expected[] = "Mr. Ronald Reagan 33";
176    ASSERT (result != NULL);
177    ASSERT (u8_strcmp (result, expected) == 0);
178    free (result);
179  }
180
181  { /* Width.  */
182    uint8_t *result =
183      my_xasprintf ("Mr. %20s %d", "Ronald Reagan", 33, 44, 55);
184    static const uint8_t expected[] = "Mr.        Ronald Reagan 33";
185    ASSERT (result != NULL);
186    ASSERT (u8_strcmp (result, expected) == 0);
187    free (result);
188  }
189
190  { /* FLAG_LEFT.  */
191    uint8_t *result =
192      my_xasprintf ("Mr. %-20s %d", "Ronald Reagan", 33, 44, 55);
193    static const uint8_t expected[] = "Mr. Ronald Reagan        33";
194    ASSERT (result != NULL);
195    ASSERT (u8_strcmp (result, expected) == 0);
196    free (result);
197  }
198
199  { /* FLAG_ZERO: no effect.  */
200    uint8_t *result =
201      my_xasprintf ("Mr. %020s %d", "Ronald Reagan", 33, 44, 55);
202    static const uint8_t expected[] = "Mr.        Ronald Reagan 33";
203    ASSERT (result != NULL);
204    ASSERT (u8_strcmp (result, expected) == 0);
205    free (result);
206  }
207
208  /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
209     output of floating-point numbers.  */
210
211  { /* A positive number.  */
212    uint8_t *result =
213      my_xasprintf ("%a %d", 3.1416015625, 33, 44, 55);
214    static const uint8_t expected1[] = "0x1.922p+1 33";
215    static const uint8_t expected2[] = "0x3.244p+0 33";
216    static const uint8_t expected3[] = "0x6.488p-1 33";
217    static const uint8_t expected4[] = "0xc.91p-2 33";
218    ASSERT (result != NULL);
219    ASSERT (u8_strcmp (result, expected1) == 0
220            || u8_strcmp (result, expected2) == 0
221            || u8_strcmp (result, expected3) == 0
222            || u8_strcmp (result, expected4) == 0);
223    free (result);
224  }
225
226  { /* Width.  */
227    uint8_t *result =
228      my_xasprintf ("%10a %d", 1.75, 33, 44, 55);
229    static const uint8_t expected1[] = "  0x1.cp+0 33";
230    static const uint8_t expected2[] = "  0x3.8p-1 33";
231    static const uint8_t expected3[] = "    0x7p-2 33";
232    static const uint8_t expected4[] = "    0xep-3 33";
233    ASSERT (result != NULL);
234    ASSERT (u8_strcmp (result, expected1) == 0
235            || u8_strcmp (result, expected2) == 0
236            || u8_strcmp (result, expected3) == 0
237            || u8_strcmp (result, expected4) == 0);
238    free (result);
239  }
240
241  { /* Small precision.  */
242    uint8_t *result =
243      my_xasprintf ("%.10a %d", 1.75, 33, 44, 55);
244    static const uint8_t expected1[] = "0x1.c000000000p+0 33";
245    static const uint8_t expected2[] = "0x3.8000000000p-1 33";
246    static const uint8_t expected3[] = "0x7.0000000000p-2 33";
247    static const uint8_t expected4[] = "0xe.0000000000p-3 33";
248    ASSERT (result != NULL);
249    ASSERT (u8_strcmp (result, expected1) == 0
250            || u8_strcmp (result, expected2) == 0
251            || u8_strcmp (result, expected3) == 0
252            || u8_strcmp (result, expected4) == 0);
253    free (result);
254  }
255
256  { /* Large precision.  */
257    uint8_t *result =
258      my_xasprintf ("%.50a %d", 1.75, 33, 44, 55);
259    static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
260    static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
261    static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
262    static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
263    ASSERT (result != NULL);
264    ASSERT (u8_strcmp (result, expected1) == 0
265            || u8_strcmp (result, expected2) == 0
266            || u8_strcmp (result, expected3) == 0
267            || u8_strcmp (result, expected4) == 0);
268    free (result);
269  }
270
271  { /* A positive number.  */
272    uint8_t *result =
273      my_xasprintf ("%La %d", 3.1416015625L, 33, 44, 55);
274    static const uint8_t expected1[] = "0x1.922p+1 33";
275    static const uint8_t expected2[] = "0x3.244p+0 33";
276    static const uint8_t expected3[] = "0x6.488p-1 33";
277    static const uint8_t expected4[] = "0xc.91p-2 33";
278    ASSERT (result != NULL);
279    ASSERT (u8_strcmp (result, expected1) == 0
280            || u8_strcmp (result, expected2) == 0
281            || u8_strcmp (result, expected3) == 0
282            || u8_strcmp (result, expected4) == 0);
283    free (result);
284  }
285
286  { /* Width.  */
287    uint8_t *result =
288      my_xasprintf ("%10La %d", 1.75L, 33, 44, 55);
289    static const uint8_t expected1[] = "  0x1.cp+0 33";
290    static const uint8_t expected2[] = "  0x3.8p-1 33";
291    static const uint8_t expected3[] = "    0x7p-2 33";
292    static const uint8_t expected4[] = "    0xep-3 33";
293    ASSERT (result != NULL);
294    ASSERT (u8_strcmp (result, expected1) == 0
295            || u8_strcmp (result, expected2) == 0
296            || u8_strcmp (result, expected3) == 0
297            || u8_strcmp (result, expected4) == 0);
298    free (result);
299  }
300
301  { /* Small precision.  */
302    uint8_t *result =
303      my_xasprintf ("%.10La %d", 1.75L, 33, 44, 55);
304    static const uint8_t expected1[] = "0x1.c000000000p+0 33";
305    static const uint8_t expected2[] = "0x3.8000000000p-1 33";
306    static const uint8_t expected3[] = "0x7.0000000000p-2 33";
307    static const uint8_t expected4[] = "0xe.0000000000p-3 33";
308    ASSERT (result != NULL);
309    ASSERT (u8_strcmp (result, expected1) == 0
310            || u8_strcmp (result, expected2) == 0
311            || u8_strcmp (result, expected3) == 0
312            || u8_strcmp (result, expected4) == 0);
313    free (result);
314  }
315
316  { /* Large precision.  */
317    uint8_t *result =
318      my_xasprintf ("%.50La %d", 1.75L, 33, 44, 55);
319    static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
320    static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
321    static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
322    static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
323    ASSERT (result != NULL);
324    ASSERT (u8_strcmp (result, expected1) == 0
325            || u8_strcmp (result, expected2) == 0
326            || u8_strcmp (result, expected3) == 0
327            || u8_strcmp (result, expected4) == 0);
328    free (result);
329  }
330
331  /* Test the support of the %f format directive.  */
332
333  { /* A positive number.  */
334    uint8_t *result =
335      my_xasprintf ("%f %d", 12.75, 33, 44, 55);
336    static const uint8_t expected[] = "12.750000 33";
337    ASSERT (result != NULL);
338    ASSERT (u8_strcmp (result, expected) == 0);
339    free (result);
340  }
341
342  { /* Width.  */
343    uint8_t *result =
344      my_xasprintf ("%10f %d", 1.75, 33, 44, 55);
345    static const uint8_t expected[] = "  1.750000 33";
346    ASSERT (result != NULL);
347    ASSERT (u8_strcmp (result, expected) == 0);
348    free (result);
349  }
350
351  { /* Precision.  */
352    uint8_t *result =
353      my_xasprintf ("%.f %d", 1234.0, 33, 44, 55);
354    static const uint8_t expected[] = "1234 33";
355    ASSERT (result != NULL);
356    ASSERT (u8_strcmp (result, expected) == 0);
357    free (result);
358  }
359
360  { /* A positive number.  */
361    uint8_t *result =
362      my_xasprintf ("%Lf %d", 12.75L, 33, 44, 55);
363    static const uint8_t expected[] = "12.750000 33";
364    ASSERT (result != NULL);
365    ASSERT (u8_strcmp (result, expected) == 0);
366    free (result);
367  }
368
369  { /* Width.  */
370    uint8_t *result =
371      my_xasprintf ("%10Lf %d", 1.75L, 33, 44, 55);
372    static const uint8_t expected[] = "  1.750000 33";
373    ASSERT (result != NULL);
374    ASSERT (u8_strcmp (result, expected) == 0);
375    free (result);
376  }
377
378  { /* Precision.  */
379    uint8_t *result =
380      my_xasprintf ("%.Lf %d", 1234.0L, 33, 44, 55);
381    static const uint8_t expected[] = "1234 33";
382    ASSERT (result != NULL);
383    ASSERT (u8_strcmp (result, expected) == 0);
384    free (result);
385  }
386
387  /* Test the support of the %F format directive.  */
388
389  { /* A positive number.  */
390    uint8_t *result =
391      my_xasprintf ("%F %d", 12.75, 33, 44, 55);
392    static const uint8_t expected[] = "12.750000 33";
393    ASSERT (result != NULL);
394    ASSERT (u8_strcmp (result, expected) == 0);
395    free (result);
396  }
397
398  { /* Precision.  */
399    uint8_t *result =
400      my_xasprintf ("%.F %d", 1234.0, 33, 44, 55);
401    static const uint8_t expected[] = "1234 33";
402    ASSERT (result != NULL);
403    ASSERT (u8_strcmp (result, expected) == 0);
404    free (result);
405  }
406
407  { /* A positive number.  */
408    uint8_t *result =
409      my_xasprintf ("%LF %d", 12.75L, 33, 44, 55);
410    static const uint8_t expected[] = "12.750000 33";
411    ASSERT (result != NULL);
412    ASSERT (u8_strcmp (result, expected) == 0);
413    free (result);
414  }
415
416  { /* Precision.  */
417    uint8_t *result =
418      my_xasprintf ("%.LF %d", 1234.0L, 33, 44, 55);
419    static const uint8_t expected[] = "1234 33";
420    ASSERT (result != NULL);
421    ASSERT (u8_strcmp (result, expected) == 0);
422    free (result);
423  }
424
425  /* Test the support of the %e format directive.  */
426
427  { /* A positive number.  */
428    uint8_t *result =
429      my_xasprintf ("%e %d", 12.75, 33, 44, 55);
430    static const uint8_t expected1[] = "1.275000e+01 33";
431    static const uint8_t expected2[] = "1.275000e+001 33";
432    ASSERT (result != NULL);
433    ASSERT (u8_strcmp (result, expected1) == 0
434            || u8_strcmp (result, expected2) == 0);
435    free (result);
436  }
437
438  { /* Width.  */
439    uint8_t *result =
440      my_xasprintf ("%15e %d", 1.75, 33, 44, 55);
441    static const uint8_t expected1[] = "   1.750000e+00 33";
442    static const uint8_t expected2[] = "  1.750000e+000 33";
443    ASSERT (result != NULL);
444    ASSERT (u8_strcmp (result, expected1) == 0
445            || u8_strcmp (result, expected2) == 0);
446    free (result);
447  }
448
449  { /* Precision.  */
450    uint8_t *result =
451      my_xasprintf ("%.e %d", 1234.0, 33, 44, 55);
452    static const uint8_t expected1[] = "1e+03 33";
453    static const uint8_t expected2[] = "1e+003 33";
454    ASSERT (result != NULL);
455    ASSERT (u8_strcmp (result, expected1) == 0
456            || u8_strcmp (result, expected2) == 0);
457    free (result);
458  }
459
460  { /* A positive number.  */
461    uint8_t *result =
462      my_xasprintf ("%Le %d", 12.75L, 33, 44, 55);
463    static const uint8_t expected[] = "1.275000e+01 33";
464    ASSERT (result != NULL);
465    ASSERT (u8_strcmp (result, expected) == 0);
466    free (result);
467  }
468
469  { /* Width.  */
470    uint8_t *result =
471      my_xasprintf ("%15Le %d", 1.75L, 33, 44, 55);
472    static const uint8_t expected[] = "   1.750000e+00 33";
473    ASSERT (result != NULL);
474    ASSERT (u8_strcmp (result, expected) == 0);
475    free (result);
476  }
477
478  { /* Precision.  */
479    uint8_t *result =
480      my_xasprintf ("%.Le %d", 1234.0L, 33, 44, 55);
481    static const uint8_t expected[] = "1e+03 33";
482    ASSERT (result != NULL);
483    ASSERT (u8_strcmp (result, expected) == 0);
484    free (result);
485  }
486
487  /* Test the support of the %g format directive.  */
488
489  { /* A positive number.  */
490    uint8_t *result =
491      my_xasprintf ("%g %d", 12.75, 33, 44, 55);
492    static const uint8_t expected[] = "12.75 33";
493    ASSERT (result != NULL);
494    ASSERT (u8_strcmp (result, expected) == 0);
495    free (result);
496  }
497
498  { /* Width.  */
499    uint8_t *result =
500      my_xasprintf ("%10g %d", 1.75, 33, 44, 55);
501    static const uint8_t expected[] = "      1.75 33";
502    ASSERT (result != NULL);
503    ASSERT (u8_strcmp (result, expected) == 0);
504    free (result);
505  }
506
507  { /* Precision.  */
508    uint8_t *result =
509      my_xasprintf ("%.g %d", 1234.0, 33, 44, 55);
510    static const uint8_t expected1[] = "1e+03 33";
511    static const uint8_t expected2[] = "1e+003 33";
512    ASSERT (result != NULL);
513    ASSERT (u8_strcmp (result, expected1) == 0
514            || u8_strcmp (result, expected2) == 0);
515    free (result);
516  }
517
518  { /* A positive number.  */
519    uint8_t *result =
520      my_xasprintf ("%Lg %d", 12.75L, 33, 44, 55);
521    static const uint8_t expected[] = "12.75 33";
522    ASSERT (result != NULL);
523    ASSERT (u8_strcmp (result, expected) == 0);
524    free (result);
525  }
526
527  { /* Width.  */
528    uint8_t *result =
529      my_xasprintf ("%10Lg %d", 1.75L, 33, 44, 55);
530    static const uint8_t expected[] = "      1.75 33";
531    ASSERT (result != NULL);
532    ASSERT (u8_strcmp (result, expected) == 0);
533    free (result);
534  }
535
536  { /* Precision.  */
537    uint8_t *result =
538      my_xasprintf ("%.Lg %d", 1234.0L, 33, 44, 55);
539    static const uint8_t expected[] = "1e+03 33";
540    ASSERT (result != NULL);
541    ASSERT (u8_strcmp (result, expected) == 0);
542    free (result);
543  }
544
545  /* Test the support of the %n format directive.  */
546
547  {
548    int count = -1;
549    uint8_t *result =
550      my_xasprintf ("%d %n", 123, &count, 33, 44, 55);
551    static const uint8_t expected[] = "123 ";
552    ASSERT (result != NULL);
553    ASSERT (u8_strcmp (result, expected) == 0);
554    ASSERT (count == 4);
555    free (result);
556  }
557
558  /* Test the support of the POSIX/XSI format strings with positions.  */
559
560  {
561    uint8_t *result =
562      my_xasprintf ("%2$d %1$d", 33, 55);
563    static const uint8_t expected[] = "55 33";
564    ASSERT (result != NULL);
565    ASSERT (u8_strcmp (result, expected) == 0);
566    free (result);
567  }
568
569  /* Test the support of the grouping flag.  */
570
571  {
572    uint8_t *result =
573      my_xasprintf ("%'d %d", 1234567, 99);
574    ASSERT (result != NULL);
575    ASSERT (result[u8_strlen (result) - 1] == '9');
576    free (result);
577  }
578
579  /* Test the support of the 'U' conversion specifier for Unicode strings.  */
580
581  {
582    static const uint8_t unicode_string[] = "Rafa\305\202 Maszkowski"; /* Rafa�� Maszkowski */
583    {
584      uint8_t *result =
585        my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
586      static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
587      ASSERT (result != NULL);
588      ASSERT (u8_strcmp (result, expected) == 0);
589      free (result);
590    }
591    { /* Width.  */
592      uint8_t *result =
593        my_xasprintf ("%20U %d", unicode_string, 33, 44, 55);
594      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
595      ASSERT (result != NULL);
596      ASSERT (u8_strcmp (result, expected) == 0);
597      free (result);
598    }
599    { /* FLAG_LEFT.  */
600      uint8_t *result =
601        my_xasprintf ("%-20U %d", unicode_string, 33, 44, 55);
602      static const uint8_t expected[] = "Rafa\305\202 Maszkowski     33";
603      ASSERT (result != NULL);
604      ASSERT (u8_strcmp (result, expected) == 0);
605      free (result);
606    }
607    { /* FLAG_ZERO: no effect.  */
608      uint8_t *result =
609        my_xasprintf ("%020U %d", unicode_string, 33, 44, 55);
610      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
611      ASSERT (result != NULL);
612      ASSERT (u8_strcmp (result, expected) == 0);
613      free (result);
614    }
615  }
616
617  {
618    static const uint16_t unicode_string[] = /* Rafa�� Maszkowski */
619      {
620        'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
621        's', 'k', 'i', 0
622      };
623    {
624      uint8_t *result =
625        my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
626      static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
627      ASSERT (result != NULL);
628      ASSERT (u8_strcmp (result, expected) == 0);
629      free (result);
630    }
631    { /* Width.  */
632      uint8_t *result =
633        my_xasprintf ("%20lU %d", unicode_string, 33, 44, 55);
634      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
635      ASSERT (result != NULL);
636      ASSERT (u8_strcmp (result, expected) == 0);
637      free (result);
638    }
639    { /* FLAG_LEFT.  */
640      uint8_t *result =
641        my_xasprintf ("%-20lU %d", unicode_string, 33, 44, 55);
642      static const uint8_t expected[] = "Rafa\305\202 Maszkowski     33";
643      ASSERT (result != NULL);
644      ASSERT (u8_strcmp (result, expected) == 0);
645      free (result);
646    }
647    { /* FLAG_ZERO: no effect.  */
648      uint8_t *result =
649        my_xasprintf ("%020lU %d", unicode_string, 33, 44, 55);
650      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
651      ASSERT (result != NULL);
652      ASSERT (u8_strcmp (result, expected) == 0);
653      free (result);
654    }
655  }
656
657  {
658    static const uint32_t unicode_string[] = /* Rafa�� Maszkowski */
659      {
660        'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
661        's', 'k', 'i', 0
662      };
663    {
664      uint8_t *result =
665        my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
666      static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
667      ASSERT (result != NULL);
668      ASSERT (u8_strcmp (result, expected) == 0);
669      free (result);
670    }
671    { /* Width.  */
672      uint8_t *result =
673        my_xasprintf ("%20llU %d", unicode_string, 33, 44, 55);
674      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
675      ASSERT (result != NULL);
676      ASSERT (u8_strcmp (result, expected) == 0);
677      free (result);
678    }
679    { /* FLAG_LEFT.  */
680      uint8_t *result =
681        my_xasprintf ("%-20llU %d", unicode_string, 33, 44, 55);
682      static const uint8_t expected[] = "Rafa\305\202 Maszkowski     33";
683      ASSERT (result != NULL);
684      ASSERT (u8_strcmp (result, expected) == 0);
685      free (result);
686    }
687    { /* FLAG_ZERO: no effect.  */
688      uint8_t *result =
689        my_xasprintf ("%020llU %d", unicode_string, 33, 44, 55);
690      static const uint8_t expected[] = "    Rafa\305\202 Maszkowski 33";
691      ASSERT (result != NULL);
692      ASSERT (u8_strcmp (result, expected) == 0);
693      free (result);
694    }
695  }
696
697  /* Test non-ASCII characters in the format string.  */
698
699  {
700    uint8_t *result =
701      my_xasprintf ("\304rger", 33, 44, 55);
702    ASSERT (result == NULL && errno == EINVAL);
703  }
704}
705