This source file includes following definitions.
- test_xfunction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 static void
20 test_xfunction (uint8_t * (*my_xasprintf) (const char *, ...))
21 {
22
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
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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
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 {
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 {
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 {
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
209
210
211 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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
332
333 {
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 {
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 {
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 {
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 {
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 {
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
388
389 {
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 {
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 {
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 {
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
426
427 {
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 {
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 {
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 {
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 {
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 {
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
488
489 {
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 {
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 {
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 {
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 {
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 {
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
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
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
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
580
581 {
582 static const uint8_t unicode_string[] = "Rafa\305\202 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 {
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 {
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 {
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[] =
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 {
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 {
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 {
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[] =
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 {
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 {
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 {
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
698
699 {
700 uint8_t *result =
701 my_xasprintf ("\304rger", 33, 44, 55);
702 ASSERT (result == NULL && errno == EINVAL);
703 }
704 }