maint/gnulib/tests/test-strtol.c

/* */
This source file includes following definitions.
main
   1 /*
   2  * Copyright (C) 2011-2021 Free Software Foundation, Inc.
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16 
  17 #include <config.h>
  18 
  19 #include <stdlib.h>
  20 
  21 #include "signature.h"
  22 #ifndef strtol
  23 SIGNATURE_CHECK (strtol, long, (const char *, char **, int));
  24 #endif
  25 
  26 #include <errno.h>
  27 
  28 #include "macros.h"
  29 
  30 int
  31 main (void)
     /*  */
  32 {
  33   /* Subject sequence empty or invalid.  */
  34   {
  35     const char input[] = "";
  36     char *ptr;
  37     long result;
  38     errno = 0;
  39     result = strtol (input, &ptr, 10);
  40     ASSERT (result == 0);
  41     ASSERT (ptr == input);
  42     ASSERT (errno == 0 || errno == EINVAL);
  43   }
  44   {
  45     const char input[] = " ";
  46     char *ptr;
  47     long result;
  48     errno = 0;
  49     result = strtol (input, &ptr, 10);
  50     ASSERT (result == 0);
  51     ASSERT (ptr == input);
  52     ASSERT (errno == 0 || errno == EINVAL);
  53   }
  54   {
  55     const char input[] = " +";
  56     char *ptr;
  57     long result;
  58     errno = 0;
  59     result = strtol (input, &ptr, 10);
  60     ASSERT (result == 0);
  61     ASSERT (ptr == input);
  62     ASSERT (errno == 0 || errno == EINVAL);
  63   }
  64   {
  65     const char input[] = " -";
  66     char *ptr;
  67     long result;
  68     errno = 0;
  69     result = strtol (input, &ptr, 10);
  70     ASSERT (result == 0);
  71     ASSERT (ptr == input);
  72     ASSERT (errno == 0 || errno == EINVAL);
  73   }
  74 
  75   /* Simple integer values.  */
  76   {
  77     const char input[] = "0";
  78     char *ptr;
  79     long result;
  80     errno = 0;
  81     result = strtol (input, &ptr, 10);
  82     ASSERT (result == 0);
  83     ASSERT (ptr == input + 1);
  84     ASSERT (errno == 0);
  85   }
  86   {
  87     const char input[] = "+0";
  88     char *ptr;
  89     long result;
  90     errno = 0;
  91     result = strtol (input, &ptr, 10);
  92     ASSERT (result == 0);
  93     ASSERT (ptr == input + 2);
  94     ASSERT (errno == 0);
  95   }
  96   {
  97     const char input[] = "-0";
  98     char *ptr;
  99     long result;
 100     errno = 0;
 101     result = strtol (input, &ptr, 10);
 102     ASSERT (result == 0);
 103     ASSERT (ptr == input + 2);
 104     ASSERT (errno == 0);
 105   }
 106   {
 107     const char input[] = "23";
 108     char *ptr;
 109     long result;
 110     errno = 0;
 111     result = strtol (input, &ptr, 10);
 112     ASSERT (result == 23);
 113     ASSERT (ptr == input + 2);
 114     ASSERT (errno == 0);
 115   }
 116   {
 117     const char input[] = " 23";
 118     char *ptr;
 119     long result;
 120     errno = 0;
 121     result = strtol (input, &ptr, 10);
 122     ASSERT (result == 23);
 123     ASSERT (ptr == input + 3);
 124     ASSERT (errno == 0);
 125   }
 126   {
 127     const char input[] = "+23";
 128     char *ptr;
 129     long result;
 130     errno = 0;
 131     result = strtol (input, &ptr, 10);
 132     ASSERT (result == 23);
 133     ASSERT (ptr == input + 3);
 134     ASSERT (errno == 0);
 135   }
 136   {
 137     const char input[] = "-23";
 138     char *ptr;
 139     long result;
 140     errno = 0;
 141     result = strtol (input, &ptr, 10);
 142     ASSERT (result == -23);
 143     ASSERT (ptr == input + 3);
 144     ASSERT (errno == 0);
 145   }
 146 
 147   /* Large integer values.  */
 148   {
 149     const char input[] = "2147483647";
 150     char *ptr;
 151     long result;
 152     errno = 0;
 153     result = strtol (input, &ptr, 10);
 154     ASSERT (result == 2147483647);
 155     ASSERT (ptr == input + 10);
 156     ASSERT (errno == 0);
 157   }
 158   {
 159     const char input[] = "-2147483648";
 160     char *ptr;
 161     long result;
 162     errno = 0;
 163     result = strtol (input, &ptr, 10);
 164     ASSERT (result == -2147483647 - 1);
 165     ASSERT (ptr == input + 11);
 166     ASSERT (errno == 0);
 167   }
 168   if (sizeof (long) > sizeof (int))
 169     {
 170       const char input[] = "4294967295";
 171       char *ptr;
 172       long result;
 173       errno = 0;
 174       result = strtol (input, &ptr, 10);
 175       ASSERT (result == (long) 4294967295UL);
 176       ASSERT (ptr == input + 10);
 177       ASSERT (errno == 0);
 178     }
 179 
 180   /* Hexadecimal integer syntax.  */
 181   {
 182     const char input[] = "0x2A";
 183     char *ptr;
 184     long result;
 185     errno = 0;
 186     result = strtol (input, &ptr, 10);
 187     ASSERT (result == 0L);
 188     ASSERT (ptr == input + 1);
 189     ASSERT (errno == 0);
 190   }
 191   {
 192     const char input[] = "0x2A";
 193     char *ptr;
 194     long result;
 195     errno = 0;
 196     result = strtol (input, &ptr, 16);
 197     ASSERT (result == 42L);
 198     ASSERT (ptr == input + 4);
 199     ASSERT (errno == 0);
 200   }
 201   {
 202     const char input[] = "0x2A";
 203     char *ptr;
 204     long result;
 205     errno = 0;
 206     result = strtol (input, &ptr, 0);
 207     ASSERT (result == 42L);
 208     ASSERT (ptr == input + 4);
 209     ASSERT (errno == 0);
 210   }
 211   {
 212     const char input[] = "0x";
 213     char *ptr;
 214     long result;
 215     errno = 0;
 216     result = strtol (input, &ptr, 10);
 217     ASSERT (result == 0L);
 218     ASSERT (ptr == input + 1);
 219     ASSERT (errno == 0);
 220   }
 221   {
 222     const char input[] = "0x";
 223     char *ptr;
 224     long result;
 225     errno = 0;
 226     result = strtol (input, &ptr, 16);
 227     ASSERT (result == 0L);
 228     ASSERT (ptr == input + 1);
 229     ASSERT (errno == 0);
 230   }
 231   {
 232     const char input[] = "0x";
 233     char *ptr;
 234     long result;
 235     errno = 0;
 236     result = strtol (input, &ptr, 0);
 237     ASSERT (result == 0L);
 238     ASSERT (ptr == input + 1);
 239     ASSERT (errno == 0);
 240   }
 241 
 242   return 0;
 243 }
/* */
root/maint/gnulib/tests/test-strtol.c

DEFINITIONS
