Black Lives Matter. Support the Equal Justice Initiative.

# Source file src/strconv/ftoa_test.go

## Documentation: strconv

```     1  // Copyright 2009 The Go Authors. All rights reserved.
2  // Use of this source code is governed by a BSD-style
4
5  package strconv_test
6
7  import (
8  	"math"
9  	"math/rand"
10  	. "strconv"
11  	"testing"
12  )
13
14  type ftoaTest struct {
15  	f    float64
16  	fmt  byte
17  	prec int
18  	s    string
19  }
20
21  func fdiv(a, b float64) float64 { return a / b }
22
23  const (
24  	below1e23 = 99999999999999974834176
25  	above1e23 = 100000000000000008388608
26  )
27
28  var 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  	// rounding
155  	{2.275555555555555, 'x', -1, "0x1.23456789abcdep+01"},
156  	{2.275555555555555, 'x', 0, "0x1p+01"},
157  	{2.275555555555555, 'x', 2, "0x1.23p+01"},
158  	{2.275555555555555, 'x', 16, "0x1.23456789abcde000p+01"},
159  	{2.275555555555555, 'x', 21, "0x1.23456789abcde00000000p+01"},
160  	{2.2755555510520935, 'x', -1, "0x1.2345678p+01"},
161  	{2.2755555510520935, 'x', 6, "0x1.234568p+01"},
162  	{2.275555431842804, 'x', -1, "0x1.2345668p+01"},
163  	{2.275555431842804, 'x', 6, "0x1.234566p+01"},
164  	{3.999969482421875, 'x', -1, "0x1.ffffp+01"},
165  	{3.999969482421875, 'x', 4, "0x1.ffffp+01"},
166  	{3.999969482421875, 'x', 3, "0x1.000p+02"},
167  	{3.999969482421875, 'x', 2, "0x1.00p+02"},
168  	{3.999969482421875, 'x', 1, "0x1.0p+02"},
169  	{3.999969482421875, 'x', 0, "0x1p+02"},
170  }
171
172  func TestFtoa(t *testing.T) {
173  	for i := 0; i < len(ftoatests); i++ {
174  		test := &ftoatests[i]
175  		s := FormatFloat(test.f, test.fmt, test.prec, 64)
176  		if s != test.s {
177  			t.Error("testN=64", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
178  		}
179  		x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 64)
180  		if string(x) != "abc"+test.s {
181  			t.Error("AppendFloat testN=64", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
182  		}
183  		if float64(float32(test.f)) == test.f && test.fmt != 'b' {
184  			s := FormatFloat(test.f, test.fmt, test.prec, 32)
185  			if s != test.s {
186  				t.Error("testN=32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
187  			}
188  			x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 32)
189  			if string(x) != "abc"+test.s {
190  				t.Error("AppendFloat testN=32", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
191  			}
192  		}
193  	}
194  }
195
196  func TestFtoaPowersOfTwo(t *testing.T) {
197  	for exp := -2048; exp <= 2048; exp++ {
198  		f := math.Ldexp(1, exp)
199  		if !math.IsInf(f, 0) {
200  			s := FormatFloat(f, 'e', -1, 64)
201  			if x, _ := ParseFloat(s, 64); x != f {
202  				t.Errorf("failed roundtrip %v => %s => %v", f, s, x)
203  			}
204  		}
205  		f32 := float32(f)
206  		if !math.IsInf(float64(f32), 0) {
207  			s := FormatFloat(float64(f32), 'e', -1, 32)
208  			if x, _ := ParseFloat(s, 32); float32(x) != f32 {
209  				t.Errorf("failed roundtrip %v => %s => %v", f32, s, float32(x))
210  			}
211  		}
212  	}
213  }
214
215  func TestFtoaRandom(t *testing.T) {
216  	N := int(1e4)
217  	if testing.Short() {
218  		N = 100
219  	}
220  	t.Logf("testing %d random numbers with fast and slow FormatFloat", N)
221  	for i := 0; i < N; i++ {
222  		bits := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
223  		x := math.Float64frombits(bits)
224
225  		shortFast := FormatFloat(x, 'g', -1, 64)
226  		SetOptimize(false)
227  		shortSlow := FormatFloat(x, 'g', -1, 64)
228  		SetOptimize(true)
229  		if shortSlow != shortFast {
230  			t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
231  		}
232
233  		prec := rand.Intn(12) + 5
234  		shortFast = FormatFloat(x, 'e', prec, 64)
235  		SetOptimize(false)
236  		shortSlow = FormatFloat(x, 'e', prec, 64)
237  		SetOptimize(true)
238  		if shortSlow != shortFast {
239  			t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
240  		}
241  	}
242  }
243
244  func TestFormatFloatInvalidBitSize(t *testing.T) {
245  	defer func() {
246  		if r := recover(); r == nil {
247  			t.Fatalf("expected panic due to invalid bitSize")
248  		}
249  	}()
250  	_ = FormatFloat(3.14, 'g', -1, 100)
251  }
252
253  var ftoaBenches = []struct {
254  	name    string
255  	float   float64
256  	fmt     byte
257  	prec    int
258  	bitSize int
259  }{
260  	{"Decimal", 33909, 'g', -1, 64},
261  	{"Float", 339.7784, 'g', -1, 64},
262  	{"Exp", -5.09e75, 'g', -1, 64},
263  	{"NegExp", -5.11e-95, 'g', -1, 64},
264  	{"LongExp", 1.234567890123456e-78, 'g', -1, 64},
265
266  	{"Big", 123456789123456789123456789, 'g', -1, 64},
267  	{"BinaryExp", -1, 'b', -1, 64},
268
269  	{"32Integer", 33909, 'g', -1, 32},
270  	{"32ExactFraction", 3.375, 'g', -1, 32},
271  	{"32Point", 339.7784, 'g', -1, 32},
272  	{"32Exp", -5.09e25, 'g', -1, 32},
273  	{"32NegExp", -5.11e-25, 'g', -1, 32},
274  	{"32Shortest", 1.234567e-8, 'g', -1, 32},
275  	{"32Fixed8Hard", math.Ldexp(15961084, -125), 'e', 8, 32},
276  	{"32Fixed9Hard", math.Ldexp(14855922, -83), 'e', 9, 32},
277
278  	{"64Fixed1", 123456, 'e', 3, 64},
279  	{"64Fixed2", 123.456, 'e', 3, 64},
280  	{"64Fixed3", 1.23456e+78, 'e', 3, 64},
281  	{"64Fixed4", 1.23456e-78, 'e', 3, 64},
282  	{"64Fixed12", 1.23456e-78, 'e', 12, 64},
283  	{"64Fixed16", 1.23456e-78, 'e', 16, 64},
284  	// From testdata/testfp.txt
285  	{"64Fixed12Hard", math.Ldexp(6965949469487146, -249), 'e', 12, 64},
286  	{"64Fixed17Hard", math.Ldexp(8887055249355788, 665), 'e', 17, 64},
287  	{"64Fixed18Hard", math.Ldexp(6994187472632449, 690), 'e', 18, 64},
288
289  	// Trigger slow path (see issue #15672).
290  	// The shortest is: 8.034137530808823e+43
291  	{"Slowpath64", 8.03413753080882349e+43, 'e', -1, 64},
292  	// This denormal is pathological because the lower/upper
293  	// halfways to neighboring floats are:
294  	// 622666234635.321003e-320 ~= 622666234635.321e-320
295  	// 622666234635.321497e-320 ~= 622666234635.3215e-320
296  	// making it hard to find the 3rd digit
297  	{"SlowpathDenormal64", 622666234635.3213e-320, 'e', -1, 64},
298  }
299
300  func BenchmarkFormatFloat(b *testing.B) {
301  	for _, c := range ftoaBenches {
302  		b.Run(c.name, func(b *testing.B) {
303  			for i := 0; i < b.N; i++ {
304  				FormatFloat(c.float, c.fmt, c.prec, c.bitSize)
305  			}
306  		})
307  	}
308  }
309
310  func BenchmarkAppendFloat(b *testing.B) {
311  	dst := make([]byte, 30)
312  	for _, c := range ftoaBenches {
313  		b.Run(c.name, func(b *testing.B) {
314  			for i := 0; i < b.N; i++ {
315  				AppendFloat(dst[:0], c.float, c.fmt, c.prec, c.bitSize)
316  			}
317  		})
318  	}
319  }
320
```

View as plain text