nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* Unit tests for gprintf
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * This work is provided "as is"; redistribution and modification
5 * in whole or in part, in any medium, physical or electronic is
6 * permitted without restriction.
7 *
8 * This work is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * In no event shall the authors or contributors be liable for any
13 * direct, indirect, incidental, special, exemplary, or consequential
14 * damages (including, but not limited to, procurement of substitute
15 * goods or services; loss of use, data, or profits; or business
16 * interruption) however caused and on any theory of liability, whether
17 * in contract, strict liability, or tort (including negligence or
18 * otherwise) arising in any way out of the use of this software, even
19 * if advised of the possibility of such damage.
20 */
21  
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include "glib.h"
26 #include "gstdio.h"
27  
28 static void
29 test_retval_and_trunc (void)
30 {
31 gchar buf[128];
32 gint res;
33  
34 res = g_snprintf (buf, 0, "abc");
35 g_assert_cmpint (res, ==, 3);
36  
37 res = g_snprintf (NULL, 0, "abc");
38 g_assert_cmpint (res, ==, 3);
39  
40 res = g_snprintf (buf, 5, "abc");
41 g_assert_cmpint (res, ==, 3);
42  
43 res = g_snprintf (buf, 1, "abc");
44 g_assert_cmpint (res, ==, 3);
45 g_assert (buf[0] == '\0');
46 g_assert_cmpstr (buf, ==, "");
47  
48 res = g_snprintf (buf, 2, "abc");
49 g_assert_cmpint (res, ==, 3);
50 g_assert (buf[1] == '\0');
51 g_assert_cmpstr (buf, ==, "a");
52  
53 res = g_snprintf (buf, 3, "abc");
54 g_assert_cmpint (res, ==, 3);
55 g_assert (buf[2] == '\0');
56 g_assert_cmpstr (buf, ==, "ab");
57  
58 res = g_snprintf (buf, 4, "abc");
59 g_assert_cmpint (res, ==, 3);
60 g_assert (buf[3] == '\0');
61 g_assert_cmpstr (buf, ==, "abc");
62  
63 res = g_snprintf (buf, 5, "abc");
64 g_assert_cmpint (res, ==, 3);
65 g_assert (buf[3] == '\0');
66 g_assert_cmpstr (buf, ==, "abc");
67 }
68  
69 static void
70 test_d (void)
71 {
72 gchar buf[128];
73 gint res;
74  
75 /* %d basic formatting */
76  
77 res = g_snprintf (buf, 128, "%d", 5);
78 g_assert_cmpint (res, ==, 1);
79 g_assert_cmpstr (buf, ==, "5");
80  
81 res = g_snprintf (buf, 128, "%d", 0);
82 g_assert_cmpint (res, ==, 1);
83 g_assert_cmpstr (buf, ==, "0");
84  
85 res = g_snprintf (buf, 128, "%.0d", 0);
86 g_assert_cmpint (res, ==, 0);
87 g_assert_cmpstr (buf, ==, "");
88  
89 res = g_snprintf (buf, 128, "%.0d", 1);
90 g_assert_cmpint (res, ==, 1);
91 g_assert_cmpstr (buf, ==, "1");
92  
93 res = g_snprintf (buf, 128, "%.d", 2);
94 g_assert_cmpint (res, ==, 1);
95 g_assert_cmpstr (buf, ==, "2");
96  
97 res = g_snprintf (buf, 128, "%d", -1);
98 g_assert_cmpint (res, ==, 2);
99 g_assert_cmpstr (buf, ==, "-1");
100  
101 res = g_snprintf (buf, 128, "%.3d", 5);
102 g_assert_cmpint (res, ==, 3);
103 g_assert_cmpstr (buf, ==, "005");
104  
105 res = g_snprintf (buf, 128, "%.3d", -5);
106 g_assert_cmpint (res, ==, 4);
107 g_assert_cmpstr (buf, ==, "-005");
108  
109 res = g_snprintf (buf, 128, "%5.3d", 5);
110 g_assert_cmpint (res, ==, 5);
111 g_assert_cmpstr (buf, ==, " 005");
112  
113 res = g_snprintf (buf, 128, "%-5.3d", -5);
114 g_assert_cmpint (res, ==, 5);
115 g_assert_cmpstr (buf, ==, "-005 ");
116  
117 /* %d, length modifiers */
118  
119 res = g_snprintf (buf, 128, "%" G_GINT16_FORMAT, (gint16)-5);
120 g_assert_cmpint (res, ==, 2);
121 g_assert_cmpstr (buf, ==, "-5");
122  
123 res = g_snprintf (buf, 128, "%" G_GUINT16_FORMAT, (guint16)5);
124 g_assert_cmpint (res, ==, 1);
125 g_assert_cmpstr (buf, ==, "5");
126  
127 res = g_snprintf (buf, 128, "%" G_GINT32_FORMAT, (gint32)-5);
128 g_assert_cmpint (res, ==, 2);
129 g_assert_cmpstr (buf, ==, "-5");
130  
131 res = g_snprintf (buf, 128, "%" G_GUINT32_FORMAT, (guint32)5);
132 g_assert_cmpint (res, ==, 1);
133 g_assert_cmpstr (buf, ==, "5");
134  
135 res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)-5);
136 g_assert_cmpint (res, ==, 2);
137 g_assert_cmpstr (buf, ==, "-5");
138  
139 res = g_snprintf (buf, 128, "%" G_GUINT64_FORMAT, (guint64)5);
140 g_assert_cmpint (res, ==, 1);
141 g_assert_cmpstr (buf, ==, "5");
142  
143 res = g_snprintf (buf, 128, "%" G_GSSIZE_FORMAT, (gssize)-5);
144 g_assert_cmpint (res, ==, 2);
145 g_assert_cmpstr (buf, ==, "-5");
146  
147 res = g_snprintf (buf, 128, "%" G_GSIZE_FORMAT, (gsize)5);
148 g_assert_cmpint (res, ==, 1);
149 g_assert_cmpstr (buf, ==, "5");
150  
151 /* %d, flags */
152  
153 res = g_snprintf (buf, 128, "%-d", 5);
154 g_assert_cmpint (res, ==, 1);
155 g_assert_cmpstr (buf, ==, "5");
156  
157 res = g_snprintf (buf, 128, "%-+d", 5);
158 g_assert_cmpint (res, ==, 2);
159 g_assert_cmpstr (buf, ==, "+5");
160  
161 res = g_snprintf (buf, 128, "%+-d", 5);
162 g_assert_cmpint (res, ==, 2);
163 g_assert_cmpstr (buf, ==, "+5");
164  
165 res = g_snprintf (buf, 128, "%+d", -5);
166 g_assert_cmpint (res, ==, 2);
167 g_assert_cmpstr (buf, ==, "-5");
168  
169 res = g_snprintf (buf, 128, "% d", 5);
170 g_assert_cmpint (res, ==, 2);
171 g_assert_cmpstr (buf, ==, " 5");
172  
173 res = g_snprintf (buf, 128, "% .0d", 0);
174 g_assert_cmpint (res, ==, 1);
175 g_assert_cmpstr (buf, ==, " ");
176  
177 res = g_snprintf (buf, 128, "%03d", 5);
178 g_assert_cmpint (res, ==, 3);
179 g_assert_cmpstr (buf, ==, "005");
180  
181 res = g_snprintf (buf, 128, "%03d", -5);
182 g_assert_cmpint (res, ==, 3);
183 g_assert_cmpstr (buf, ==, "-05");
184 }
185  
186 /* gcc emits warnings for the following formats, since the C spec
187 * says some of the flags must be ignored. (The " " in "% +d" and
188 * the "0" in "%-03d".) But we need to test that our printf gets
189 * those rules right. So we fool gcc into not warning.
190 *
191 * These have to be in a separate function in order to use #pragma.
192 */
193 #pragma GCC diagnostic push
194 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
195 static void
196 test_d_invalid (void)
197 {
198 const gchar *fmt;
199 gchar buf[128];
200 gint res;
201  
202 fmt = "% +d";
203 res = g_snprintf (buf, 128, fmt, 5);
204 g_assert_cmpint (res, ==, 2);
205 g_assert_cmpstr (buf, ==, "+5");
206  
207 fmt = "%-03d";
208 res = g_snprintf (buf, 128, fmt, -5);
209 g_assert_cmpint (res, ==, 3);
210 g_assert_cmpstr (buf, ==, "-5 ");
211 }
212 #pragma GCC diagnostic pop
213  
214 static void
215 test_o (void)
216 {
217 gchar buf[128];
218 gint res;
219  
220 /* %o basic formatting */
221  
222 res = g_snprintf (buf, 128, "%o", 5);
223 g_assert_cmpint (res, ==, 1);
224 g_assert_cmpstr (buf, ==, "5");
225  
226 res = g_snprintf (buf, 128, "%o", 8);
227 g_assert_cmpint (res, ==, 2);
228 g_assert_cmpstr (buf, ==, "10");
229  
230 res = g_snprintf (buf, 128, "%o", 0);
231 g_assert_cmpint (res, ==, 1);
232 g_assert_cmpstr (buf, ==, "0");
233  
234 res = g_snprintf (buf, 128, "%.0o", 0);
235 g_assert_cmpint (res, ==, 0);
236 g_assert_cmpstr (buf, ==, "");
237  
238 res = g_snprintf (buf, 128, "%.0o", 1);
239 g_assert_cmpint (res, ==, 1);
240 g_assert_cmpstr (buf, ==, "1");
241  
242 res = g_snprintf (buf, 128, "%.3o", 5);
243 g_assert_cmpint (res, ==, 3);
244 g_assert_cmpstr (buf, ==, "005");
245  
246 res = g_snprintf (buf, 128, "%.3o", 8);
247 g_assert_cmpint (res, ==, 3);
248 g_assert_cmpstr (buf, ==, "010");
249  
250 res = g_snprintf (buf, 128, "%5.3o", 5);
251 g_assert_cmpint (res, ==, 5);
252 g_assert_cmpstr (buf, ==, " 005");
253 }
254  
255 static void
256 test_u (void)
257 {
258 gchar buf[128];
259 gint res;
260  
261 /* %u, basic formatting */
262  
263 res = g_snprintf (buf, 128, "%u", 5);
264 g_assert_cmpint (res, ==, 1);
265 g_assert_cmpstr (buf, ==, "5");
266  
267 res = g_snprintf (buf, 128, "%u", 0);
268 g_assert_cmpint (res, ==, 1);
269 g_assert_cmpstr (buf, ==, "0");
270  
271 res = g_snprintf (buf, 128, "%.0u", 0);
272 g_assert_cmpint (res, ==, 0);
273 g_assert_cmpstr (buf, ==, "");
274  
275 res = g_snprintf (buf, 128, "%.0u", 1);
276 g_assert_cmpint (res, ==, 1);
277 g_assert_cmpstr (buf, ==, "1");
278  
279 res = g_snprintf (buf, 128, "%.3u", 5);
280 g_assert_cmpint (res, ==, 3);
281 g_assert_cmpstr (buf, ==, "005");
282  
283 res = g_snprintf (buf, 128, "%5.3u", 5);
284 g_assert_cmpint (res, ==, 5);
285 g_assert_cmpstr (buf, ==, " 005");
286 }
287  
288 static void
289 test_x (void)
290 {
291 gchar buf[128];
292 gint res;
293  
294 /* %x, basic formatting */
295  
296 res = g_snprintf (buf, 128, "%x", 5);
297 g_assert_cmpint (res, ==, 1);
298 g_assert_cmpstr (buf, ==, "5");
299  
300 res = g_snprintf (buf, 128, "%x", 31);
301 g_assert_cmpint (res, ==, 2);
302 g_assert_cmpstr (buf, ==, "1f");
303  
304 res = g_snprintf (buf, 128, "%x", 0);
305 g_assert_cmpint (res, ==, 1);
306 g_assert_cmpstr (buf, ==, "0");
307  
308 res = g_snprintf (buf, 128, "%.0x", 0);
309 g_assert_cmpint (res, ==, 0);
310 g_assert_cmpstr (buf, ==, "");
311  
312 res = g_snprintf (buf, 128, "%.0x", 1);
313 g_assert_cmpint (res, ==, 1);
314 g_assert_cmpstr (buf, ==, "1");
315  
316 res = g_snprintf (buf, 128, "%.3x", 5);
317 g_assert_cmpint (res, ==, 3);
318 g_assert_cmpstr (buf, ==, "005");
319  
320 res = g_snprintf (buf, 128, "%.3x", 31);
321 g_assert_cmpint (res, ==, 3);
322 g_assert_cmpstr (buf, ==, "01f");
323  
324 res = g_snprintf (buf, 128, "%5.3x", 5);
325 g_assert_cmpint (res, ==, 5);
326 g_assert_cmpstr (buf, ==, " 005");
327  
328 /* %x, flags */
329  
330 res = g_snprintf (buf, 128, "%-x", 5);
331 g_assert_cmpint (res, ==, 1);
332 g_assert_cmpstr (buf, ==, "5");
333  
334 res = g_snprintf (buf, 128, "%03x", 5);
335 g_assert_cmpint (res, ==, 3);
336 g_assert_cmpstr (buf, ==, "005");
337  
338 res = g_snprintf (buf, 128, "%#x", 31);
339 g_assert_cmpint (res, ==, 4);
340 g_assert_cmpstr (buf, ==, "0x1f");
341  
342 res = g_snprintf (buf, 128, "%#x", 0);
343 g_assert_cmpint (res, ==, 1);
344 g_assert_cmpstr (buf, ==, "0");
345 }
346  
347 static void
348 test_X (void)
349 {
350 gchar buf[128];
351 gint res;
352  
353 /* %X, basic formatting */
354  
355 res = g_snprintf (buf, 128, "%X", 5);
356 g_assert_cmpint (res, ==, 1);
357 g_assert_cmpstr (buf, ==, "5");
358  
359 res = g_snprintf (buf, 128, "%X", 31);
360 g_assert_cmpint (res, ==, 2);
361 g_assert_cmpstr (buf, ==, "1F");
362  
363 res = g_snprintf (buf, 128, "%X", 0);
364 g_assert_cmpint (res, ==, 1);
365 g_assert_cmpstr (buf, ==, "0");
366  
367 res = g_snprintf (buf, 128, "%.0X", 0);
368 g_assert_cmpint (res, ==, 0);
369 g_assert_cmpstr (buf, ==, "");
370  
371 res = g_snprintf (buf, 128, "%.0X", 1);
372 g_assert_cmpint (res, ==, 1);
373 g_assert_cmpstr (buf, ==, "1");
374  
375 res = g_snprintf (buf, 128, "%.3X", 5);
376 g_assert_cmpint (res, ==, 3);
377 g_assert_cmpstr (buf, ==, "005");
378  
379 res = g_snprintf (buf, 128, "%.3X", 31);
380 g_assert_cmpint (res, ==, 3);
381 g_assert_cmpstr (buf, ==, "01F");
382  
383 res = g_snprintf (buf, 128, "%5.3X", 5);
384 g_assert_cmpint (res, ==, 5);
385 g_assert_cmpstr (buf, ==, " 005");
386  
387 /* %X, flags */
388  
389 res = g_snprintf (buf, 128, "%-X", 5);
390 g_assert_cmpint (res, ==, 1);
391 g_assert_cmpstr (buf, ==, "5");
392  
393 res = g_snprintf (buf, 128, "%03X", 5);
394 g_assert_cmpint (res, ==, 3);
395 g_assert_cmpstr (buf, ==, "005");
396  
397 res = g_snprintf (buf, 128, "%#X", 31);
398 g_assert_cmpint (res, ==, 4);
399 g_assert_cmpstr (buf, ==, "0X1F");
400  
401 res = g_snprintf (buf, 128, "%#X", 0);
402 g_assert_cmpint (res, ==, 1);
403 g_assert_cmpstr (buf, ==, "0");
404 }
405  
406 static void
407 test_f (void)
408 {
409 gchar buf[128];
410 gint res;
411  
412 /* %f, basic formattting */
413  
414 res = g_snprintf (buf, 128, "%f", G_PI);
415 g_assert_cmpint (res, ==, 8);
416 g_assert (0 == strncmp (buf, "3.14159", 7));
417  
418 res = g_snprintf (buf, 128, "%.8f", G_PI);
419 g_assert_cmpint (res, ==, 10);
420 g_assert (0 == strncmp (buf, "3.1415926", 9));
421  
422 res = g_snprintf (buf, 128, "%.0f", G_PI);
423 g_assert_cmpint (res, ==, 1);
424 g_assert_cmpstr (buf, ==, "3");
425  
426 res = g_snprintf (buf, 128, "%1.f", G_PI);
427 g_assert_cmpint (res, ==, 1);
428 g_assert_cmpstr (buf, ==, "3");
429  
430 res = g_snprintf (buf, 128, "%3.f", G_PI);
431 g_assert_cmpint (res, ==, 3);
432 g_assert_cmpstr (buf, ==, " 3");
433  
434 /* %f, flags */
435  
436 res = g_snprintf (buf, 128, "%+f", G_PI);
437 g_assert_cmpint (res, ==, 9);
438 g_assert (0 == strncmp (buf, "+3.14159", 8));
439  
440 res = g_snprintf (buf, 128, "% f", G_PI);
441 g_assert_cmpint (res, ==, 9);
442 g_assert (0 == strncmp (buf, " 3.14159", 8));
443  
444 res = g_snprintf (buf, 128, "%#.0f", G_PI);
445 g_assert_cmpint (res, ==, 2);
446 g_assert_cmpstr (buf, ==, "3.");
447  
448 res = g_snprintf (buf, 128, "%05.2f", G_PI);
449 g_assert_cmpint (res, ==, 5);
450 g_assert_cmpstr (buf, ==, "03.14");
451 }
452  
453 static gboolean
454 same_value (const gchar *actual,
455 const gchar *expected)
456 {
457 gdouble actual_value, expected_value;
458  
459 actual_value = g_ascii_strtod (actual, NULL);
460 expected_value = g_ascii_strtod (expected, NULL);
461  
462 return actual_value == expected_value;
463 }
464  
465 static void
466 test_e (void)
467 {
468 gchar buf[128];
469 gint res;
470  
471 /* %e, basic formatting */
472 /* for %e we can't expect to reproduce exact strings and lengths, since SUS
473 * only guarantees that the exponent shall always contain at least two
474 * digits. On Windows, it seems to be at least three digits long.
475 * Therefore, we compare the results of parsing the expected result and the
476 * actual result.
477 */
478  
479 res = g_snprintf (buf, 128, "%e", G_PI);
480 g_assert_cmpint (res, >=, 12);
481 g_assert (same_value (buf, "3.141593e+00"));
482  
483 res = g_snprintf (buf, 128, "%.8e", G_PI);
484 g_assert_cmpint (res, >=, 14);
485 g_assert (same_value (buf, "3.14159265e+00"));
486  
487 res = g_snprintf (buf, 128, "%.0e", G_PI);
488 g_assert_cmpint (res, >=, 5);
489 g_assert (same_value (buf, "3e+00"));
490  
491 res = g_snprintf (buf, 128, "%.1e", 0.0);
492 g_assert_cmpint (res, >=, 7);
493 g_assert (same_value (buf, "0.0e+00"));
494  
495 res = g_snprintf (buf, 128, "%.1e", 0.00001);
496 g_assert_cmpint (res, >=, 7);
497 g_assert (same_value (buf, "1.0e-05"));
498  
499 res = g_snprintf (buf, 128, "%.1e", 10000.0);
500 g_assert_cmpint (res, >=, 7);
501 g_assert (same_value (buf, "1.0e+04"));
502  
503 /* %e, flags */
504  
505 res = g_snprintf (buf, 128, "%+e", G_PI);
506 g_assert_cmpint (res, >=, 13);
507 g_assert (same_value (buf, "+3.141593e+00"));
508  
509 res = g_snprintf (buf, 128, "% e", G_PI);
510 g_assert_cmpint (res, >=, 13);
511 g_assert (same_value (buf, " 3.141593e+00"));
512  
513 res = g_snprintf (buf, 128, "%#.0e", G_PI);
514 g_assert_cmpint (res, >=, 6);
515 g_assert (same_value (buf, "3.e+00"));
516  
517 res = g_snprintf (buf, 128, "%09.2e", G_PI);
518 g_assert_cmpint (res, >=, 9);
519 g_assert (same_value (buf, "03.14e+00"));
520 }
521  
522 static void
523 test_c (void)
524 {
525 gchar buf[128];
526 gint res;
527  
528 res = g_snprintf (buf, 128, "%c", 'a');
529 g_assert_cmpint (res, ==, 1);
530 g_assert_cmpstr (buf, ==, "a");
531 }
532  
533 static void
534 test_s (void)
535 {
536 gchar buf[128];
537 gint res;
538  
539 res = g_snprintf (buf, 128, "%.2s", "abc");
540 g_assert_cmpint (res, ==, 2);
541 g_assert_cmpstr (buf, ==, "ab");
542  
543 res = g_snprintf (buf, 128, "%.6s", "abc");
544 g_assert_cmpint (res, ==, 3);
545 g_assert_cmpstr (buf, ==, "abc");
546  
547 res = g_snprintf (buf, 128, "%5s", "abc");
548 g_assert_cmpint (res, ==, 5);
549 g_assert_cmpstr (buf, ==, " abc");
550  
551 res = g_snprintf (buf, 128, "%-5s", "abc");
552 g_assert_cmpint (res, ==, 5);
553 g_assert_cmpstr (buf, ==, "abc ");
554  
555 res = g_snprintf (buf, 128, "%5.2s", "abc");
556 g_assert_cmpint (res, ==, 5);
557 g_assert_cmpstr (buf, ==, " ab");
558  
559 res = g_snprintf (buf, 128, "%*s", 5, "abc");
560 g_assert_cmpint (res, ==, 5);
561 g_assert_cmpstr (buf, ==, " abc");
562  
563 res = g_snprintf (buf, 128, "%*s", -5, "abc");
564 g_assert_cmpint (res, ==, 5);
565 g_assert_cmpstr (buf, ==, "abc ");
566  
567 res = g_snprintf (buf, 128, "%*.*s", 5, 2, "abc");
568 g_assert_cmpint (res, ==, 5);
569 g_assert_cmpstr (buf, ==, " ab");
570 }
571  
572 static void
573 test_n (void)
574 {
575 gchar buf[128];
576 gint res;
577 gint i;
578 glong l;
579  
580 res = g_snprintf (buf, 128, "abc%n", &i);
581 g_assert_cmpint (res, ==, 3);
582 g_assert_cmpstr (buf, ==, "abc");
583 g_assert_cmpint (i, ==, 3);
584  
585 res = g_snprintf (buf, 128, "abc%ln", &l);
586 g_assert_cmpint (res, ==, 3);
587 g_assert_cmpstr (buf, ==, "abc");
588 g_assert_cmpint (l, ==, 3);
589 }
590  
591 static void
592 test_percent (void)
593 {
594 gchar buf[128];
595 gint res;
596  
597 res = g_snprintf (buf, 128, "%%");
598 g_assert_cmpint (res, ==, 1);
599 g_assert_cmpstr (buf, ==, "%");
600 }
601  
602 static void
603 test_positional_params (void)
604 {
605 gchar buf[128];
606 gint res;
607  
608 res = g_snprintf (buf, 128, "%2$c %1$c", 'b', 'a');
609 g_assert_cmpint (res, ==, 3);
610 g_assert_cmpstr (buf, ==, "a b");
611  
612 res = g_snprintf (buf, 128, "%1$*2$.*3$s", "abc", 5, 2);
613 g_assert_cmpint (res, ==, 5);
614 g_assert_cmpstr (buf, ==, " ab");
615  
616 res = g_snprintf (buf, 128, "%1$s%1$s", "abc");
617 g_assert_cmpint (res, ==, 6);
618 g_assert_cmpstr (buf, ==, "abcabc");
619 }
620  
621 static void
622 test_positional_params2 (void)
623 {
624 if (g_test_subprocess ())
625 {
626 gint res;
627  
628 res = g_printf ("%2$c %1$c\n", 'b', 'a');
629 g_assert_cmpint (res, ==, 4);
630  
631 res = g_printf ("%1$*2$.*3$s\n", "abc", 5, 2);
632 g_assert_cmpint (res, ==, 6);
633  
634 res = g_printf ("%1$s%1$s\n", "abc");
635 g_assert_cmpint (res, ==, 7);
636 return;
637 }
638 g_test_trap_subprocess (NULL, 0, 0);
639 g_test_trap_assert_passed ();
640 #ifndef G_OS_WIN32
641 g_test_trap_assert_stdout ("a b\n ab\nabcabc\n");
642 #else
643 g_test_trap_assert_stdout ("a b\r\n ab\r\nabcabc\r\n");
644 #endif
645 }
646  
647 static void
648 test_positional_params3 (void)
649 {
650 gchar buf[128];
651 gint res;
652  
653 res = g_sprintf (buf, "%2$c %1$c", 'b', 'a');
654 g_assert_cmpint (res, ==, 3);
655 g_assert_cmpstr (buf, ==, "a b");
656  
657 res = g_sprintf (buf, "%1$*2$.*3$s", "abc", 5, 2);
658 g_assert_cmpint (res, ==, 5);
659 g_assert_cmpstr (buf, ==, " ab");
660  
661 res = g_sprintf (buf, "%1$s%1$s", "abc");
662 g_assert_cmpint (res, ==, 6);
663 g_assert_cmpstr (buf, ==, "abcabc");
664 }
665  
666 static void
667 test_percent2 (void)
668 {
669 if (g_test_subprocess ())
670 {
671 gint res;
672  
673 res = g_printf ("%%");
674 g_assert_cmpint (res, ==, 1);
675 return;
676 }
677 g_test_trap_subprocess (NULL, 0, 0);
678 g_test_trap_assert_passed ();
679 g_test_trap_assert_stdout ("*%*");
680 }
681  
682 static void
683 test_64bit (void)
684 {
685 gchar buf[128];
686 gint res;
687  
688 res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)123456);
689 g_assert_cmpint (res, ==, 6);
690 g_assert_cmpstr (buf, ==, "123456");
691  
692 res = g_snprintf (buf, 128, "%" G_GINT64_FORMAT, (gint64)-123456);
693 g_assert_cmpint (res, ==, 7);
694 g_assert_cmpstr (buf, ==, "-123456");
695  
696 res = g_snprintf (buf, 128, "%" G_GUINT64_FORMAT, (guint64)123456);
697 g_assert_cmpint (res, ==, 6);
698 g_assert_cmpstr (buf, ==, "123456");
699  
700 res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "o", (gint64)123456);
701 g_assert_cmpint (res, ==, 6);
702 g_assert_cmpstr (buf, ==, "361100");
703  
704 res = g_snprintf (buf, 128, "%#" G_GINT64_MODIFIER "o", (gint64)123456);
705 g_assert_cmpint (res, ==, 7);
706 g_assert_cmpstr (buf, ==, "0361100");
707  
708 res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "x", (gint64)123456);
709 g_assert_cmpint (res, ==, 5);
710 g_assert_cmpstr (buf, ==, "1e240");
711  
712 res = g_snprintf (buf, 128, "%#" G_GINT64_MODIFIER "x", (gint64)123456);
713 g_assert_cmpint (res, ==, 7);
714 g_assert_cmpstr (buf, ==, "0x1e240");
715  
716 res = g_snprintf (buf, 128, "%" G_GINT64_MODIFIER "X", (gint64)123456);
717 g_assert_cmpint (res, ==, 5);
718 g_assert_cmpstr (buf, ==, "1E240");
719  
720 #ifdef G_OS_WIN32
721 /* On Win32, test that the "ll" modifier also works, for backward
722 * compatibility. One really should use the G_GINT64_MODIFIER (which
723 * on Win32 is the "I64" that the (msvcrt) C library's printf uses),
724 * but "ll" used to work with the "trio" g_printf implementation in
725 * GLib 2.2, so it's best if it continues to work.
726 */
727  
728 /* However, gcc doesn't know about this, so we need to disable printf
729 * format warnings...
730 */
731 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
732 _Pragma ("GCC diagnostic push")
733 _Pragma ("GCC diagnostic ignored \"-Wformat\"")
734 _Pragma ("GCC diagnostic ignored \"-Wformat-extra-args\"")
735 #endif
736  
737 res = g_snprintf (buf, 128, "%" "lli", (gint64)123456);
738 g_assert_cmpint (res, ==, 6);
739 g_assert_cmpstr (buf, ==, "123456");
740  
741 res = g_snprintf (buf, 128, "%" "lli", (gint64)-123456);
742 g_assert_cmpint (res, ==, 7);
743 g_assert_cmpstr (buf, ==, "-123456");
744  
745 res = g_snprintf (buf, 128, "%" "llu", (guint64)123456);
746 g_assert_cmpint (res, ==, 6);
747 g_assert_cmpstr (buf, ==, "123456");
748  
749 res = g_snprintf (buf, 128, "%" "ll" "o", (gint64)123456);
750 g_assert_cmpint (res, ==, 6);
751 g_assert_cmpstr (buf, ==, "361100");
752  
753 res = g_snprintf (buf, 128, "%#" "ll" "o", (gint64)123456);
754 g_assert_cmpint (res, ==, 7);
755 g_assert_cmpstr (buf, ==, "0361100");
756  
757 res = g_snprintf (buf, 128, "%" "ll" "x", (gint64)123456);
758 g_assert_cmpint (res, ==, 5);
759 g_assert_cmpstr (buf, ==, "1e240");
760  
761 res = g_snprintf (buf, 128, "%#" "ll" "x", (gint64)123456);
762 g_assert_cmpint (res, ==, 7);
763 g_assert_cmpstr (buf, ==, "0x1e240");
764  
765 res = g_snprintf (buf, 128, "%" "ll" "X", (gint64)123456);
766 g_assert_cmpint (res, ==, 5);
767 g_assert_cmpstr (buf, ==, "1E240");
768  
769 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
770 _Pragma ("GCC diagnostic pop")
771 #endif
772  
773 #endif
774 }
775  
776 static void
777 test_64bit2_base (void)
778 {
779 gint res;
780  
781 res = g_printf ("%" G_GINT64_FORMAT "\n", (gint64)123456);
782 g_assert_cmpint (res, ==, 7);
783  
784 res = g_printf ("%" G_GINT64_FORMAT "\n", (gint64)-123456);
785 g_assert_cmpint (res, ==, 8);
786  
787 res = g_printf ("%" G_GUINT64_FORMAT "\n", (guint64)123456);
788 g_assert_cmpint (res, ==, 7);
789  
790 res = g_printf ("%" G_GINT64_MODIFIER "o\n", (gint64)123456);
791 g_assert_cmpint (res, ==, 7);
792  
793 res = g_printf ("%#" G_GINT64_MODIFIER "o\n", (gint64)123456);
794 g_assert_cmpint (res, ==, 8);
795  
796 res = g_printf ("%" G_GINT64_MODIFIER "x\n", (gint64)123456);
797 g_assert_cmpint (res, ==, 6);
798  
799 res = g_printf ("%#" G_GINT64_MODIFIER "x\n", (gint64)123456);
800 g_assert_cmpint (res, ==, 8);
801  
802 res = g_printf ("%" G_GINT64_MODIFIER "X\n", (gint64)123456);
803 g_assert_cmpint (res, ==, 6);
804 }
805  
806 #ifdef G_OS_WIN32
807 static void
808 test_64bit2_win32 (void)
809 {
810 gint res;
811  
812 /* On Win32, test that the "ll" modifier also works, for backward
813 * compatibility. One really should use the G_GINT64_MODIFIER (which
814 * on Win32 is the "I64" that the (msvcrt) C library's printf uses),
815 * but "ll" used to work with the "trio" g_printf implementation in
816 * GLib 2.2, so it's best if it continues to work.
817 */
818  
819 /* However, gcc doesn't know about this, so we need to disable printf
820 * format warnings...
821 */
822 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
823 _Pragma ("GCC diagnostic push")
824 _Pragma ("GCC diagnostic ignored \"-Wformat\"")
825 _Pragma ("GCC diagnostic ignored \"-Wformat-extra-args\"")
826 #endif
827  
828 res = g_printf ("%" "lli\n", (gint64)123456);
829 g_assert_cmpint (res, ==, 7);
830  
831 res = g_printf ("%" "lli\n", (gint64)-123456);
832 g_assert_cmpint (res, ==, 8);
833  
834 res = g_printf ("%" "llu\n", (guint64)123456);
835 g_assert_cmpint (res, ==, 7);
836  
837 res = g_printf ("%" "ll" "o\n", (gint64)123456);
838 g_assert_cmpint (res, ==, 7);
839  
840 res = g_printf ("%#" "ll" "o\n", (gint64)123456);
841 g_assert_cmpint (res, ==, 8);
842  
843 res = g_printf ("%" "ll" "x\n", (gint64)123456);
844 g_assert_cmpint (res, ==, 6);
845  
846 res = g_printf ("%#" "ll" "x\n", (gint64)123456);
847 g_assert_cmpint (res, ==, 8);
848  
849 res = g_printf ("%" "ll" "X\n", (gint64)123456);
850 g_assert_cmpint (res, ==, 6);
851  
852 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
853 _Pragma ("GCC diagnostic pop")
854 #endif
855 }
856 #endif
857  
858 static void
859 test_64bit2 (void)
860 {
861 #ifndef G_OS_WIN32
862 g_test_trap_subprocess ("/printf/test-64bit/subprocess/base", 0, 0);
863 g_test_trap_assert_passed ();
864 g_test_trap_assert_stdout ("123456\n-123456\n123456\n"
865 "361100\n0361100\n1e240\n"
866 "0x1e240\n1E240\n");
867  
868 #else
869 g_test_trap_subprocess ("/printf/test-64bit/subprocess/base", 0, 0);
870 g_test_trap_assert_passed ();
871 g_test_trap_assert_stdout ("123456\r\n-123456\r\n123456\r\n"
872 "361100\r\n0361100\r\n1e240\r\n"
873 "0x1e240\r\n1E240\r\n");
874  
875 g_test_trap_subprocess ("/printf/test-64bit/subprocess/win32", 0, 0);
876 g_test_trap_assert_passed ();
877 g_test_trap_assert_stdout ("123456\r\n-123456\r\n123456\r\n"
878 "361100\r\n0361100\r\n1e240\r\n"
879 "0x1e240\r\n1E240\r\n");
880 #endif
881 }
882  
883 G_GNUC_PRINTF(1, 2)
884 static gsize
885 upper_bound (const gchar *format, ...)
886 {
887 va_list args;
888 gsize res;
889  
890 va_start (args, format);
891 res = g_printf_string_upper_bound (format, args);
892 va_end (args);
893  
894 return res;
895 }
896  
897 static void
898 test_upper_bound (void)
899 {
900 gsize res;
901  
902 res = upper_bound ("bla %s %d: %g\n", "bla", 123, 0.123);
903 g_assert_cmpint (res, ==, 20);
904 }
905  
906 int
907 main (int argc,
908 char *argv[])
909 {
910 g_test_init (&argc, &argv, NULL);
911  
912 g_test_add_func ("/snprintf/retval-and-trunc", test_retval_and_trunc);
913 g_test_add_func ("/snprintf/%d", test_d);
914 g_test_add_func ("/snprintf/%d-invalid", test_d_invalid);
915 g_test_add_func ("/snprintf/%o", test_o);
916 g_test_add_func ("/snprintf/%u", test_u);
917 g_test_add_func ("/snprintf/%x", test_x);
918 g_test_add_func ("/snprintf/%X", test_X);
919 g_test_add_func ("/snprintf/%f", test_f);
920 g_test_add_func ("/snprintf/%e", test_e);
921 g_test_add_func ("/snprintf/%c", test_c);
922 g_test_add_func ("/snprintf/%s", test_s);
923 g_test_add_func ("/snprintf/%n", test_n);
924 g_test_add_func ("/snprintf/test-percent", test_percent);
925 g_test_add_func ("/snprintf/test-positional-params", test_positional_params);
926 g_test_add_func ("/snprintf/test-64bit", test_64bit);
927  
928 g_test_add_func ("/printf/test-percent", test_percent2);
929 g_test_add_func ("/printf/test-positional-params", test_positional_params2);
930 g_test_add_func ("/printf/test-64bit", test_64bit2);
931 g_test_add_func ("/printf/test-64bit/subprocess/base", test_64bit2_base);
932 #ifdef G_OS_WIN32
933 g_test_add_func ("/printf/test-64bit/subprocess/win32", test_64bit2_win32);
934 #endif
935  
936 g_test_add_func ("/sprintf/test-positional-params", test_positional_params3);
937 g_test_add_func ("/sprintf/upper-bound", test_upper_bound);
938  
939 return g_test_run();
940 }