libgo/go/strconv/atoi_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package strconv_test
   6
   7 import (
   8         "errors"
   9         "reflect"
  10         . "strconv"
  11         "testing"
  12 )
  13
  14 type atoui64Test struct {
  15         in  string
  16         out uint64
  17         err error
  18 }
  19
  20 var atoui64tests = []atoui64Test{
  21         {"", 0, ErrSyntax},
  22         {"0", 0, nil},
  23         {"1", 1, nil},
  24         {"12345", 12345, nil},
  25         {"012345", 12345, nil},
  26         {"12345x", 0, ErrSyntax},
  27         {"98765432100", 98765432100, nil},
  28         {"18446744073709551615", 1<<64 - 1, nil},
  29         {"18446744073709551616", 1<<64 - 1, ErrRange},
  30         {"18446744073709551620", 1<<64 - 1, ErrRange},
  31 }
  32
  33 var btoui64tests = []atoui64Test{
  34         {"", 0, ErrSyntax},
  35         {"0", 0, nil},
  36         {"1", 1, nil},
  37         {"12345", 12345, nil},
  38         {"012345", 012345, nil},
  39         {"0x12345", 0x12345, nil},
  40         {"0X12345", 0x12345, nil},
  41         {"12345x", 0, ErrSyntax},
  42         {"98765432100", 98765432100, nil},
  43         {"18446744073709551615", 1<<64 - 1, nil},
  44         {"18446744073709551616", 1<<64 - 1, ErrRange},
  45         {"18446744073709551620", 1<<64 - 1, ErrRange},
  46         {"0xFFFFFFFFFFFFFFFF", 1<<64 - 1, nil},
  47         {"0x10000000000000000", 1<<64 - 1, ErrRange},
  48         {"01777777777777777777777", 1<<64 - 1, nil},
  49         {"01777777777777777777778", 0, ErrSyntax},
  50         {"02000000000000000000000", 1<<64 - 1, ErrRange},
  51         {"0200000000000000000000", 1 << 61, nil},
  52 }
  53
  54 type atoi64Test struct {
  55         in  string
  56         out int64
  57         err error
  58 }
  59
  60 var atoi64tests = []atoi64Test{
  61         {"", 0, ErrSyntax},
  62         {"0", 0, nil},
  63         {"-0", 0, nil},
  64         {"1", 1, nil},
  65         {"-1", -1, nil},
  66         {"12345", 12345, nil},
  67         {"-12345", -12345, nil},
  68         {"012345", 12345, nil},
  69         {"-012345", -12345, nil},
  70         {"98765432100", 98765432100, nil},
  71         {"-98765432100", -98765432100, nil},
  72         {"9223372036854775807", 1<<63 - 1, nil},
  73         {"-9223372036854775807", -(1<<63 - 1), nil},
  74         {"9223372036854775808", 1<<63 - 1, ErrRange},
  75         {"-9223372036854775808", -1 << 63, nil},
  76         {"9223372036854775809", 1<<63 - 1, ErrRange},
  77         {"-9223372036854775809", -1 << 63, ErrRange},
  78 }
  79
  80 var btoi64tests = []atoi64Test{
  81         {"", 0, ErrSyntax},
  82         {"0", 0, nil},
  83         {"-0", 0, nil},
  84         {"1", 1, nil},
  85         {"-1", -1, nil},
  86         {"12345", 12345, nil},
  87         {"-12345", -12345, nil},
  88         {"012345", 012345, nil},
  89         {"-012345", -012345, nil},
  90         {"0x12345", 0x12345, nil},
  91         {"-0X12345", -0x12345, nil},
  92         {"12345x", 0, ErrSyntax},
  93         {"-12345x", 0, ErrSyntax},
  94         {"98765432100", 98765432100, nil},
  95         {"-98765432100", -98765432100, nil},
  96         {"9223372036854775807", 1<<63 - 1, nil},
  97         {"-9223372036854775807", -(1<<63 - 1), nil},
  98         {"9223372036854775808", 1<<63 - 1, ErrRange},
  99         {"-9223372036854775808", -1 << 63, nil},
 100         {"9223372036854775809", 1<<63 - 1, ErrRange},
 101         {"-9223372036854775809", -1 << 63, ErrRange},
 102 }
 103
 104 type atoui32Test struct {
 105         in  string
 106         out uint32
 107         err error
 108 }
 109
 110 var atoui32tests = []atoui32Test{
 111         {"", 0, ErrSyntax},
 112         {"0", 0, nil},
 113         {"1", 1, nil},
 114         {"12345", 12345, nil},
 115         {"012345", 12345, nil},
 116         {"12345x", 0, ErrSyntax},
 117         {"987654321", 987654321, nil},
 118         {"4294967295", 1<<32 - 1, nil},
 119         {"4294967296", 1<<32 - 1, ErrRange},
 120 }
 121
 122 type atoi32Test struct {
 123         in  string
 124         out int32
 125         err error
 126 }
 127
 128 var atoi32tests = []atoi32Test{
 129         {"", 0, ErrSyntax},
 130         {"0", 0, nil},
 131         {"-0", 0, nil},
 132         {"1", 1, nil},
 133         {"-1", -1, nil},
 134         {"12345", 12345, nil},
 135         {"-12345", -12345, nil},
 136         {"012345", 12345, nil},
 137         {"-012345", -12345, nil},
 138         {"12345x", 0, ErrSyntax},
 139         {"-12345x", 0, ErrSyntax},
 140         {"987654321", 987654321, nil},
 141         {"-987654321", -987654321, nil},
 142         {"2147483647", 1<<31 - 1, nil},
 143         {"-2147483647", -(1<<31 - 1), nil},
 144         {"2147483648", 1<<31 - 1, ErrRange},
 145         {"-2147483648", -1 << 31, nil},
 146         {"2147483649", 1<<31 - 1, ErrRange},
 147         {"-2147483649", -1 << 31, ErrRange},
 148 }
 149
 150 type numErrorTest struct {
 151         num, want string
 152 }
 153
 154 var numErrorTests = []numErrorTest{
 155         {"0", `strconv.ParseFloat: parsing "0": failed`},
 156         {"`", "strconv.ParseFloat: parsing \"`\": failed"},
 157         {"1\x00.2", `strconv.ParseFloat: parsing "1\x00.2": failed`},
 158 }
 159
 160 func init() {
 161         // The atoi routines return NumErrors wrapping
 162         // the error and the string.  Convert the tables above.
 163         for i := range atoui64tests {
 164                 test := &atoui64tests[i]
 165                 if test.err != nil {
 166                         test.err = &NumError{"ParseUint", test.in, test.err}
 167                 }
 168         }
 169         for i := range btoui64tests {
 170                 test := &btoui64tests[i]
 171                 if test.err != nil {
 172                         test.err = &NumError{"ParseUint", test.in, test.err}
 173                 }
 174         }
 175         for i := range atoi64tests {
 176                 test := &atoi64tests[i]
 177                 if test.err != nil {
 178                         test.err = &NumError{"ParseInt", test.in, test.err}
 179                 }
 180         }
 181         for i := range btoi64tests {
 182                 test := &btoi64tests[i]
 183                 if test.err != nil {
 184                         test.err = &NumError{"ParseInt", test.in, test.err}
 185                 }
 186         }
 187         for i := range atoui32tests {
 188                 test := &atoui32tests[i]
 189                 if test.err != nil {
 190                         test.err = &NumError{"ParseUint", test.in, test.err}
 191                 }
 192         }
 193         for i := range atoi32tests {
 194                 test := &atoi32tests[i]
 195                 if test.err != nil {
 196                         test.err = &NumError{"ParseInt", test.in, test.err}
 197                 }
 198         }
 199 }
 200
 201 func TestParseUint64(t *testing.T) {
 202         for i := range atoui64tests {
 203                 test := &atoui64tests[i]
 204                 out, err := ParseUint(test.in, 10, 64)
 205                 if test.out != out || !reflect.DeepEqual(test.err, err) {
 206                         t.Errorf("Atoui64(%q) = %v, %v want %v, %v",
 207                                 test.in, out, err, test.out, test.err)
 208                 }
 209         }
 210 }
 211
 212 func TestParseUint64Base(t *testing.T) {
 213         for i := range btoui64tests {
 214                 test := &btoui64tests[i]
 215                 out, err := ParseUint(test.in, 0, 64)
 216                 if test.out != out || !reflect.DeepEqual(test.err, err) {
 217                         t.Errorf("ParseUint(%q) = %v, %v want %v, %v",
 218                                 test.in, out, err, test.out, test.err)
 219                 }
 220         }
 221 }
 222
 223 func TestParseInt64(t *testing.T) {
 224         for i := range atoi64tests {
 225                 test := &atoi64tests[i]
 226                 out, err := ParseInt(test.in, 10, 64)
 227                 if test.out != out || !reflect.DeepEqual(test.err, err) {
 228                         t.Errorf("Atoi64(%q) = %v, %v want %v, %v",
 229                                 test.in, out, err, test.out, test.err)
 230                 }
 231         }
 232 }
 233
 234 func TestParseInt64Base(t *testing.T) {
 235         for i := range btoi64tests {
 236                 test := &btoi64tests[i]
 237                 out, err := ParseInt(test.in, 0, 64)
 238                 if test.out != out || !reflect.DeepEqual(test.err, err) {
 239                         t.Errorf("ParseInt(%q) = %v, %v want %v, %v",
 240                                 test.in, out, err, test.out, test.err)
 241                 }
 242         }
 243 }
 244
 245 func TestParseUint(t *testing.T) {
 246         switch IntSize {
 247         case 32:
 248                 for i := range atoui32tests {
 249                         test := &atoui32tests[i]
 250                         out, err := ParseUint(test.in, 10, 0)
 251                         if test.out != uint32(out) || !reflect.DeepEqual(test.err, err) {
 252                                 t.Errorf("Atoui(%q) = %v, %v want %v, %v",
 253                                         test.in, out, err, test.out, test.err)
 254                         }
 255                 }
 256         case 64:
 257                 for i := range atoui64tests {
 258                         test := &atoui64tests[i]
 259                         out, err := ParseUint(test.in, 10, 0)
 260                         if test.out != uint64(out) || !reflect.DeepEqual(test.err, err) {
 261                                 t.Errorf("Atoui(%q) = %v, %v want %v, %v",
 262                                         test.in, out, err, test.out, test.err)
 263                         }
 264                 }
 265         }
 266 }
 267
 268 func TestParseInt(t *testing.T) {
 269         switch IntSize {
 270         case 32:
 271                 for i := range atoi32tests {
 272                         test := &atoi32tests[i]
 273                         out, err := ParseInt(test.in, 10, 0)
 274                         if test.out != int32(out) || !reflect.DeepEqual(test.err, err) {
 275                                 t.Errorf("Atoi(%q) = %v, %v want %v, %v",
 276                                         test.in, out, err, test.out, test.err)
 277                         }
 278                 }
 279         case 64:
 280                 for i := range atoi64tests {
 281                         test := &atoi64tests[i]
 282                         out, err := ParseInt(test.in, 10, 0)
 283                         if test.out != int64(out) || !reflect.DeepEqual(test.err, err) {
 284                                 t.Errorf("Atoi(%q) = %v, %v want %v, %v",
 285                                         test.in, out, err, test.out, test.err)
 286                         }
 287                 }
 288         }
 289 }
 290
 291 func TestNumError(t *testing.T) {
 292         for _, test := range numErrorTests {
 293                 err := &NumError{
 294                         Func: "ParseFloat",
 295                         Num:  test.num,
 296                         Err:  errors.New("failed"),
 297                 }
 298                 if got := err.Error(); got != test.want {
 299                         t.Errorf(`(&NumError{"ParseFloat", %q, "failed"}).Error() = %v, want %v`, test.num, got, test.want)
 300                 }
 301         }
 302 }
 303
 304 func BenchmarkAtoi(b *testing.B) {
 305         for i := 0; i < b.N; i++ {
 306                 ParseInt("12345678", 10, 0)
 307         }
 308 }
 309
 310 func BenchmarkAtoiNeg(b *testing.B) {
 311         for i := 0; i < b.N; i++ {
 312                 ParseInt("-12345678", 10, 0)
 313         }
 314 }
 315
 316 func BenchmarkAtoi64(b *testing.B) {
 317         for i := 0; i < b.N; i++ {
 318                 ParseInt("12345678901234", 10, 64)
 319         }
 320 }
 321
 322 func BenchmarkAtoi64Neg(b *testing.B) {
 323         for i := 0; i < b.N; i++ {
 324                 ParseInt("-12345678901234", 10, 64)
 325         }
 326 }