开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 数学计算 > 查看源码
t-printf.c
资源名称：gmp-5.0.1.tar.gz　[点击查看]
上传用户：qaz666999
上传日期：2022-08-06
资源大小：2570k
文件大小：25k
源码类别：

数学计算

开发平台：

Unix_Linux

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