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	"math"
9	"math/rand"
10	. "strconv"
11	"testing"
12)
13
14type ftoaTest struct {
15	f    float64
16	fmt  byte
17	prec int
18	s    string
19}
20
21func fdiv(a, b float64) float64 { return a / b }
22
23const (
24	below1e23 = 99999999999999974834176
25	above1e23 = 100000000000000008388608
26)
27
28var ftoatests = []ftoaTest{
29	{1, 'e', 5, "1.00000e+00"},
30	{1, 'f', 5, "1.00000"},
31	{1, 'g', 5, "1"},
32	{1, 'g', -1, "1"},
33	{1, 'x', -1, "0x1p+00"},
34	{1, 'x', 5, "0x1.00000p+00"},
35	{20, 'g', -1, "20"},
36	{20, 'x', -1, "0x1.4p+04"},
37	{1234567.8, 'g', -1, "1.2345678e+06"},
38	{1234567.8, 'x', -1, "0x1.2d687cccccccdp+20"},
39	{200000, 'g', -1, "200000"},
40	{200000, 'x', -1, "0x1.86ap+17"},
41	{200000, 'X', -1, "0X1.86AP+17"},
42	{2000000, 'g', -1, "2e+06"},
43	{1e10, 'g', -1, "1e+10"},
44
45	// g conversion and zero suppression
46	{400, 'g', 2, "4e+02"},
47	{40, 'g', 2, "40"},
48	{4, 'g', 2, "4"},
49	{.4, 'g', 2, "0.4"},
50	{.04, 'g', 2, "0.04"},
51	{.004, 'g', 2, "0.004"},
52	{.0004, 'g', 2, "0.0004"},
53	{.00004, 'g', 2, "4e-05"},
54	{.000004, 'g', 2, "4e-06"},
55
56	{0, 'e', 5, "0.00000e+00"},
57	{0, 'f', 5, "0.00000"},
58	{0, 'g', 5, "0"},
59	{0, 'g', -1, "0"},
60	{0, 'x', 5, "0x0.00000p+00"},
61
62	{-1, 'e', 5, "-1.00000e+00"},
63	{-1, 'f', 5, "-1.00000"},
64	{-1, 'g', 5, "-1"},
65	{-1, 'g', -1, "-1"},
66
67	{12, 'e', 5, "1.20000e+01"},
68	{12, 'f', 5, "12.00000"},
69	{12, 'g', 5, "12"},
70	{12, 'g', -1, "12"},
71
72	{123456700, 'e', 5, "1.23457e+08"},
73	{123456700, 'f', 5, "123456700.00000"},
74	{123456700, 'g', 5, "1.2346e+08"},
75	{123456700, 'g', -1, "1.234567e+08"},
76
77	{1.2345e6, 'e', 5, "1.23450e+06"},
78	{1.2345e6, 'f', 5, "1234500.00000"},
79	{1.2345e6, 'g', 5, "1.2345e+06"},
80
81	// Round to even
82	{1.2345e6, 'e', 3, "1.234e+06"},
83	{1.2355e6, 'e', 3, "1.236e+06"},
84	{1.2345, 'f', 3, "1.234"},
85	{1.2355, 'f', 3, "1.236"},
86	{1234567890123456.5, 'e', 15, "1.234567890123456e+15"},
87	{1234567890123457.5, 'e', 15, "1.234567890123458e+15"},
88	{108678236358137.625, 'g', -1, "1.0867823635813762e+14"},
89
90	{1e23, 'e', 17, "9.99999999999999916e+22"},
91	{1e23, 'f', 17, "99999999999999991611392.00000000000000000"},
92	{1e23, 'g', 17, "9.9999999999999992e+22"},
93
94	{1e23, 'e', -1, "1e+23"},
95	{1e23, 'f', -1, "100000000000000000000000"},
96	{1e23, 'g', -1, "1e+23"},
97
98	{below1e23, 'e', 17, "9.99999999999999748e+22"},
99	{below1e23, 'f', 17, "99999999999999974834176.00000000000000000"},
100	{below1e23, 'g', 17, "9.9999999999999975e+22"},
101
102	{below1e23, 'e', -1, "9.999999999999997e+22"},
103	{below1e23, 'f', -1, "99999999999999970000000"},
104	{below1e23, 'g', -1, "9.999999999999997e+22"},
105
106	{above1e23, 'e', 17, "1.00000000000000008e+23"},
107	{above1e23, 'f', 17, "100000000000000008388608.00000000000000000"},
108	{above1e23, 'g', 17, "1.0000000000000001e+23"},
109
110	{above1e23, 'e', -1, "1.0000000000000001e+23"},
111	{above1e23, 'f', -1, "100000000000000010000000"},
112	{above1e23, 'g', -1, "1.0000000000000001e+23"},
113
114	{fdiv(5e-304, 1e20), 'g', -1, "5e-324"},   // avoid constant arithmetic
115	{fdiv(-5e-304, 1e20), 'g', -1, "-5e-324"}, // avoid constant arithmetic
116
117	{32, 'g', -1, "32"},
118	{32, 'g', 0, "3e+01"},
119
120	{100, 'x', -1, "0x1.9p+06"},
121	{100, 'y', -1, "%y"},
122
123	{math.NaN(), 'g', -1, "NaN"},
124	{-math.NaN(), 'g', -1, "NaN"},
125	{math.Inf(0), 'g', -1, "+Inf"},
126	{math.Inf(-1), 'g', -1, "-Inf"},
127	{-math.Inf(0), 'g', -1, "-Inf"},
128
129	{-1, 'b', -1, "-4503599627370496p-52"},
130
131	// fixed bugs
132	{0.9, 'f', 1, "0.9"},
133	{0.09, 'f', 1, "0.1"},
134	{0.0999, 'f', 1, "0.1"},
135	{0.05, 'f', 1, "0.1"},
136	{0.05, 'f', 0, "0"},
137	{0.5, 'f', 1, "0.5"},
138	{0.5, 'f', 0, "0"},
139	{1.5, 'f', 0, "2"},
140
141	// https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
142	{2.2250738585072012e-308, 'g', -1, "2.2250738585072014e-308"},
143	// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
144	{2.2250738585072011e-308, 'g', -1, "2.225073858507201e-308"},
145
146	// Issue 2625.
147	{383260575764816448, 'f', 0, "383260575764816448"},
148	{383260575764816448, 'g', -1, "3.8326057576481645e+17"},
149
150	// Issue 29491.
151	{498484681984085570, 'f', -1, "498484681984085570"},
152	{-5.8339553793802237e+23, 'g', -1, "-5.8339553793802237e+23"},
153
154	// Issue 52187
155	{123.45, '?', 0, "%?"},
156	{123.45, '?', 1, "%?"},
157	{123.45, '?', -1, "%?"},
158
159	// rounding
160	{2.275555555555555, 'x', -1, "0x1.23456789abcdep+01"},
161	{2.275555555555555, 'x', 0, "0x1p+01"},
162	{2.275555555555555, 'x', 2, "0x1.23p+01"},
163	{2.275555555555555, 'x', 16, "0x1.23456789abcde000p+01"},
164	{2.275555555555555, 'x', 21, "0x1.23456789abcde00000000p+01"},
165	{2.2755555510520935, 'x', -1, "0x1.2345678p+01"},
166	{2.2755555510520935, 'x', 6, "0x1.234568p+01"},
167	{2.275555431842804, 'x', -1, "0x1.2345668p+01"},
168	{2.275555431842804, 'x', 6, "0x1.234566p+01"},
169	{3.999969482421875, 'x', -1, "0x1.ffffp+01"},
170	{3.999969482421875, 'x', 4, "0x1.ffffp+01"},
171	{3.999969482421875, 'x', 3, "0x1.000p+02"},
172	{3.999969482421875, 'x', 2, "0x1.00p+02"},
173	{3.999969482421875, 'x', 1, "0x1.0p+02"},
174	{3.999969482421875, 'x', 0, "0x1p+02"},
175}
176
177func TestFtoa(t *testing.T) {
178	for i := 0; i < len(ftoatests); i++ {
179		test := &ftoatests[i]
180		s := FormatFloat(test.f, test.fmt, test.prec, 64)
181		if s != test.s {
182			t.Error("testN=64", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
183		}
184		x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 64)
185		if string(x) != "abc"+test.s {
186			t.Error("AppendFloat testN=64", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
187		}
188		if float64(float32(test.f)) == test.f && test.fmt != 'b' {
189			s := FormatFloat(test.f, test.fmt, test.prec, 32)
190			if s != test.s {
191				t.Error("testN=32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
192			}
193			x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 32)
194			if string(x) != "abc"+test.s {
195				t.Error("AppendFloat testN=32", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
196			}
197		}
198	}
199}
200
201func TestFtoaPowersOfTwo(t *testing.T) {
202	for exp := -2048; exp <= 2048; exp++ {
203		f := math.Ldexp(1, exp)
204		if !math.IsInf(f, 0) {
205			s := FormatFloat(f, 'e', -1, 64)
206			if x, _ := ParseFloat(s, 64); x != f {
207				t.Errorf("failed roundtrip %v => %s => %v", f, s, x)
208			}
209		}
210		f32 := float32(f)
211		if !math.IsInf(float64(f32), 0) {
212			s := FormatFloat(float64(f32), 'e', -1, 32)
213			if x, _ := ParseFloat(s, 32); float32(x) != f32 {
214				t.Errorf("failed roundtrip %v => %s => %v", f32, s, float32(x))
215			}
216		}
217	}
218}
219
220func TestFtoaRandom(t *testing.T) {
221	N := int(1e4)
222	if testing.Short() {
223		N = 100
224	}
225	t.Logf("testing %d random numbers with fast and slow FormatFloat", N)
226	for i := 0; i < N; i++ {
227		bits := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
228		x := math.Float64frombits(bits)
229
230		shortFast := FormatFloat(x, 'g', -1, 64)
231		SetOptimize(false)
232		shortSlow := FormatFloat(x, 'g', -1, 64)
233		SetOptimize(true)
234		if shortSlow != shortFast {
235			t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
236		}
237
238		prec := rand.Intn(12) + 5
239		shortFast = FormatFloat(x, 'e', prec, 64)
240		SetOptimize(false)
241		shortSlow = FormatFloat(x, 'e', prec, 64)
242		SetOptimize(true)
243		if shortSlow != shortFast {
244			t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
245		}
246	}
247}
248
249func TestFormatFloatInvalidBitSize(t *testing.T) {
250	defer func() {
251		if r := recover(); r == nil {
252			t.Fatalf("expected panic due to invalid bitSize")
253		}
254	}()
255	_ = FormatFloat(3.14, 'g', -1, 100)
256}
257
258var ftoaBenches = []struct {
259	name    string
260	float   float64
261	fmt     byte
262	prec    int
263	bitSize int
264}{
265	{"Decimal", 33909, 'g', -1, 64},
266	{"Float", 339.7784, 'g', -1, 64},
267	{"Exp", -5.09e75, 'g', -1, 64},
268	{"NegExp", -5.11e-95, 'g', -1, 64},
269	{"LongExp", 1.234567890123456e-78, 'g', -1, 64},
270
271	{"Big", 123456789123456789123456789, 'g', -1, 64},
272	{"BinaryExp", -1, 'b', -1, 64},
273
274	{"32Integer", 33909, 'g', -1, 32},
275	{"32ExactFraction", 3.375, 'g', -1, 32},
276	{"32Point", 339.7784, 'g', -1, 32},
277	{"32Exp", -5.09e25, 'g', -1, 32},
278	{"32NegExp", -5.11e-25, 'g', -1, 32},
279	{"32Shortest", 1.234567e-8, 'g', -1, 32},
280	{"32Fixed8Hard", math.Ldexp(15961084, -125), 'e', 8, 32},
281	{"32Fixed9Hard", math.Ldexp(14855922, -83), 'e', 9, 32},
282
283	{"64Fixed1", 123456, 'e', 3, 64},
284	{"64Fixed2", 123.456, 'e', 3, 64},
285	{"64Fixed3", 1.23456e+78, 'e', 3, 64},
286	{"64Fixed4", 1.23456e-78, 'e', 3, 64},
287	{"64Fixed12", 1.23456e-78, 'e', 12, 64},
288	{"64Fixed16", 1.23456e-78, 'e', 16, 64},
289	// From testdata/testfp.txt
290	{"64Fixed12Hard", math.Ldexp(6965949469487146, -249), 'e', 12, 64},
291	{"64Fixed17Hard", math.Ldexp(8887055249355788, 665), 'e', 17, 64},
292	{"64Fixed18Hard", math.Ldexp(6994187472632449, 690), 'e', 18, 64},
293
294	// Trigger slow path (see issue #15672).
295	// The shortest is: 8.034137530808823e+43
296	{"Slowpath64", 8.03413753080882349e+43, 'e', -1, 64},
297	// This denormal is pathological because the lower/upper
298	// halfways to neighboring floats are:
299	// 622666234635.321003e-320 ~= 622666234635.321e-320
300	// 622666234635.321497e-320 ~= 622666234635.3215e-320
301	// making it hard to find the 3rd digit
302	{"SlowpathDenormal64", 622666234635.3213e-320, 'e', -1, 64},
303}
304
305func BenchmarkFormatFloat(b *testing.B) {
306	for _, c := range ftoaBenches {
307		b.Run(c.name, func(b *testing.B) {
308			for i := 0; i < b.N; i++ {
309				FormatFloat(c.float, c.fmt, c.prec, c.bitSize)
310			}
311		})
312	}
313}
314
315func BenchmarkAppendFloat(b *testing.B) {
316	dst := make([]byte, 30)
317	for _, c := range ftoaBenches {
318		b.Run(c.name, func(b *testing.B) {
319			for i := 0; i < b.N; i++ {
320				AppendFloat(dst[:0], c.float, c.fmt, c.prec, c.bitSize)
321			}
322		})
323	}
324}
325