Annotation of OpenXM_contrib/gmp/tests/misc/t-printf.c, Revision 1.1.1.1
1.1 ohara 1: /* Test gmp_printf and related functions.
2:
3: Copyright 2001, 2002 Free Software Foundation, Inc.
4:
5: This file is part of the GNU MP Library.
6:
7: The GNU MP Library is free software; you can redistribute it and/or modify
8: it under the terms of the GNU Lesser General Public License as published by
9: the Free Software Foundation; either version 2.1 of the License, or (at your
10: option) any later version.
11:
12: The GNU MP Library is distributed in the hope that it will be useful, but
13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
15: License for more details.
16:
17: You should have received a copy of the GNU Lesser General Public License
18: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20: MA 02111-1307, USA. */
21:
22:
23: /* Usage: t-printf [-s]
24:
25: -s Check the data against the system printf, where possible. This is
26: only an option since we don't want to fail if the system printf is
27: faulty or strange. */
28:
29:
30: #include "config.h"
31:
32: #if HAVE_STDARG
33: #include <stdarg.h>
34: #else
35: #include <varargs.h>
36: #endif
37:
38: #include <stddef.h> /* for ptrdiff_t */
39: #include <stdio.h>
40: #include <stdlib.h>
41: #include <string.h>
42:
43: #if HAVE_OBSTACK_VPRINTF
44: #define obstack_chunk_alloc tests_allocate
45: #define obstack_chunk_free tests_free_nosize
46: #include <obstack.h>
47: #endif
48:
49: #if HAVE_INTTYPES_H
50: # include <inttypes.h> /* for intmax_t */
51: #else
52: # if HAVE_STDINT_H
53: # include <stdint.h>
54: # endif
55: #endif
56:
57: #if HAVE_UNISTD_H
58: #include <unistd.h> /* for unlink */
59: #endif
60:
61: #include "gmp.h"
62: #include "gmp-impl.h"
63: #include "tests.h"
64:
65:
66: int option_check_printf = 0;
67:
68:
69: #define CHECK_VFPRINTF_FILENAME "t-printf.tmp"
70: FILE *check_vfprintf_fp;
71:
72:
73: /* From any of the tests run here. */
74: #define MAX_OUTPUT 1024
75:
76:
77: void
78: #if HAVE_STDARG
79: check_plain (const char *want, const char *fmt_orig, ...)
80: #else
81: check_plain (va_alist)
82: va_dcl
83: #endif
84: {
85: char got[MAX_OUTPUT];
86: int got_len, want_len;
87: size_t fmtsize;
88: char *fmt, *q;
89: const char *p;
90: va_list ap;
91: #if HAVE_STDARG
92: va_start (ap, fmt_orig);
93: #else
94: const char *want;
95: const char *fmt_orig;
96: va_start (ap);
97: want = va_arg (ap, const char *);
98: fmt_orig = va_arg (ap, const char *);
99: #endif
100:
101: if (! option_check_printf)
102: return;
103:
104: fmtsize = strlen (fmt_orig) + 1;
105: fmt = (*__gmp_allocate_func) (fmtsize);
106:
107: for (p = fmt_orig, q = fmt; *p != '\0'; p++)
108: {
109: switch (*p) {
110: case 'a':
111: case 'A':
112: /* The exact value of the exponent isn't guaranteed in glibc, and it
113: and gmp_printf do slightly different things, so don't compare
114: directly. */
115: goto done;
116: case 'F':
117: if (p > fmt_orig && *(p-1) == '.')
118: goto done; /* don't test the "all digits" cases */
119: /* discard 'F' type */
120: break;
121: case 'Z':
122: /* transmute */
123: *q++ = 'l';
124: break;
125: default:
126: *q++ = *p;
127: break;
128: }
129: }
130: *q = '\0';
131:
132: want_len = strlen (want);
133: ASSERT_ALWAYS (want_len < sizeof(got));
134:
135: got_len = vsprintf (got, fmt, ap);
136:
137: if (got_len != want_len || strcmp (got, want) != 0)
138: {
139: printf ("wanted data doesn't match plain vsprintf\n");
140: printf (" fmt |%s|\n", fmt);
141: printf (" got |%s|\n", got);
142: printf (" want |%s|\n", want);
143: printf (" got_len %d\n", got_len);
144: printf (" want_len %d\n", want_len);
145: abort ();
146: }
147:
148: done:
149: (*__gmp_free_func) (fmt, fmtsize);
150: }
151:
152: void
153: check_vsprintf (const char *want, const char *fmt, va_list ap)
154: {
155: char got[MAX_OUTPUT];
156: int got_len, want_len;
157:
158: want_len = strlen (want);
159: got_len = gmp_vsprintf (got, fmt, ap);
160:
161: if (got_len != want_len || strcmp (got, want) != 0)
162: {
163: printf ("gmp_vsprintf wrong\n");
164: printf (" fmt |%s|\n", fmt);
165: printf (" got |%s|\n", got);
166: printf (" want |%s|\n", want);
167: printf (" got_len %d\n", got_len);
168: printf (" want_len %d\n", want_len);
169: abort ();
170: }
171: }
172:
173: void
174: check_vfprintf (const char *want, const char *fmt, va_list ap)
175: {
176: char got[MAX_OUTPUT];
177: int got_len, want_len, fread_len;
178: long ftell_len;
179:
180: want_len = strlen (want);
181:
182: rewind (check_vfprintf_fp);
183: got_len = gmp_vfprintf (check_vfprintf_fp, fmt, ap);
184: ASSERT_ALWAYS (got_len != -1);
185: ASSERT_ALWAYS (fflush (check_vfprintf_fp) == 0);
186:
187: ftell_len = ftell (check_vfprintf_fp);
188: ASSERT_ALWAYS (ftell_len != -1);
189:
190: rewind (check_vfprintf_fp);
191: ASSERT_ALWAYS (ftell_len <= sizeof(got));
192: fread_len = fread (got, 1, ftell_len, check_vfprintf_fp);
193:
194: if (got_len != want_len
195: || ftell_len != want_len
196: || fread_len != want_len
197: || memcmp (got, want, want_len) != 0)
198: {
199: printf ("gmp_vfprintf wrong\n");
200: printf (" fmt |%s|\n", fmt);
201: printf (" got |%.*s|\n", fread_len, got);
202: printf (" want |%s|\n", want);
203: printf (" got_len %d\n", got_len);
204: printf (" ftell_len %ld\n", ftell_len);
205: printf (" fread_len %d\n", fread_len);
206: printf (" want_len %d\n", want_len);
207: abort ();
208: }
209: }
210:
211: void
212: check_vsnprintf (const char *want, const char *fmt, va_list ap)
213: {
214: char got[MAX_OUTPUT+1];
215: int ret, got_len, want_len;
216: size_t bufsize;
217:
218: want_len = strlen (want);
219:
220: bufsize = -1;
221: for (;;)
222: {
223: /* do 0 to 5, then want-5 to want+5 */
224: bufsize++;
225: if (bufsize > 5 && bufsize < want_len-5)
226: bufsize = want_len-5;
227: if (bufsize > want_len + 5)
228: break;
229: ASSERT_ALWAYS (bufsize+1 <= sizeof (got));
230:
231: got[bufsize] = '!';
232: ret = gmp_vsnprintf (got, bufsize, fmt, ap);
233:
234: got_len = MIN (MAX(1,bufsize)-1, want_len);
235:
236: if (got[bufsize] != '!')
237: {
238: printf ("gmp_vsnprintf overwrote bufsize sentinel\n");
239: goto error;
240: }
241:
242: if (ret != want_len)
243: {
244: printf ("gmp_vsnprintf return value wrong\n");
245: goto error;
246: }
247:
248: if (bufsize > 0)
249: {
250: if (memcmp (got, want, got_len) != 0 || got[got_len] != '\0')
251: {
252: printf ("gmp_vsnprintf wrong result string\n");
253: error:
254: printf (" fmt |%s|\n", fmt);
255: printf (" bufsize %u\n", bufsize);
256: printf (" got |%s|\n", got);
257: printf (" want |%.*s|\n", got_len, want);
258: printf (" want full |%s|\n", want);
259: printf (" ret %d\n", ret);
260: printf (" want_len %d\n", want_len);
261: abort ();
262: }
263: }
264: }
265: }
266:
267: void
268: check_vasprintf (const char *want, const char *fmt, va_list ap)
269: {
270: char *got;
271: int got_len, want_len;
272:
273: want_len = strlen (want);
274: got_len = gmp_vasprintf (&got, fmt, ap);
275:
276: if (got_len != want_len || strcmp (got, want) != 0)
277: {
278: printf ("gmp_vasprintf wrong\n");
279: printf (" fmt |%s|\n", fmt);
280: printf (" got |%s|\n", got);
281: printf (" want |%s|\n", want);
282: printf (" got_len %d\n", got_len);
283: printf (" want_len %d\n", want_len);
284: abort ();
285: }
286: (*__gmp_free_func) (got, strlen(got)+1);
287: }
288:
289: void
290: check_obstack_vprintf (const char *want, const char *fmt, va_list ap)
291: {
292: #if HAVE_OBSTACK_VPRINTF
293: struct obstack ob;
294: int got_len, want_len, ob_len;
295: char *got;
296:
297: want_len = strlen (want);
298:
299: obstack_init (&ob);
300: got_len = gmp_obstack_vprintf (&ob, fmt, ap);
301: got = obstack_base (&ob);
302: ob_len = obstack_object_size (&ob);
303:
304: if (got_len != want_len
305: || ob_len != want_len
306: || memcmp (got, want, want_len) != 0)
307: {
308: printf ("gmp_obstack_vprintf wrong\n");
309: printf (" fmt |%s|\n", fmt);
310: printf (" got |%s|\n", got);
311: printf (" want |%s|\n", want);
312: printf (" got_len %d\n", got_len);
313: printf (" ob_len %d\n", ob_len);
314: printf (" want_len %d\n", want_len);
315: abort ();
316: }
317: obstack_free (&ob, NULL);
318: #endif
319: }
320:
321:
322: void
323: #if HAVE_STDARG
324: check_one (const char *want, const char *fmt, ...)
325: #else
326: check_one (va_alist)
327: va_dcl
328: #endif
329: {
330: va_list ap;
331: #if HAVE_STDARG
332: va_start (ap, fmt);
333: #else
334: const char *want;
335: const char *fmt;
336: va_start (ap);
337: want = va_arg (ap, const char *);
338: fmt = va_arg (ap, const char *);
339: #endif
340:
341: /* simplest first */
342: check_vsprintf (want, fmt, ap);
343: check_vfprintf (want, fmt, ap);
344: check_vsnprintf (want, fmt, ap);
345: check_vasprintf (want, fmt, ap);
346: check_obstack_vprintf (want, fmt, ap);
347: }
348:
349:
350: #define hex_or_octal_p(fmt) \
351: (strchr (fmt, 'x') != NULL \
352: || strchr (fmt, 'X') != NULL \
353: || strchr (fmt, 'o') != NULL)
354:
355: void
356: check_z (void)
357: {
358: static const struct {
359: const char *fmt;
360: const char *z;
361: const char *want;
362: } data[] = {
363: { "%Zd", "0", "0" },
364: { "%Zd", "1", "1" },
365: { "%Zd", "123", "123" },
366: { "%Zd", "-1", "-1" },
367: { "%Zd", "-123", "-123" },
368:
369: { "%+Zd", "0", "+0" },
370: { "%+Zd", "123", "+123" },
371: { "%+Zd", "-123", "-123" },
372:
373: { "%Zx", "123", "7b" },
374: { "%ZX", "123", "7B" },
375: { "%Zx", "-123", "-7b" },
376: { "%ZX", "-123", "-7B" },
377: { "%Zo", "123", "173" },
378: { "%Zo", "-123", "-173" },
379:
380: { "%#Zx", "0", "0" },
381: { "%#ZX", "0", "0" },
382: { "%#Zx", "123", "0x7b" },
383: { "%#ZX", "123", "0X7B" },
384: { "%#Zx", "-123", "-0x7b" },
385: { "%#ZX", "-123", "-0X7B" },
386:
387: { "%#Zo", "0", "0" },
388: { "%#Zo", "123", "0173" },
389: { "%#Zo", "-123", "-0173" },
390:
391: { "%10Zd", "0", " 0" },
392: { "%10Zd", "123", " 123" },
393: { "%10Zd", "-123", " -123" },
394:
395: { "%-10Zd", "0", "0 " },
396: { "%-10Zd", "123", "123 " },
397: { "%-10Zd", "-123", "-123 " },
398:
399: { "%+10Zd", "123", " +123" },
400: { "%+-10Zd", "123", "+123 " },
401: { "%+10Zd", "-123", " -123" },
402: { "%+-10Zd", "-123", "-123 " },
403:
404: { "%08Zd", "0", "00000000" },
405: { "%08Zd", "123", "00000123" },
406: { "%08Zd", "-123", "-0000123" },
407:
408: { "%+08Zd", "0", "+0000000" },
409: { "%+08Zd", "123", "+0000123" },
410: { "%+08Zd", "-123", "-0000123" },
411:
412: { "%#08Zx", "0", "00000000" },
413: { "%#08Zx", "123", "0x00007b" },
414: { "%#08Zx", "-123", "-0x0007b" },
415:
416: { "%+#08Zx", "0", "+0000000" },
417: { "%+#08Zx", "123", "+0x0007b" },
418: { "%+#08Zx", "-123", "-0x0007b" },
419:
420: { "%.0Zd", "0", "" },
421: { "%.1Zd", "0", "0" },
422: { "%.2Zd", "0", "00" },
423: { "%.3Zd", "0", "000" },
424: };
425:
426: int i, j, zeros;
427: mpz_t z;
428: char *nfmt;
429: mp_size_t nsize;
430:
431: mpz_init (z);
432:
433: for (i = 0; i < numberof (data); i++)
434: {
435: mpz_set_str_or_abort (z, data[i].z, 0);
436:
437: /* don't try negatives or forced sign in hex or octal */
438: if (mpz_fits_slong_p (z)
439: && ! (hex_or_octal_p (data[i].fmt)
440: && (strchr (data[i].fmt, '+') != NULL || mpz_sgn(z) < 0)))
441: {
442: check_plain (data[i].want, data[i].fmt, mpz_get_si (z));
443: }
444:
445: check_one (data[i].want, data[i].fmt, z);
446:
447: /* Same again, with %N and possibly some high zero limbs */
448: nfmt = __gmp_allocate_strdup (data[i].fmt);
449: for (j = 0; nfmt[j] != '\0'; j++)
450: if (nfmt[j] == 'Z')
451: nfmt[j] = 'N';
452: for (zeros = 0; zeros <= 3; zeros++)
453: {
454: nsize = ABSIZ(z)+zeros;
455: MPZ_REALLOC (z, nsize);
456: nsize = (SIZ(z) >= 0 ? nsize : -nsize);
457: refmpn_zero (PTR(z)+ABSIZ(z), zeros);
458: check_one (data[i].want, nfmt, PTR(z), nsize);
459: }
460: __gmp_free_func (nfmt, strlen(nfmt)+1);
461: }
462:
463: mpz_clear (z);
464: }
465:
466: void
467: check_q (void)
468: {
469: static const struct {
470: const char *fmt;
471: const char *q;
472: const char *want;
473: } data[] = {
474: { "%Qd", "0", "0" },
475: { "%Qd", "1", "1" },
476: { "%Qd", "123", "123" },
477: { "%Qd", "-1", "-1" },
478: { "%Qd", "-123", "-123" },
479: { "%Qd", "3/2", "3/2" },
480: { "%Qd", "-3/2", "-3/2" },
481:
482: { "%+Qd", "0", "+0" },
483: { "%+Qd", "123", "+123" },
484: { "%+Qd", "-123", "-123" },
485: { "%+Qd", "5/8", "+5/8" },
486: { "%+Qd", "-5/8", "-5/8" },
487:
488: { "%Qx", "123", "7b" },
489: { "%QX", "123", "7B" },
490: { "%Qx", "15/16", "f/10" },
491: { "%QX", "15/16", "F/10" },
492: { "%Qx", "-123", "-7b" },
493: { "%QX", "-123", "-7B" },
494: { "%Qx", "-15/16", "-f/10" },
495: { "%QX", "-15/16", "-F/10" },
496: { "%Qo", "123", "173" },
497: { "%Qo", "-123", "-173" },
498: { "%Qo", "16/17", "20/21" },
499: { "%Qo", "-16/17", "-20/21" },
500:
501: { "%#Qx", "0", "0" },
502: { "%#QX", "0", "0" },
503: { "%#Qx", "123", "0x7b" },
504: { "%#QX", "123", "0X7B" },
505: { "%#Qx", "5/8", "0x5/0x8" },
506: { "%#QX", "5/8", "0X5/0X8" },
507: { "%#Qx", "-123", "-0x7b" },
508: { "%#QX", "-123", "-0X7B" },
509: { "%#Qx", "-5/8", "-0x5/0x8" },
510: { "%#QX", "-5/8", "-0X5/0X8" },
511: { "%#Qo", "0", "0" },
512: { "%#Qo", "123", "0173" },
513: { "%#Qo", "-123", "-0173" },
514: { "%#Qo", "5/7", "05/07" },
515: { "%#Qo", "-5/7", "-05/07" },
516:
517: /* zero denominator and showbase */
518: { "%#10Qo", "0/0", " 0/0" },
519: { "%#10Qd", "0/0", " 0/0" },
520: { "%#10Qx", "0/0", " 0/0" },
521: { "%#10Qo", "123/0", " 0173/0" },
522: { "%#10Qd", "123/0", " 123/0" },
523: { "%#10Qx", "123/0", " 0x7b/0" },
524: { "%#10QX", "123/0", " 0X7B/0" },
525: { "%#10Qo", "-123/0", " -0173/0" },
526: { "%#10Qd", "-123/0", " -123/0" },
527: { "%#10Qx", "-123/0", " -0x7b/0" },
528: { "%#10QX", "-123/0", " -0X7B/0" },
529:
530: { "%10Qd", "0", " 0" },
531: { "%-10Qd", "0", "0 " },
532: { "%10Qd", "123", " 123" },
533: { "%-10Qd", "123", "123 " },
534: { "%10Qd", "-123", " -123" },
535: { "%-10Qd", "-123", "-123 " },
536:
537: { "%+10Qd", "123", " +123" },
538: { "%+-10Qd", "123", "+123 " },
539: { "%+10Qd", "-123", " -123" },
540: { "%+-10Qd", "-123", "-123 " },
541:
542: { "%08Qd", "0", "00000000" },
543: { "%08Qd", "123", "00000123" },
544: { "%08Qd", "-123", "-0000123" },
545:
546: { "%+08Qd", "0", "+0000000" },
547: { "%+08Qd", "123", "+0000123" },
548: { "%+08Qd", "-123", "-0000123" },
549:
550: { "%#08Qx", "0", "00000000" },
551: { "%#08Qx", "123", "0x00007b" },
552: { "%#08Qx", "-123", "-0x0007b" },
553:
554: { "%+#08Qx", "0", "+0000000" },
555: { "%+#08Qx", "123", "+0x0007b" },
556: { "%+#08Qx", "-123", "-0x0007b" },
557: };
558:
559: int i;
560: mpq_t q;
561:
562: mpq_init (q);
563:
564: for (i = 0; i < numberof (data); i++)
565: {
566: mpq_set_str_or_abort (q, data[i].q, 0);
567: check_one (data[i].want, data[i].fmt, q);
568: }
569:
570: mpq_clear (q);
571: }
572:
573: void
574: check_f (void)
575: {
576: static const struct {
577: const char *fmt;
578: const char *f;
579: const char *want;
580:
581: } data[] = {
582:
583: { "%Ff", "0", "0.000000" },
584: { "%Ff", "123", "123.000000" },
585: { "%Ff", "-123", "-123.000000" },
586:
587: { "%+Ff", "0", "+0.000000" },
588: { "%+Ff", "123", "+123.000000" },
589: { "%+Ff", "-123", "-123.000000" },
590:
591: { "%.0Ff", "0", "0" },
592: { "%.0Ff", "123", "123" },
593: { "%.0Ff", "-123", "-123" },
594:
595: { "%8.0Ff", "0", " 0" },
596: { "%8.0Ff", "123", " 123" },
597: { "%8.0Ff", "-123", " -123" },
598:
599: { "%08.0Ff", "0", "00000000" },
600: { "%08.0Ff", "123", "00000123" },
601: { "%08.0Ff", "-123", "-0000123" },
602:
603: { "%10.2Ff", "0", " 0.00" },
604: { "%10.2Ff", "0.25", " 0.25" },
605: { "%10.2Ff", "123.25", " 123.25" },
606: { "%10.2Ff", "-123.25", " -123.25" },
607:
608: { "%-10.2Ff", "0", "0.00 " },
609: { "%-10.2Ff", "0.25", "0.25 " },
610: { "%-10.2Ff", "123.25", "123.25 " },
611: { "%-10.2Ff", "-123.25", "-123.25 " },
612:
613: { "%.2Ff", "0.00000000000001", "0.00" },
614: { "%.2Ff", "0.002", "0.00" },
615: { "%.2Ff", "0.008", "0.01" },
616:
617: { "%.0Ff", "123.00000000000001", "123" },
618: { "%.0Ff", "123.2", "123" },
619: { "%.0Ff", "123.8", "124" },
620:
621: { "%.0Ff", "999999.9", "1000000" },
622: { "%.0Ff", "3999999.9", "4000000" },
623:
624: { "%Fe", "0", "0.000000e+00" },
625: { "%Fe", "1", "1.000000e+00" },
626: { "%Fe", "123", "1.230000e+02" },
627:
628: { "%FE", "0", "0.000000E+00" },
629: { "%FE", "1", "1.000000E+00" },
630: { "%FE", "123", "1.230000E+02" },
631:
632: { "%Fe", "0", "0.000000e+00" },
633: { "%Fe", "1", "1.000000e+00" },
634:
635: { "%.0Fe", "10000000000", "1e+10" },
636: { "%.0Fe", "-10000000000", "-1e+10" },
637:
638: { "%.2Fe", "10000000000", "1.00e+10" },
639: { "%.2Fe", "-10000000000", "-1.00e+10" },
640:
641: { "%8.0Fe", "10000000000", " 1e+10" },
642: { "%8.0Fe", "-10000000000", " -1e+10" },
643:
644: { "%-8.0Fe", "10000000000", "1e+10 " },
645: { "%-8.0Fe", "-10000000000", "-1e+10 " },
646:
647: { "%12.2Fe", "10000000000", " 1.00e+10" },
648: { "%12.2Fe", "-10000000000", " -1.00e+10" },
649:
650: { "%012.2Fe", "10000000000", "00001.00e+10" },
651: { "%012.2Fe", "-10000000000", "-0001.00e+10" },
652:
653: { "%Fg", "0", "0" },
654: { "%Fg", "1", "1" },
655: { "%Fg", "-1", "-1" },
656:
657: { "%.0Fg", "0", "0" },
658: { "%.0Fg", "1", "1" },
659: { "%.0Fg", "-1", "-1" },
660:
661: { "%.1Fg", "100", "1e+02" },
662: { "%.2Fg", "100", "1e+02" },
663: { "%.3Fg", "100", "100" },
664: { "%.4Fg", "100", "100" },
665:
666: { "%Fg", "0.001", "0.001" },
667: { "%Fg", "0.0001", "0.0001" },
668: { "%Fg", "0.00001", "1e-05" },
669: { "%Fg", "0.000001", "1e-06" },
670:
671: { "%.4Fg", "1.00000000000001", "1" },
672: { "%.4Fg", "100000000000001", "1e+14" },
673:
674: { "%.4Fg", "12345678", "1.235e+07" },
675:
676: { "%Fa", "0","0x0p+0" },
677: { "%FA", "0","0X0P+0" },
678:
679: { "%Fa", "1","0x1p+0" },
680: { "%Fa", "65535","0xf.fffp+12" },
681: { "%Fa", "65536","0x1p+16" },
682: { "%F.10a", "65536","0x1.0000000000p+16" },
683: { "%F.1a", "65535","0x1.0p+16" },
684: { "%F.0a", "65535","0x1p+16" },
685:
686: { "%.2Ff", "0.99609375", "1.00" },
687: { "%.Ff", "0.99609375", "0.99609375" },
688: { "%.Fe", "0.99609375", "9.9609375e-01" },
689: { "%.Fg", "0.99609375", "0.99609375" },
690: { "%.20Fg", "1000000", "1000000" },
691: { "%.Fg", "1000000", "1000000" },
692:
693: { "%#.0Ff", "1", "1." },
694: { "%#.0Fe", "1", "1.e+00" },
695: { "%#.0Fg", "1", "1." },
696:
697: { "%#.1Ff", "1", "1.0" },
698: { "%#.1Fe", "1", "1.0e+00" },
699: { "%#.1Fg", "1", "1." },
700:
701: { "%#.4Ff", "1234", "1234.0000" },
702: { "%#.4Fe", "1234", "1.2340e+03" },
703: { "%#.4Fg", "1234", "1234." },
704:
705: { "%#.8Ff", "1234", "1234.00000000" },
706: { "%#.8Fe", "1234", "1.23400000e+03" },
707: { "%#.8Fg", "1234", "1234.0000" },
708:
709: };
710:
711: int i;
712: mpf_t f;
713: double d;
714:
715: mpf_init2 (f, 256L);
716:
717: for (i = 0; i < numberof (data); i++)
718: {
719: if (data[i].f[0] == '0' && data[i].f[1] == 'x')
720: mpf_set_str_or_abort (f, data[i].f, 16);
721: else
722: mpf_set_str_or_abort (f, data[i].f, 10);
723:
724: /* if mpf->double doesn't truncate, then expect same result */
725: d = mpf_get_d (f);
726: if (mpf_cmp_d (f, d) == 0)
727: check_plain (data[i].want, data[i].fmt, d);
728:
729: check_one (data[i].want, data[i].fmt, f);
730: }
731:
732: mpf_clear (f);
733: }
734:
735:
736: void
737: check_n (void)
738: {
739: {
740: int n = -1;
741: check_one ("blah", "%nblah", &n);
742: ASSERT_ALWAYS (n == 0);
743: }
744:
745: {
746: int n = -1;
747: check_one ("hello ", "hello %n", &n);
748: ASSERT_ALWAYS (n == 6);
749: }
750:
751: {
752: int n = -1;
753: check_one ("hello world", "hello %n world", &n);
754: ASSERT_ALWAYS (n == 6);
755: }
756:
757: #define CHECK_N(type, string) \
758: do { \
759: type x[2]; \
760: char fmt[128]; \
761: \
762: x[0] = ~ (type) 0; \
763: x[1] = ~ (type) 0; \
764: sprintf (fmt, "%%d%%%sn%%d", string); \
765: check_one ("123456", fmt, 123, &x[0], 456); \
766: \
767: /* should write whole of x[0] and none of x[1] */ \
768: ASSERT_ALWAYS (x[0] == 3); \
769: ASSERT_ALWAYS (x[1] == (type) ~ (type) 0); \
770: \
771: } while (0)
772:
773: CHECK_N (char, "hh");
774: CHECK_N (long, "l");
775: #if HAVE_LONG_LONG
776: CHECK_N (long long, "L");
777: #endif
778: #if HAVE_INTMAX_T
779: CHECK_N (intmax_t, "j");
780: #endif
781: #if HAVE_PTRDIFF_T
782: CHECK_N (ptrdiff_t, "t");
783: #endif
784: CHECK_N (short, "h");
785: CHECK_N (size_t, "z");
786:
787: {
788: mpz_t x[2];
789: mpz_init_set_si (x[0], -987L);
790: mpz_init_set_si (x[1], 654L);
791: check_one ("123456", "%d%Zn%d", 123, x[0], 456);
792: MPZ_CHECK_FORMAT (x[0]);
793: MPZ_CHECK_FORMAT (x[1]);
794: ASSERT_ALWAYS (mpz_cmp_ui (x[0], 3L) == 0);
795: ASSERT_ALWAYS (mpz_cmp_ui (x[1], 654L) == 0);
796: mpz_clear (x[0]);
797: mpz_clear (x[1]);
798: }
799:
800: {
801: mpq_t x[2];
802: mpq_init (x[0]);
803: mpq_init (x[1]);
804: mpq_set_ui (x[0], -987L, 654L);
805: mpq_set_ui (x[1], 4115L, 226L);
806: check_one ("123456", "%d%Qn%d", 123, x[0], 456);
807: MPQ_CHECK_FORMAT (x[0]);
808: MPQ_CHECK_FORMAT (x[1]);
809: ASSERT_ALWAYS (mpq_cmp_ui (x[0], 3L, 1L) == 0);
810: ASSERT_ALWAYS (mpq_cmp_ui (x[1], 4115L, 226L) == 0);
811: mpq_clear (x[0]);
812: mpq_clear (x[1]);
813: }
814:
815: {
816: mpf_t x[2];
817: mpf_init (x[0]);
818: mpf_init (x[1]);
819: mpf_set_ui (x[0], -987L);
820: mpf_set_ui (x[1], 654L);
821: check_one ("123456", "%d%Fn%d", 123, x[0], 456);
822: MPF_CHECK_FORMAT (x[0]);
823: MPF_CHECK_FORMAT (x[1]);
824: ASSERT_ALWAYS (mpf_cmp_ui (x[0], 3L) == 0);
825: ASSERT_ALWAYS (mpf_cmp_ui (x[1], 654L) == 0);
826: mpf_clear (x[0]);
827: mpf_clear (x[1]);
828: }
829:
830: {
831: mp_limb_t a[5];
832: mp_limb_t a_want[numberof(a)];
833: mp_size_t i;
834:
835: a[0] = 123;
836: check_one ("blah", "bl%Nnah", a, (mp_size_t) 0);
837: ASSERT_ALWAYS (a[0] == 123);
838:
839: MPN_ZERO (a_want, numberof (a_want));
840: for (i = 1; i < numberof (a); i++)
841: {
842: check_one ("blah", "bl%Nnah", a, i);
843: a_want[0] = 2;
844: ASSERT_ALWAYS (mpn_cmp (a, a_want, i) == 0);
845: }
846: }
847: }
848:
849:
850: void
851: check_misc (void)
852: {
853: mpz_t z;
854: mpf_t f;
855:
856: mpz_init (z);
857: mpf_init2 (f, 128L);
858:
859: check_one ("!", "%c", '!');
860:
861: check_one ("hello world", "hello %s", "world");
862: check_one ("hello:", "%s:", "hello");
863: mpz_set_ui (z, 0L);
864: check_one ("hello0", "%s%Zd", "hello", z, z);
865:
866: {
867: static char xs[801];
868: memset (xs, 'x', sizeof(xs)-1);
869: check_one (xs, "%s", xs);
870: }
871:
872: mpz_set_ui (z, 12345L);
873: check_one (" 12345", "%*Zd", 10, z);
874: check_one ("0000012345", "%0*Zd", 10, z);
875: check_one ("12345 ", "%*Zd", -10, z);
876: check_one ("12345 and 678", "%Zd and %d", z, 678);
877: check_one ("12345,1,12345,2,12345", "%Zd,%d,%Zd,%d,%Zd", z, 1, z, 2, z);
878:
879: /* from the glibc info docs */
880: mpz_set_si (z, 0L);
881: check_one ("| 0|0 | +0|+0 | 0|00000| | 00|0|",
882: "|%5Zd|%-5Zd|%+5Zd|%+-5Zd|% 5Zd|%05Zd|%5.0Zd|%5.2Zd|%Zd|",
883: /**/ z, z, z, z, z, z, z, z, z);
884: mpz_set_si (z, 1L);
885: check_one ("| 1|1 | +1|+1 | 1|00001| 1| 01|1|",
886: "|%5Zd|%-5Zd|%+5Zd|%+-5Zd|% 5Zd|%05Zd|%5.0Zd|%5.2Zd|%Zd|",
887: /**/ z, z, z, z, z, z, z, z, z);
888: mpz_set_si (z, -1L);
889: check_one ("| -1|-1 | -1|-1 | -1|-0001| -1| -01|-1|",
890: "|%5Zd|%-5Zd|%+5Zd|%+-5Zd|% 5Zd|%05Zd|%5.0Zd|%5.2Zd|%Zd|",
891: /**/ z, z, z, z, z, z, z, z, z);
892: mpz_set_si (z, 100000L);
893: check_one ("|100000|100000|+100000|+100000| 100000|100000|100000|100000|100000|",
894: "|%5Zd|%-5Zd|%+5Zd|%+-5Zd|% 5Zd|%05Zd|%5.0Zd|%5.2Zd|%Zd|",
895: /**/ z, z, z, z, z, z, z, z, z);
896: mpz_set_si (z, 0L);
897: check_one ("| 0| 0| 0| 0| 0| 0| 00000000|",
898: "|%5Zo|%5Zx|%5ZX|%#5Zo|%#5Zx|%#5ZX|%#10.8Zx|",
899: /**/ z, z, z, z, z, z, z);
900: mpz_set_si (z, 1L);
901: check_one ("| 1| 1| 1| 01| 0x1| 0X1|0x00000001|",
902: "|%5Zo|%5Zx|%5ZX|%#5Zo|%#5Zx|%#5ZX|%#10.8Zx|",
903: /**/ z, z, z, z, z, z, z);
904: mpz_set_si (z, 100000L);
905: check_one ("|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|",
906: "|%5Zo|%5Zx|%5ZX|%#5Zo|%#5Zx|%#5ZX|%#10.8Zx|",
907: /**/ z, z, z, z, z, z, z);
908:
909: /* %zd for size_t won't be available on old systems, and running something
910: to see if it works might be bad, so only try it on glibc, and only on a
911: new enough version (glibc 2.0 doesn't have %zd) */
912: #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 0)
913: mpz_set_ui (z, 789L);
914: check_one ("456 789 blah", "%zd %Zd blah", (size_t) 456, z);
915: #endif
916:
917: mpz_clear (z);
918: mpf_clear (f);
919: }
920:
921:
922: int
923: main (int argc, char *argv[])
924: {
925: if (argc > 1 && strcmp (argv[1], "-s") == 0)
926: option_check_printf = 1;
927:
928: tests_start ();
929: check_vfprintf_fp = fopen (CHECK_VFPRINTF_FILENAME, "w+");
930: ASSERT_ALWAYS (check_vfprintf_fp != NULL);
931:
932: check_z ();
933: check_q ();
934: check_f ();
935: check_n ();
936: check_misc ();
937:
938: ASSERT_ALWAYS (fclose (check_vfprintf_fp) == 0);
939: unlink (CHECK_VFPRINTF_FILENAME);
940: tests_end ();
941: exit (0);
942: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to t-printf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tests / misc