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
5package strconv_test
6
7import (
8	. "strconv"
9	"testing"
10)
11
12type itob64Test struct {
13	in   int64
14	base int
15	out  string
16}
17
18var 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
62func 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
98type uitob64Test struct {
99	in   uint64
100	base int
101	out  string
102}
103
104var 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
113func 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
129func BenchmarkFormatInt(b *testing.B) {
130	for i := 0; i < b.N; i++ {
131		for _, test := range itob64tests {
132			FormatInt(test.in, test.base)
133		}
134	}
135}
136
137func BenchmarkAppendInt(b *testing.B) {
138	dst := make([]byte, 0, 30)
139	for i := 0; i < b.N; i++ {
140		for _, test := range itob64tests {
141			AppendInt(dst, test.in, test.base)
142		}
143	}
144}
145
146func BenchmarkFormatUint(b *testing.B) {
147	for i := 0; i < b.N; i++ {
148		for _, test := range uitob64tests {
149			FormatUint(test.in, test.base)
150		}
151	}
152}
153
154func BenchmarkAppendUint(b *testing.B) {
155	dst := make([]byte, 0, 30)
156	for i := 0; i < b.N; i++ {
157		for _, test := range uitob64tests {
158			AppendUint(dst, test.in, test.base)
159		}
160	}
161}
162