tests/test-strtol.c

   1 /*
   2  * Copyright (C) 2011-2024 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   /* Binary integer syntax.  */
 243   {
 244     const char input[] = "0b111010";
 245     char *ptr;
 246     long result;
 247     errno = 0;
 248     result = strtol (input, &ptr, 10);
 249     ASSERT (result == 0L);
 250     ASSERT (ptr == input + 1);
 251     ASSERT (errno == 0);
 252   }
 253   {
 254     const char input[] = "0b111010";
 255     char *ptr;
 256     long result;
 257     errno = 0;
 258     result = strtol (input, &ptr, 2);
 259     ASSERT (result == 58L);
 260     ASSERT (ptr == input + 8);
 261     ASSERT (errno == 0);
 262   }
 263   {
 264     const char input[] = "0b111010";
 265     char *ptr;
 266     long result;
 267     errno = 0;
 268     result = strtol (input, &ptr, 0);
 269     ASSERT (result == 58L);
 270     ASSERT (ptr == input + 8);
 271     ASSERT (errno == 0);
 272   }
 273   {
 274     const char input[] = "0b";
 275     char *ptr;
 276     long result;
 277     errno = 0;
 278     result = strtol (input, &ptr, 10);
 279     ASSERT (result == 0L);
 280     ASSERT (ptr == input + 1);
 281     ASSERT (errno == 0);
 282   }
 283   {
 284     const char input[] = "0b";
 285     char *ptr;
 286     long result;
 287     errno = 0;
 288     result = strtol (input, &ptr, 2);
 289     ASSERT (result == 0L);
 290     ASSERT (ptr == input + 1);
 291     ASSERT (errno == 0);
 292   }
 293   {
 294     const char input[] = "0b";
 295     char *ptr;
 296     long result;
 297     errno = 0;
 298     result = strtol (input, &ptr, 0);
 299     ASSERT (result == 0L);
 300     ASSERT (ptr == input + 1);
 301     ASSERT (errno == 0);
 302   }
 303
 304   return test_exit_status;
 305 }