github.com/ice-blockchain/go/src@v0.0.0-20240403114104-1564d284e521/strconv/itoa_test.go (about) 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 // Override when base is illegal 98 defer func() { 99 if r := recover(); r == nil { 100 t.Fatalf("expected panic due to illegal base") 101 } 102 }() 103 FormatUint(12345678, 1) 104 } 105 106 type uitob64Test struct { 107 in uint64 108 base int 109 out string 110 } 111 112 var uitob64tests = []uitob64Test{ 113 {1<<63 - 1, 10, "9223372036854775807"}, 114 {1 << 63, 10, "9223372036854775808"}, 115 {1<<63 + 1, 10, "9223372036854775809"}, 116 {1<<64 - 2, 10, "18446744073709551614"}, 117 {1<<64 - 1, 10, "18446744073709551615"}, 118 {1<<64 - 1, 2, "1111111111111111111111111111111111111111111111111111111111111111"}, 119 } 120 121 func TestUitoa(t *testing.T) { 122 for _, test := range uitob64tests { 123 s := FormatUint(test.in, test.base) 124 if s != test.out { 125 t.Errorf("FormatUint(%v, %v) = %v want %v", 126 test.in, test.base, s, test.out) 127 } 128 x := AppendUint([]byte("abc"), test.in, test.base) 129 if string(x) != "abc"+test.out { 130 t.Errorf("AppendUint(%q, %v, %v) = %q want %v", 131 "abc", test.in, test.base, x, test.out) 132 } 133 134 } 135 } 136 137 var varlenUints = []struct { 138 in uint64 139 out string 140 }{ 141 {1, "1"}, 142 {12, "12"}, 143 {123, "123"}, 144 {1234, "1234"}, 145 {12345, "12345"}, 146 {123456, "123456"}, 147 {1234567, "1234567"}, 148 {12345678, "12345678"}, 149 {123456789, "123456789"}, 150 {1234567890, "1234567890"}, 151 {12345678901, "12345678901"}, 152 {123456789012, "123456789012"}, 153 {1234567890123, "1234567890123"}, 154 {12345678901234, "12345678901234"}, 155 {123456789012345, "123456789012345"}, 156 {1234567890123456, "1234567890123456"}, 157 {12345678901234567, "12345678901234567"}, 158 {123456789012345678, "123456789012345678"}, 159 {1234567890123456789, "1234567890123456789"}, 160 {12345678901234567890, "12345678901234567890"}, 161 } 162 163 func TestFormatUintVarlen(t *testing.T) { 164 for _, test := range varlenUints { 165 s := FormatUint(test.in, 10) 166 if s != test.out { 167 t.Errorf("FormatUint(%v, 10) = %v want %v", test.in, s, test.out) 168 } 169 } 170 } 171 172 func BenchmarkFormatInt(b *testing.B) { 173 for i := 0; i < b.N; i++ { 174 for _, test := range itob64tests { 175 s := FormatInt(test.in, test.base) 176 BenchSink += len(s) 177 } 178 } 179 } 180 181 func BenchmarkAppendInt(b *testing.B) { 182 dst := make([]byte, 0, 30) 183 for i := 0; i < b.N; i++ { 184 for _, test := range itob64tests { 185 dst = AppendInt(dst[:0], test.in, test.base) 186 BenchSink += len(dst) 187 } 188 } 189 } 190 191 func BenchmarkFormatUint(b *testing.B) { 192 for i := 0; i < b.N; i++ { 193 for _, test := range uitob64tests { 194 s := FormatUint(test.in, test.base) 195 BenchSink += len(s) 196 } 197 } 198 } 199 200 func BenchmarkAppendUint(b *testing.B) { 201 dst := make([]byte, 0, 30) 202 for i := 0; i < b.N; i++ { 203 for _, test := range uitob64tests { 204 dst = AppendUint(dst[:0], test.in, test.base) 205 BenchSink += len(dst) 206 } 207 } 208 } 209 210 func BenchmarkFormatIntSmall(b *testing.B) { 211 smallInts := []int64{7, 42} 212 for _, smallInt := range smallInts { 213 b.Run(Itoa(int(smallInt)), func(b *testing.B) { 214 for i := 0; i < b.N; i++ { 215 s := FormatInt(smallInt, 10) 216 BenchSink += len(s) 217 } 218 }) 219 } 220 } 221 222 func BenchmarkAppendIntSmall(b *testing.B) { 223 dst := make([]byte, 0, 30) 224 const smallInt = 42 225 for i := 0; i < b.N; i++ { 226 dst = AppendInt(dst[:0], smallInt, 10) 227 BenchSink += len(dst) 228 } 229 } 230 231 func BenchmarkAppendUintVarlen(b *testing.B) { 232 for _, test := range varlenUints { 233 b.Run(test.out, func(b *testing.B) { 234 dst := make([]byte, 0, 30) 235 for j := 0; j < b.N; j++ { 236 dst = AppendUint(dst[:0], test.in, 10) 237 BenchSink += len(dst) 238 } 239 }) 240 } 241 } 242 243 var BenchSink int // make sure compiler cannot optimize away benchmarks