stdlib/tst-strtol.c

   1 /* My bet is this was written by Chris Torek.
   2    I reformatted and ansidecl-ized it, and tweaked it a little.  */
   3
   4 #include <ctype.h>
   5 #include <stdio.h>
   6 #include <errno.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <limits.h>
  10
  11 struct ltest
  12   {
  13     const char *str;            /* Convert this.  */
  14     unsigned long int expect;   /* To get this.  */
  15     int base;                   /* Use this base.  */
  16     char left;                  /* With this left over.  */
  17     int err;                    /* And this in errno.  */
  18   };
  19 static const struct ltest tests[] =
  20   {
  21   /* First, signed numbers:  */
  22   /* simple... */
  23   {"123", 123, 0, 0, 0},
  24   {"+123", 123, 0, 0, 0},
  25   {"  123", 123, 0, 0, 0},
  26   {" 123 ", 123, 0, ' ', 0},
  27   {"   -17", -17, 0, 0, 0},
  28
  29   /* implicit base... */
  30   {"0123", 0123, 0, 0, 0},
  31   {"0123a", 0123, 0, 'a', 0},
  32   {"01239", 0123, 0, '9', 0},
  33   {"0x123", 0x123, 0, 0, 0},
  34   {"-0x123", -0x123, 0, 0, 0},
  35   {"0x0xc", 0, 0, 'x', 0},
  36   {" +0x123fg", 0x123f, 0, 'g', 0},
  37
  38   /* explicit base... */
  39   {"123", 0x123, 16, 0, 0},
  40   {"0x123", 0x123, 16, 0, 0},
  41   {"123", 0123, 8, 0, 0},
  42   {"0123", 0123, 8, 0, 0},
  43   {"0123", 123, 10, 0, 0},
  44   {"0x123", 0, 10, 'x', 0},
  45
  46   /* case insensitivity... */
  47   {"abcd", 0xabcd, 16, 0, 0},
  48   {"AbCd", 0xabcd, 16, 0, 0},
  49   {"0xABCD", 0xabcd, 16, 0, 0},
  50   {"0Xabcd", 0xabcd, 16, 0, 0},
  51
  52   /* odd bases... */
  53   {"0xyz", 33 * 35 + 34, 35, 'z', 0},
  54   {"yz!", 34 * 36 + 35, 36, '!', 0},
  55   {"-yz", -(34*36 + 35), 36, 0, 0},
  56   {"GhI4", ((16*20 + 17)*20 + 18)*20 + 4, 20, 0, 0},
  57
  58   /* extremes... */
  59 #if LONG_MAX == 0x7fffffff
  60   {"2147483647", 2147483647, 0, 0, 0},
  61   {"2147483648", 2147483647, 0, 0, ERANGE},
  62   {"214748364888", 2147483647, 0, 0, ERANGE},
  63   {"2147483650", 2147483647, 0, 0, ERANGE},
  64   {"-2147483648", 0x80000000, 0, 0, 0},
  65   {"-2147483649", 0x80000000, 0, 0, ERANGE},
  66   {"0x1122334455z", 2147483647, 16, 'z', ERANGE},
  67 #else
  68   {"9223372036854775807", 9223372036854775807, 0, 0, 0},
  69   {"9223372036854775808", 9223372036854775807, 0, 0, ERANGE},
  70   {"922337203685477580777", 9223372036854775807, 0, 0, ERANGE},
  71   {"9223372036854775810", 9223372036854775807, 0, 0, ERANGE},
  72   {"-2147483648", -2147483648, 0, 0, 0},
  73   {"-9223372036854775808", -9223372036854775808, 0, 0, 0},
  74   {"-9223372036854775809", -9223372036854775808, 0, 0, ERANGE},
  75   {"0x112233445566778899z", 9223372036854775807, 16, 'z', ERANGE},
  76 #endif
  77   {NULL, 0, 0, 0, 0},
  78
  79   /* Then unsigned.  */
  80   {"  0", 0, 0, 0, 0},
  81   {"0xffffffffg", 0xffffffff, 0, 'g', 0},
  82 #if LONG_MAX == 0x7fffffff
  83   {"-0xfedcba98", 0x01234568, 0, 0, 0},
  84   {"0xf1f2f3f4f5", 0xffffffff, 0, 0, ERANGE},
  85   {"-0x123456789", 0xffffffff, 0, 0, ERANGE},
  86 #else
  87   {"0xffffffffffffffffg", 0xffffffffffffffff, 0, 'g', 0},
  88   {"-0xfedcba987654321", 0xf0123456789abcdf, 0, 0, 0},
  89   {"0xf1f2f3f4f5f6f7f8f9", 0xffffffffffffffff, 0, 0, ERANGE},
  90   {"-0x123456789abcdef01", 0xffffffffffffffff, 0, 0, ERANGE},
  91 #endif
  92   {NULL, 0, 0, 0, 0},
  93   };
  94
  95 /* Prototypes for local functions.  */
  96 static void expand (char *dst, int c);
  97
  98 int
  99 main (void)
 100 {
 101   register const struct ltest *lt;
 102   char *ep;
 103   int status = 0;
 104   int save_errno;
 105
 106   for (lt = tests; lt->str != NULL; ++lt)
 107     {
 108       register long int l;
 109
 110       errno = 0;
 111       l = strtol (lt->str, &ep, lt->base);
 112       save_errno = errno;
 113       printf ("strtol(\"%s\", , %d) test %u",
 114               lt->str, lt->base, (unsigned int) (lt - tests));
 115       if (l == (long int) lt->expect && *ep == lt->left
 116           && save_errno == lt->err)
 117         puts("\tOK");
 118       else
 119         {
 120           puts("\tBAD");
 121           if (l != (long int) lt->expect)
 122             printf("  returns %ld, expected %ld\n",
 123                    l, (long int) lt->expect);
 124           if (lt->left != *ep)
 125             {
 126               char exp1[5], exp2[5];
 127               expand (exp1, *ep);
 128               expand (exp2, lt->left);
 129               printf ("  leaves '%s', expected '%s'\n", exp1, exp2);
 130             }
 131           if (save_errno != lt->err)
 132             printf ("  errno %d (%s)  instead of %d (%s)\n",
 133                     save_errno, strerror (save_errno),
 134                     lt->err, strerror (lt->err));
 135           status = 1;
 136         }
 137     }
 138
 139   for (++lt; lt->str != NULL; lt++)
 140     {
 141       register unsigned long int ul;
 142
 143       errno = 0;
 144       ul = strtoul (lt->str, &ep, lt->base);
 145       save_errno = errno;
 146       printf ("strtoul(\"%s\", , %d) test %u",
 147               lt->str, lt->base, (unsigned int) (lt - tests));
 148       if (ul == lt->expect && *ep == lt->left && save_errno == lt->err)
 149         puts("\tOK");
 150       else
 151         {
 152           puts ("\tBAD");
 153           if (ul != lt->expect)
 154             printf ("  returns %lu, expected %lu\n",
 155                     ul, lt->expect);
 156           if (lt->left != *ep)
 157             {
 158               char exp1[5], exp2[5];
 159               expand (exp1, *ep);
 160               expand (exp2, lt->left);
 161               printf ("  leaves '%s', expected '%s'\n", exp1, exp2);
 162             }
 163           if (save_errno != lt->err)
 164             printf ("  errno %d (%s) instead of %d (%s)\n",
 165                     save_errno, strerror (save_errno),
 166                     lt->err, strerror (lt->err));
 167           status = 1;
 168         }
 169     }
 170
 171   exit (status ? EXIT_FAILURE : EXIT_SUCCESS);
 172 }
 173
 174 static void
 175 expand (dst, c)
 176      char *dst;
 177      int c;
 178 {
 179   if (isprint (c))
 180     {
 181       dst[0] = c;
 182       dst[1] = '\0';
 183     }
 184   else
 185     (void) sprintf (dst, "%#.3o", (unsigned int) c);
 186 }