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 const smallInt = 42 204 for i := 0; i < b.N; i++ { 205 s := FormatInt(smallInt, 10) 206 BenchSink += len(s) 207 } 208 } 209 210 func BenchmarkAppendIntSmall(b *testing.B) { 211 dst := make([]byte, 0, 30) 212 const smallInt = 42 213 for i := 0; i < b.N; i++ { 214 dst = AppendInt(dst[:0], smallInt, 10) 215 BenchSink += len(dst) 216 } 217 } 218 219 func BenchmarkAppendUintVarlen(b *testing.B) { 220 for _, test := range varlenUints { 221 b.Run(test.out, func(b *testing.B) { 222 dst := make([]byte, 0, 30) 223 for j := 0; j < b.N; j++ { 224 dst = AppendUint(dst[:0], test.in, 10) 225 BenchSink += len(dst) 226 } 227 }) 228 } 229 } 230 231 var BenchSink int // make sure compiler cannot optimize away benchmarks 232
