libgo/go/strconv/itoa_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         . "strconv"
   9         "testing"
  10 )
  11
  12 type itob64Test struct {
  13         in   int64
  14         base int
  15         out  string
  16 }
  17
  18 var itob64tests = []itob64Test{
  19         {0, 10, "0"},
  20         {1, 10, "1"},
  21         {-1, 10, "-1"},
  22         {12345678, 10, "12345678"},
  23         {-987654321, 10, "-987654321"},
  24         {1<<31 - 1, 10, "2147483647"},
  25         {-1<<31 + 1, 10, "-2147483647"},
  26         {1 << 31, 10, "2147483648"},
  27         {-1 << 31, 10, "-2147483648"},
  28         {1<<31 + 1, 10, "2147483649"},
  29         {-1<<31 - 1, 10, "-2147483649"},
  30         {1<<32 - 1, 10, "4294967295"},
  31         {-1<<32 + 1, 10, "-4294967295"},
  32         {1 << 32, 10, "4294967296"},
  33         {-1 << 32, 10, "-4294967296"},
  34         {1<<32 + 1, 10, "4294967297"},
  35         {-1<<32 - 1, 10, "-4294967297"},
  36         {1 << 50, 10, "1125899906842624"},
  37         {1<<63 - 1, 10, "9223372036854775807"},
  38         {-1<<63 + 1, 10, "-9223372036854775807"},
  39         {-1 << 63, 10, "-9223372036854775808"},
  40
  41         {0, 2, "0"},
  42         {10, 2, "1010"},
  43         {-1, 2, "-1"},
  44         {1 << 15, 2, "1000000000000000"},
  45
  46         {-8, 8, "-10"},
  47         {057635436545, 8, "57635436545"},
  48         {1 << 24, 8, "100000000"},
  49
  50         {16, 16, "10"},
  51         {-0x123456789abcdef, 16, "-123456789abcdef"},
  52         {1<<63 - 1, 16, "7fffffffffffffff"},
  53         {1<<63 - 1, 2, "111111111111111111111111111111111111111111111111111111111111111"},
  54         {-1 << 63, 2, "-1000000000000000000000000000000000000000000000000000000000000000"},
  55
  56         {16, 17, "g"},
  57         {25, 25, "10"},
  58         {(((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35 + 32, 35, "holycow"},
  59         {(((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36 + 32, 36, "holycow"},
  60 }
  61
  62 func TestItoa(t *testing.T) {
  63         for _, test := range itob64tests {
  64                 s := FormatInt(test.in, test.base)
  65                 if s != test.out {
  66                         t.Errorf("FormatInt(%v, %v) = %v want %v",
  67                                 test.in, test.base, s, test.out)
  68                 }
  69                 x := AppendInt([]byte("abc"), test.in, test.base)
  70                 if string(x) != "abc"+test.out {
  71                         t.Errorf("AppendInt(%q, %v, %v) = %q want %v",
  72                                 "abc", test.in, test.base, x, test.out)
  73                 }
  74
  75                 if test.in >= 0 {
  76                         s := FormatUint(uint64(test.in), test.base)
  77                         if s != test.out {
  78                                 t.Errorf("FormatUint(%v, %v) = %v want %v",
  79                                         test.in, test.base, s, test.out)
  80                         }
  81                         x := AppendUint(nil, uint64(test.in), test.base)
  82                         if string(x) != test.out {
  83                                 t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
  84                                         "abc", uint64(test.in), test.base, x, test.out)
  85                         }
  86                 }
  87
  88                 if test.base == 10 && int64(int(test.in)) == test.in {
  89                         s := Itoa(int(test.in))
  90                         if s != test.out {
  91                                 t.Errorf("Itoa(%v) = %v want %v",
  92                                         test.in, s, test.out)
  93                         }
  94                 }
  95         }
  96 }
  97
  98 type uitob64Test struct {
  99         in   uint64
 100         base int
 101         out  string
 102 }
 103
 104 var uitob64tests = []uitob64Test{
 105         {1<<63 - 1, 10, "9223372036854775807"},
 106         {1 << 63, 10, "9223372036854775808"},
 107         {1<<63 + 1, 10, "9223372036854775809"},
 108         {1<<64 - 2, 10, "18446744073709551614"},
 109         {1<<64 - 1, 10, "18446744073709551615"},
 110         {1<<64 - 1, 2, "1111111111111111111111111111111111111111111111111111111111111111"},
 111 }
 112
 113 func TestUitoa(t *testing.T) {
 114         for _, test := range uitob64tests {
 115                 s := FormatUint(test.in, test.base)
 116                 if s != test.out {
 117                         t.Errorf("FormatUint(%v, %v) = %v want %v",
 118                                 test.in, test.base, s, test.out)
 119                 }
 120                 x := AppendUint([]byte("abc"), test.in, test.base)
 121                 if string(x) != "abc"+test.out {
 122                         t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
 123                                 "abc", test.in, test.base, x, test.out)
 124                 }
 125
 126         }
 127 }
 128
 129 var varlenUints = []struct {
 130         in  uint64
 131         out string
 132 }{
 133         {1, "1"},
 134         {12, "12"},
 135         {123, "123"},
 136         {1234, "1234"},
 137         {12345, "12345"},
 138         {123456, "123456"},
 139         {1234567, "1234567"},
 140         {12345678, "12345678"},
 141         {123456789, "123456789"},
 142         {1234567890, "1234567890"},
 143         {12345678901, "12345678901"},
 144         {123456789012, "123456789012"},
 145         {1234567890123, "1234567890123"},
 146         {12345678901234, "12345678901234"},
 147         {123456789012345, "123456789012345"},
 148         {1234567890123456, "1234567890123456"},
 149         {12345678901234567, "12345678901234567"},
 150         {123456789012345678, "123456789012345678"},
 151         {1234567890123456789, "1234567890123456789"},
 152         {12345678901234567890, "12345678901234567890"},
 153 }
 154
 155 func TestFormatUintVarlen(t *testing.T) {
 156         for _, test := range varlenUints {
 157                 s := FormatUint(test.in, 10)
 158                 if s != test.out {
 159                         t.Errorf("FormatUint(%v, 10) = %v want %v", test.in, s, test.out)
 160                 }
 161         }
 162 }
 163
 164 func BenchmarkFormatInt(b *testing.B) {
 165         for i := 0; i < b.N; i++ {
 166                 for _, test := range itob64tests {
 167                         s := FormatInt(test.in, test.base)
 168                         BenchSink += len(s)
 169                 }
 170         }
 171 }
 172
 173 func BenchmarkAppendInt(b *testing.B) {
 174         dst := make([]byte, 0, 30)
 175         for i := 0; i < b.N; i++ {
 176                 for _, test := range itob64tests {
 177                         dst = AppendInt(dst[:0], test.in, test.base)
 178                         BenchSink += len(dst)
 179                 }
 180         }
 181 }
 182
 183 func BenchmarkFormatUint(b *testing.B) {
 184         for i := 0; i < b.N; i++ {
 185                 for _, test := range uitob64tests {
 186                         s := FormatUint(test.in, test.base)
 187                         BenchSink += len(s)
 188                 }
 189         }
 190 }
 191
 192 func BenchmarkAppendUint(b *testing.B) {
 193         dst := make([]byte, 0, 30)
 194         for i := 0; i < b.N; i++ {
 195                 for _, test := range uitob64tests {
 196                         dst = AppendUint(dst[:0], test.in, test.base)
 197                         BenchSink += len(dst)
 198                 }
 199         }
 200 }
 201
 202 func BenchmarkFormatIntSmall(b *testing.B) {
 203         smallInts := []int64{7, 42}
 204         for _, smallInt := range smallInts {
 205                 b.Run(Itoa(int(smallInt)), func(b *testing.B) {
 206                         for i := 0; i < b.N; i++ {
 207                                 s := FormatInt(smallInt, 10)
 208                                 BenchSink += len(s)
 209                         }
 210                 })
 211         }
 212 }
 213
 214 func BenchmarkAppendIntSmall(b *testing.B) {
 215         dst := make([]byte, 0, 30)
 216         const smallInt = 42
 217         for i := 0; i < b.N; i++ {
 218                 dst = AppendInt(dst[:0], smallInt, 10)
 219                 BenchSink += len(dst)
 220         }
 221 }
 222
 223 func BenchmarkAppendUintVarlen(b *testing.B) {
 224         for _, test := range varlenUints {
 225                 b.Run(test.out, func(b *testing.B) {
 226                         dst := make([]byte, 0, 30)
 227                         for j := 0; j < b.N; j++ {
 228                                 dst = AppendUint(dst[:0], test.in, 10)
 229                                 BenchSink += len(dst)
 230                         }
 231                 })
 232         }
 233 }
 234
 235 var BenchSink int // make sure compiler cannot optimize away benchmarks