t-inp_str.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:6k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. /* Test mpf_inp_str.
  2. Copyright 2001, 2002 Free Software Foundation, Inc.
  3. This file is part of the GNU MP Library.
  4. The GNU MP Library is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU Lesser General Public License as published by
  6. the Free Software Foundation; either version 3 of the License, or (at your
  7. option) any later version.
  8. The GNU MP Library is distributed in the hope that it will be useful, but
  9. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  11. License for more details.
  12. You should have received a copy of the GNU Lesser General Public License
  13. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  14. #include "config.h"
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #if HAVE_UNISTD_H
  19. #include <unistd.h> /* for unlink */
  20. #endif
  21. #include "gmp.h"
  22. #include "gmp-impl.h"
  23. #include "tests.h"
  24. #define FILENAME  "t-inp_str.tmp"
  25. void
  26. check_data (void)
  27. {
  28.   static const struct {
  29.     const char  *inp;
  30.     int         base;
  31.     const char  *want;
  32.     int         want_nread;
  33.   } data[] = {
  34.     { "0",   10, "0", 1 },
  35.     { "abc", 10, "0", 0 },
  36.     { "ghi", 16, "0", 0 },
  37.     { "125",    10, "125",  3 },
  38.     { "125e1",  10, "1250", 5 },
  39.     { "125e-1", 10, "12.5", 6 },
  40.     {  "ff", 16,  "255", 2 },
  41.     { "-ff", 16, "-255", 3 },
  42.     {  "FF", 16,  "255", 2 },
  43.     { "-FF", 16, "-255", 3 },
  44.     { "100",     16, "256",  3 },
  45.     { "100@1",   16, "4096", 5 },
  46.     { "100@10",  16, "4722366482869645213696", 6 },
  47.     { "100@10", -16, "281474976710656",        6 },
  48.     { "100@-1",  16, "16",   6 },
  49.     { "10000000000000000@-10",  16, "1", 21 },
  50.     { "10000000000@-10",       -16, "1", 15 },
  51.     { "z", 36, "35", 1 },
  52.     { "Z", 36, "35", 1 },
  53.     { "z@1", 36, "1260", 3 },
  54.     { "Z@1", 36, "1260", 3 },
  55.     {  "0",      0,   "0", 1 },
  56.   };
  57.   mpf_t  got, want;
  58.   long   ftell_nread;
  59.   int    i, pre, post, j, got_nread, want_nread;
  60.   FILE   *fp;
  61.   mpf_init (got);
  62.   mpf_init (want);
  63.   for (i = 0; i < numberof (data); i++)
  64.     {
  65.       for (pre = 0; pre <= 3; pre++)
  66.         {
  67.           for (post = 0; post <= 2; post++)
  68.             {
  69.               mpf_set_str_or_abort (want, data[i].want, 10);
  70.               MPF_CHECK_FORMAT (want);
  71.               /* create the file new each time to ensure its length is what
  72.                  we want */
  73.               fp = fopen (FILENAME, "w+");
  74.               ASSERT_ALWAYS (fp != NULL);
  75.               for (j = 0; j < pre; j++)
  76.                 putc (' ', fp);
  77.               fputs (data[i].inp, fp);
  78.               for (j = 0; j < post; j++)
  79.                 putc (' ', fp);
  80.               fflush (fp);
  81.               ASSERT_ALWAYS (! ferror(fp));
  82.               rewind (fp);
  83.               got_nread = mpf_inp_str (got, fp, data[i].base);
  84.               if (got_nread != 0)
  85.                 {
  86.                   ftell_nread = ftell (fp);
  87.                   if (got_nread != ftell_nread)
  88.                     {
  89.                       printf ("mpf_inp_str nread wrongn");
  90.                       printf ("  inp          "%s"n", data[i].inp);
  91.                       printf ("  base         %dn", data[i].base);
  92.                       printf ("  pre          %dn", pre);
  93.                       printf ("  post         %dn", post);
  94.                       printf ("  got_nread    %dn", got_nread);
  95.                       printf ("  ftell_nread  %ldn", ftell_nread);
  96.                       abort ();
  97.                     }
  98.                 }
  99.               /* if data[i].inp is a whole string to read and there's no post
  100.                  whitespace then expect to have EOF */
  101.               if (post == 0 && data[i].want_nread == strlen(data[i].inp))
  102.                 {
  103.                   int  c = getc(fp);
  104.                   if (c != EOF)
  105.                     {
  106.                       printf ("mpf_inp_str didn't read to EOFn");
  107.                       printf ("  inp   "%s"n", data[i].inp);
  108.                       printf ("  base  %dn", data[i].base);
  109.                       printf ("  pre   %dn", pre);
  110.                       printf ("  post  %dn", post);
  111.                       printf ("  c     '%c' %#xn", c, c);
  112.                       abort ();
  113.                     }
  114.                 }
  115.               /* only expect "pre" included in the count when non-zero */
  116.               want_nread = data[i].want_nread;
  117.               if (want_nread != 0)
  118.                 want_nread += pre;
  119.               if (got_nread != want_nread)
  120.                 {
  121.                   printf ("mpf_inp_str nread wrongn");
  122.                   printf ("  inp         "%s"n", data[i].inp);
  123.                   printf ("  base        %dn", data[i].base);
  124.                   printf ("  pre         %dn", pre);
  125.                   printf ("  post        %dn", post);
  126.                   printf ("  got_nread   %dn", got_nread);
  127.                   printf ("  want_nread  %dn", want_nread);
  128.                   abort ();
  129.                 }
  130.               MPF_CHECK_FORMAT (got);
  131.               if (mpf_cmp (got, want) != 0)
  132.                 {
  133.                   printf ("mpf_inp_str wrong resultn");
  134.                   printf ("  inp   "%s"n", data[i].inp);
  135.                   printf ("  base  %dn", data[i].base);
  136.                   mpf_trace ("  got ",  got);
  137.                   mpf_trace ("  want", want);
  138.                   abort ();
  139.                 }
  140.               ASSERT_ALWAYS (fclose (fp) == 0);
  141.             }
  142.         }
  143.     }
  144.   mpf_clear (got);
  145.   mpf_clear (want);
  146. }
  147. int
  148. main (void)
  149. {
  150.   tests_start ();
  151.   check_data ();
  152.   unlink (FILENAME);
  153.   tests_end ();
  154.   exit (0);
  155. }