tests/test-strtol.c

   1 /*
   2  * Copyright (C) 2011-2014 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 <http://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 == 65535L * 65537L);
 176       ASSERT (ptr == input + 10);
 177       ASSERT (errno == 0);
 178     }
 179
 180   return 0;
 181 }