Source file
src/strconv/atof_test.go
Documentation: strconv
1
2
3
4
5 package strconv_test
6
7 import (
8 "math"
9 "math/rand"
10 "reflect"
11 . "strconv"
12 "strings"
13 "sync"
14 "testing"
15 "time"
16 )
17
18 type atofTest struct {
19 in string
20 out string
21 err error
22 }
23
24 var atoftests = []atofTest{
25 {"", "0", ErrSyntax},
26 {"1", "1", nil},
27 {"+1", "1", nil},
28 {"1x", "0", ErrSyntax},
29 {"1.1.", "0", ErrSyntax},
30 {"1e23", "1e+23", nil},
31 {"1E23", "1e+23", nil},
32 {"100000000000000000000000", "1e+23", nil},
33 {"1e-100", "1e-100", nil},
34 {"123456700", "1.234567e+08", nil},
35 {"99999999999999974834176", "9.999999999999997e+22", nil},
36 {"100000000000000000000001", "1.0000000000000001e+23", nil},
37 {"100000000000000008388608", "1.0000000000000001e+23", nil},
38 {"100000000000000016777215", "1.0000000000000001e+23", nil},
39 {"100000000000000016777216", "1.0000000000000003e+23", nil},
40 {"-1", "-1", nil},
41 {"-0.1", "-0.1", nil},
42 {"-0", "-0", nil},
43 {"1e-20", "1e-20", nil},
44 {"625e-3", "0.625", nil},
45
46
47 {"0x1p0", "1", nil},
48 {"0x1p1", "2", nil},
49 {"0x1p-1", "0.5", nil},
50 {"0x1ep-1", "15", nil},
51 {"-0x1ep-1", "-15", nil},
52 {"-0x1_ep-1", "-15", nil},
53 {"0x1p-200", "6.223015277861142e-61", nil},
54 {"0x1p200", "1.6069380442589903e+60", nil},
55 {"0x1fFe2.p0", "131042", nil},
56 {"0x1fFe2.P0", "131042", nil},
57 {"-0x2p3", "-16", nil},
58 {"0x0.fp4", "15", nil},
59 {"0x0.fp0", "0.9375", nil},
60 {"0x1e2", "0", ErrSyntax},
61 {"1p2", "0", ErrSyntax},
62
63
64 {"0", "0", nil},
65 {"0e0", "0", nil},
66 {"-0e0", "-0", nil},
67 {"+0e0", "0", nil},
68 {"0e-0", "0", nil},
69 {"-0e-0", "-0", nil},
70 {"+0e-0", "0", nil},
71 {"0e+0", "0", nil},
72 {"-0e+0", "-0", nil},
73 {"+0e+0", "0", nil},
74 {"0e+01234567890123456789", "0", nil},
75 {"0.00e-01234567890123456789", "0", nil},
76 {"-0e+01234567890123456789", "-0", nil},
77 {"-0.00e-01234567890123456789", "-0", nil},
78 {"0x0p+01234567890123456789", "0", nil},
79 {"0x0.00p-01234567890123456789", "0", nil},
80 {"-0x0p+01234567890123456789", "-0", nil},
81 {"-0x0.00p-01234567890123456789", "-0", nil},
82
83 {"0e291", "0", nil},
84 {"0e292", "0", nil},
85 {"0e347", "0", nil},
86 {"0e348", "0", nil},
87 {"-0e291", "-0", nil},
88 {"-0e292", "-0", nil},
89 {"-0e347", "-0", nil},
90 {"-0e348", "-0", nil},
91 {"0x0p126", "0", nil},
92 {"0x0p127", "0", nil},
93 {"0x0p128", "0", nil},
94 {"0x0p129", "0", nil},
95 {"0x0p130", "0", nil},
96 {"0x0p1022", "0", nil},
97 {"0x0p1023", "0", nil},
98 {"0x0p1024", "0", nil},
99 {"0x0p1025", "0", nil},
100 {"0x0p1026", "0", nil},
101 {"-0x0p126", "-0", nil},
102 {"-0x0p127", "-0", nil},
103 {"-0x0p128", "-0", nil},
104 {"-0x0p129", "-0", nil},
105 {"-0x0p130", "-0", nil},
106 {"-0x0p1022", "-0", nil},
107 {"-0x0p1023", "-0", nil},
108 {"-0x0p1024", "-0", nil},
109 {"-0x0p1025", "-0", nil},
110 {"-0x0p1026", "-0", nil},
111
112
113 {"nan", "NaN", nil},
114 {"NaN", "NaN", nil},
115 {"NAN", "NaN", nil},
116
117
118 {"inf", "+Inf", nil},
119 {"-Inf", "-Inf", nil},
120 {"+INF", "+Inf", nil},
121 {"-Infinity", "-Inf", nil},
122 {"+INFINITY", "+Inf", nil},
123 {"Infinity", "+Inf", nil},
124
125
126 {"1.7976931348623157e308", "1.7976931348623157e+308", nil},
127 {"-1.7976931348623157e308", "-1.7976931348623157e+308", nil},
128 {"0x1.fffffffffffffp1023", "1.7976931348623157e+308", nil},
129 {"-0x1.fffffffffffffp1023", "-1.7976931348623157e+308", nil},
130 {"0x1fffffffffffffp+971", "1.7976931348623157e+308", nil},
131 {"-0x1fffffffffffffp+971", "-1.7976931348623157e+308", nil},
132 {"0x.1fffffffffffffp1027", "1.7976931348623157e+308", nil},
133 {"-0x.1fffffffffffffp1027", "-1.7976931348623157e+308", nil},
134
135
136 {"1.7976931348623159e308", "+Inf", ErrRange},
137 {"-1.7976931348623159e308", "-Inf", ErrRange},
138 {"0x1p1024", "+Inf", ErrRange},
139 {"-0x1p1024", "-Inf", ErrRange},
140 {"0x2p1023", "+Inf", ErrRange},
141 {"-0x2p1023", "-Inf", ErrRange},
142 {"0x.1p1028", "+Inf", ErrRange},
143 {"-0x.1p1028", "-Inf", ErrRange},
144 {"0x.2p1027", "+Inf", ErrRange},
145 {"-0x.2p1027", "-Inf", ErrRange},
146
147
148
149 {"1.7976931348623158e308", "1.7976931348623157e+308", nil},
150 {"-1.7976931348623158e308", "-1.7976931348623157e+308", nil},
151 {"0x1.fffffffffffff7fffp1023", "1.7976931348623157e+308", nil},
152 {"-0x1.fffffffffffff7fffp1023", "-1.7976931348623157e+308", nil},
153
154 {"1.797693134862315808e308", "+Inf", ErrRange},
155 {"-1.797693134862315808e308", "-Inf", ErrRange},
156 {"0x1.fffffffffffff8p1023", "+Inf", ErrRange},
157 {"-0x1.fffffffffffff8p1023", "-Inf", ErrRange},
158 {"0x1fffffffffffff.8p+971", "+Inf", ErrRange},
159 {"-0x1fffffffffffff8p+967", "-Inf", ErrRange},
160 {"0x.1fffffffffffff8p1027", "+Inf", ErrRange},
161 {"-0x.1fffffffffffff9p1027", "-Inf", ErrRange},
162
163
164 {"1e308", "1e+308", nil},
165 {"2e308", "+Inf", ErrRange},
166 {"1e309", "+Inf", ErrRange},
167 {"0x1p1025", "+Inf", ErrRange},
168
169
170 {"1e310", "+Inf", ErrRange},
171 {"-1e310", "-Inf", ErrRange},
172 {"1e400", "+Inf", ErrRange},
173 {"-1e400", "-Inf", ErrRange},
174 {"1e400000", "+Inf", ErrRange},
175 {"-1e400000", "-Inf", ErrRange},
176 {"0x1p1030", "+Inf", ErrRange},
177 {"0x1p2000", "+Inf", ErrRange},
178 {"0x1p2000000000", "+Inf", ErrRange},
179 {"-0x1p1030", "-Inf", ErrRange},
180 {"-0x1p2000", "-Inf", ErrRange},
181 {"-0x1p2000000000", "-Inf", ErrRange},
182
183
184 {"1e-305", "1e-305", nil},
185 {"1e-306", "1e-306", nil},
186 {"1e-307", "1e-307", nil},
187 {"1e-308", "1e-308", nil},
188 {"1e-309", "1e-309", nil},
189 {"1e-310", "1e-310", nil},
190 {"1e-322", "1e-322", nil},
191
192 {"5e-324", "5e-324", nil},
193 {"4e-324", "5e-324", nil},
194 {"3e-324", "5e-324", nil},
195
196 {"2e-324", "0", nil},
197
198 {"1e-350", "0", nil},
199 {"1e-400000", "0", nil},
200
201
202 {"0x2.00000000000000p-1010", "1.8227805048890994e-304", nil},
203 {"0x1.fffffffffffff0p-1010", "1.8227805048890992e-304", nil},
204 {"0x1.fffffffffffff7p-1010", "1.8227805048890992e-304", nil},
205 {"0x1.fffffffffffff8p-1010", "1.8227805048890994e-304", nil},
206 {"0x1.fffffffffffff9p-1010", "1.8227805048890994e-304", nil},
207
208 {"0x2.00000000000000p-1022", "4.450147717014403e-308", nil},
209 {"0x1.fffffffffffff0p-1022", "4.4501477170144023e-308", nil},
210 {"0x1.fffffffffffff7p-1022", "4.4501477170144023e-308", nil},
211 {"0x1.fffffffffffff8p-1022", "4.450147717014403e-308", nil},
212 {"0x1.fffffffffffff9p-1022", "4.450147717014403e-308", nil},
213
214 {"0x1.00000000000000p-1022", "2.2250738585072014e-308", nil},
215 {"0x0.fffffffffffff0p-1022", "2.225073858507201e-308", nil},
216 {"0x0.ffffffffffffe0p-1022", "2.2250738585072004e-308", nil},
217 {"0x0.ffffffffffffe7p-1022", "2.2250738585072004e-308", nil},
218 {"0x1.ffffffffffffe8p-1023", "2.225073858507201e-308", nil},
219 {"0x1.ffffffffffffe9p-1023", "2.225073858507201e-308", nil},
220
221 {"0x0.00000003fffff0p-1022", "2.072261e-317", nil},
222 {"0x0.00000003456780p-1022", "1.694649e-317", nil},
223 {"0x0.00000003456787p-1022", "1.694649e-317", nil},
224 {"0x0.00000003456788p-1022", "1.694649e-317", nil},
225 {"0x0.00000003456790p-1022", "1.6946496e-317", nil},
226 {"0x0.00000003456789p-1022", "1.6946496e-317", nil},
227
228 {"0x0.0000000345678800000000000000000000000001p-1022", "1.6946496e-317", nil},
229
230 {"0x0.000000000000f0p-1022", "7.4e-323", nil},
231 {"0x0.00000000000060p-1022", "3e-323", nil},
232 {"0x0.00000000000058p-1022", "3e-323", nil},
233 {"0x0.00000000000057p-1022", "2.5e-323", nil},
234 {"0x0.00000000000050p-1022", "2.5e-323", nil},
235
236 {"0x0.00000000000010p-1022", "5e-324", nil},
237 {"0x0.000000000000081p-1022", "5e-324", nil},
238 {"0x0.00000000000008p-1022", "0", nil},
239 {"0x0.00000000000007fp-1022", "0", nil},
240
241
242 {"1e-4294967296", "0", nil},
243 {"1e+4294967296", "+Inf", ErrRange},
244 {"1e-18446744073709551616", "0", nil},
245 {"1e+18446744073709551616", "+Inf", ErrRange},
246 {"0x1p-4294967296", "0", nil},
247 {"0x1p+4294967296", "+Inf", ErrRange},
248 {"0x1p-18446744073709551616", "0", nil},
249 {"0x1p+18446744073709551616", "+Inf", ErrRange},
250
251
252 {"1e", "0", ErrSyntax},
253 {"1e-", "0", ErrSyntax},
254 {".e-1", "0", ErrSyntax},
255 {"1\x00.2", "0", ErrSyntax},
256 {"0x", "0", ErrSyntax},
257 {"0x.", "0", ErrSyntax},
258 {"0x1", "0", ErrSyntax},
259 {"0x.1", "0", ErrSyntax},
260 {"0x1p", "0", ErrSyntax},
261 {"0x.1p", "0", ErrSyntax},
262 {"0x1p+", "0", ErrSyntax},
263 {"0x.1p+", "0", ErrSyntax},
264 {"0x1p-", "0", ErrSyntax},
265 {"0x.1p-", "0", ErrSyntax},
266 {"0x1p+2", "4", nil},
267 {"0x.1p+2", "0.25", nil},
268 {"0x1p-2", "0.25", nil},
269 {"0x.1p-2", "0.015625", nil},
270
271
272 {"2.2250738585072012e-308", "2.2250738585072014e-308", nil},
273
274 {"2.2250738585072011e-308", "2.225073858507201e-308", nil},
275
276
277 {"4.630813248087435e+307", "4.630813248087435e+307", nil},
278
279
280 {"22.222222222222222", "22.22222222222222", nil},
281 {"2." + strings.Repeat("2", 4000) + "e+1", "22.22222222222222", nil},
282 {"0x1.1111111111111p222", "7.18931911124017e+66", nil},
283 {"0x2.2222222222222p221", "7.18931911124017e+66", nil},
284 {"0x2." + strings.Repeat("2", 4000) + "p221", "7.18931911124017e+66", nil},
285
286
287
288 {"1.00000000000000011102230246251565404236316680908203125", "1", nil},
289 {"0x1.00000000000008p0", "1", nil},
290
291 {"1.00000000000000011102230246251565404236316680908203124", "1", nil},
292 {"0x1.00000000000007Fp0", "1", nil},
293
294 {"1.00000000000000011102230246251565404236316680908203126", "1.0000000000000002", nil},
295 {"0x1.000000000000081p0", "1.0000000000000002", nil},
296 {"0x1.00000000000009p0", "1.0000000000000002", nil},
297
298 {"1.00000000000000011102230246251565404236316680908203125" + strings.Repeat("0", 10000) + "1", "1.0000000000000002", nil},
299 {"0x1.00000000000008" + strings.Repeat("0", 10000) + "1p0", "1.0000000000000002", nil},
300
301
302
303 {"1.00000000000000033306690738754696212708950042724609375", "1.0000000000000004", nil},
304 {"0x1.00000000000018p0", "1.0000000000000004", nil},
305
306
307
308 {"1090544144181609348671888949248", "1.0905441441816093e+30", nil},
309
310 {"1090544144181609348835077142190", "1.0905441441816094e+30", nil},
311
312
313 {"1_23.50_0_0e+1_2", "1.235e+14", nil},
314 {"-_123.5e+12", "0", ErrSyntax},
315 {"+_123.5e+12", "0", ErrSyntax},
316 {"_123.5e+12", "0", ErrSyntax},
317 {"1__23.5e+12", "0", ErrSyntax},
318 {"123_.5e+12", "0", ErrSyntax},
319 {"123._5e+12", "0", ErrSyntax},
320 {"123.5_e+12", "0", ErrSyntax},
321 {"123.5__0e+12", "0", ErrSyntax},
322 {"123.5e_+12", "0", ErrSyntax},
323 {"123.5e+_12", "0", ErrSyntax},
324 {"123.5e_-12", "0", ErrSyntax},
325 {"123.5e-_12", "0", ErrSyntax},
326 {"123.5e+1__2", "0", ErrSyntax},
327 {"123.5e+12_", "0", ErrSyntax},
328
329 {"0x_1_2.3_4_5p+1_2", "74565", nil},
330 {"-_0x12.345p+12", "0", ErrSyntax},
331 {"+_0x12.345p+12", "0", ErrSyntax},
332 {"_0x12.345p+12", "0", ErrSyntax},
333 {"0x__12.345p+12", "0", ErrSyntax},
334 {"0x1__2.345p+12", "0", ErrSyntax},
335 {"0x12_.345p+12", "0", ErrSyntax},
336 {"0x12._345p+12", "0", ErrSyntax},
337 {"0x12.3__45p+12", "0", ErrSyntax},
338 {"0x12.345_p+12", "0", ErrSyntax},
339 {"0x12.345p_+12", "0", ErrSyntax},
340 {"0x12.345p+_12", "0", ErrSyntax},
341 {"0x12.345p_-12", "0", ErrSyntax},
342 {"0x12.345p-_12", "0", ErrSyntax},
343 {"0x12.345p+1__2", "0", ErrSyntax},
344 {"0x12.345p+12_", "0", ErrSyntax},
345 }
346
347 var atof32tests = []atofTest{
348
349 {"0x1p-100", "7.888609e-31", nil},
350 {"0x1p100", "1.2676506e+30", nil},
351
352
353
354 {"1.000000059604644775390625", "1", nil},
355 {"0x1.000001p0", "1", nil},
356
357 {"1.000000059604644775390624", "1", nil},
358 {"0x1.0000008p0", "1", nil},
359 {"0x1.000000fp0", "1", nil},
360
361 {"1.000000059604644775390626", "1.0000001", nil},
362 {"0x1.000002p0", "1.0000001", nil},
363 {"0x1.0000018p0", "1.0000001", nil},
364 {"0x1.0000011p0", "1.0000001", nil},
365
366 {"1.000000059604644775390625" + strings.Repeat("0", 10000) + "1", "1.0000001", nil},
367 {"0x1.000001" + strings.Repeat("0", 10000) + "1p0", "1.0000001", nil},
368
369
370 {"340282346638528859811704183484516925440", "3.4028235e+38", nil},
371 {"-340282346638528859811704183484516925440", "-3.4028235e+38", nil},
372 {"0x.ffffffp128", "3.4028235e+38", nil},
373 {"-340282346638528859811704183484516925440", "-3.4028235e+38", nil},
374 {"-0x.ffffffp128", "-3.4028235e+38", nil},
375
376 {"3.4028236e38", "+Inf", ErrRange},
377 {"-3.4028236e38", "-Inf", ErrRange},
378 {"0x1.0p128", "+Inf", ErrRange},
379 {"-0x1.0p128", "-Inf", ErrRange},
380
381
382 {"3.402823567e38", "3.4028235e+38", nil},
383 {"-3.402823567e38", "-3.4028235e+38", nil},
384 {"0x.ffffff7fp128", "3.4028235e+38", nil},
385 {"-0x.ffffff7fp128", "-3.4028235e+38", nil},
386
387 {"3.4028235678e38", "+Inf", ErrRange},
388 {"-3.4028235678e38", "-Inf", ErrRange},
389 {"0x.ffffff8p128", "+Inf", ErrRange},
390 {"-0x.ffffff8p128", "-Inf", ErrRange},
391
392
393 {"1e-38", "1e-38", nil},
394 {"1e-39", "1e-39", nil},
395 {"1e-40", "1e-40", nil},
396 {"1e-41", "1e-41", nil},
397 {"1e-42", "1e-42", nil},
398 {"1e-43", "1e-43", nil},
399 {"1e-44", "1e-44", nil},
400 {"6e-45", "6e-45", nil},
401 {"5e-45", "6e-45", nil},
402
403
404 {"1e-45", "1e-45", nil},
405 {"2e-45", "1e-45", nil},
406 {"3e-45", "3e-45", nil},
407
408
409 {"0x0.89aBcDp-125", "1.2643093e-38", nil},
410 {"0x0.8000000p-125", "1.1754944e-38", nil},
411 {"0x0.1234560p-125", "1.671814e-39", nil},
412 {"0x0.1234567p-125", "1.671814e-39", nil},
413 {"0x0.1234568p-125", "1.671814e-39", nil},
414 {"0x0.1234569p-125", "1.671815e-39", nil},
415 {"0x0.1234570p-125", "1.671815e-39", nil},
416 {"0x0.0000010p-125", "1e-45", nil},
417 {"0x0.00000081p-125", "1e-45", nil},
418 {"0x0.0000008p-125", "0", nil},
419 {"0x0.0000007p-125", "0", nil},
420
421
422
423
424
425
426
427 {"4951760157141521099596496896", "4.9517602e+27", nil},
428 }
429
430 type atofSimpleTest struct {
431 x float64
432 s string
433 }
434
435 var (
436 atofOnce sync.Once
437 atofRandomTests []atofSimpleTest
438 benchmarksRandomBits [1024]string
439 benchmarksRandomNormal [1024]string
440 )
441
442 func initAtof() {
443 atofOnce.Do(initAtofOnce)
444 }
445
446 func initAtofOnce() {
447
448
449 for i := range atoftests {
450 test := &atoftests[i]
451 if test.err != nil {
452 test.err = &NumError{"ParseFloat", test.in, test.err}
453 }
454 }
455 for i := range atof32tests {
456 test := &atof32tests[i]
457 if test.err != nil {
458 test.err = &NumError{"ParseFloat", test.in, test.err}
459 }
460 }
461
462
463 rand.Seed(time.Now().UnixNano())
464 if testing.Short() {
465 atofRandomTests = make([]atofSimpleTest, 100)
466 } else {
467 atofRandomTests = make([]atofSimpleTest, 10000)
468 }
469 for i := range atofRandomTests {
470 n := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
471 x := math.Float64frombits(n)
472 s := FormatFloat(x, 'g', -1, 64)
473 atofRandomTests[i] = atofSimpleTest{x, s}
474 }
475
476 for i := range benchmarksRandomBits {
477 bits := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
478 x := math.Float64frombits(bits)
479 benchmarksRandomBits[i] = FormatFloat(x, 'g', -1, 64)
480 }
481
482 for i := range benchmarksRandomNormal {
483 x := rand.NormFloat64()
484 benchmarksRandomNormal[i] = FormatFloat(x, 'g', -1, 64)
485 }
486 }
487
488 func TestParseFloatPrefix(t *testing.T) {
489 for i := range atoftests {
490 test := &atoftests[i]
491 if test.err != nil {
492 continue
493 }
494
495
496
497 for _, suffix := range []string{" ", "q", "+", "-", "<", "=", ">", "(", ")", "i", "init"} {
498 in := test.in + suffix
499 _, n, err := ParseFloatPrefix(in, 64)
500 if err != nil {
501 t.Errorf("ParseFloatPrefix(%q, 64): err = %v; want no error", in, err)
502 }
503 if n != len(test.in) {
504 t.Errorf("ParseFloatPrefix(%q, 64): n = %d; want %d", in, n, len(test.in))
505 }
506 }
507 }
508 }
509
510 func testAtof(t *testing.T, opt bool) {
511 initAtof()
512 oldopt := SetOptimize(opt)
513 for i := 0; i < len(atoftests); i++ {
514 test := &atoftests[i]
515 out, err := ParseFloat(test.in, 64)
516 outs := FormatFloat(out, 'g', -1, 64)
517 if outs != test.out || !reflect.DeepEqual(err, test.err) {
518 t.Errorf("ParseFloat(%v, 64) = %v, %v want %v, %v",
519 test.in, out, err, test.out, test.err)
520 }
521
522 if float64(float32(out)) == out {
523 out, err := ParseFloat(test.in, 32)
524 out32 := float32(out)
525 if float64(out32) != out {
526 t.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test.in, out, float64(out32))
527 continue
528 }
529 outs := FormatFloat(float64(out32), 'g', -1, 32)
530 if outs != test.out || !reflect.DeepEqual(err, test.err) {
531 t.Errorf("ParseFloat(%v, 32) = %v, %v want %v, %v # %v",
532 test.in, out32, err, test.out, test.err, out)
533 }
534 }
535 }
536 for _, test := range atof32tests {
537 out, err := ParseFloat(test.in, 32)
538 out32 := float32(out)
539 if float64(out32) != out {
540 t.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test.in, out, float64(out32))
541 continue
542 }
543 outs := FormatFloat(float64(out32), 'g', -1, 32)
544 if outs != test.out || !reflect.DeepEqual(err, test.err) {
545 t.Errorf("ParseFloat(%v, 32) = %v, %v want %v, %v # %v",
546 test.in, out32, err, test.out, test.err, out)
547 }
548 }
549 SetOptimize(oldopt)
550 }
551
552 func TestAtof(t *testing.T) { testAtof(t, true) }
553
554 func TestAtofSlow(t *testing.T) { testAtof(t, false) }
555
556 func TestAtofRandom(t *testing.T) {
557 initAtof()
558 for _, test := range atofRandomTests {
559 x, _ := ParseFloat(test.s, 64)
560 switch {
561 default:
562 t.Errorf("number %s badly parsed as %b (expected %b)", test.s, x, test.x)
563 case x == test.x:
564 case math.IsNaN(test.x) && math.IsNaN(x):
565 }
566 }
567 t.Logf("tested %d random numbers", len(atofRandomTests))
568 }
569
570 var roundTripCases = []struct {
571 f float64
572 s string
573 }{
574
575
576
577
578
579
580 {8865794286000691 << 39, "4.87402195346389e+27"},
581 {8865794286000692 << 39, "4.8740219534638903e+27"},
582 }
583
584 func TestRoundTrip(t *testing.T) {
585 for _, tt := range roundTripCases {
586 old := SetOptimize(false)
587 s := FormatFloat(tt.f, 'g', -1, 64)
588 if s != tt.s {
589 t.Errorf("no-opt FormatFloat(%b) = %s, want %s", tt.f, s, tt.s)
590 }
591 f, err := ParseFloat(tt.s, 64)
592 if f != tt.f || err != nil {
593 t.Errorf("no-opt ParseFloat(%s) = %b, %v want %b, nil", tt.s, f, err, tt.f)
594 }
595 SetOptimize(true)
596 s = FormatFloat(tt.f, 'g', -1, 64)
597 if s != tt.s {
598 t.Errorf("opt FormatFloat(%b) = %s, want %s", tt.f, s, tt.s)
599 }
600 f, err = ParseFloat(tt.s, 64)
601 if f != tt.f || err != nil {
602 t.Errorf("opt ParseFloat(%s) = %b, %v want %b, nil", tt.s, f, err, tt.f)
603 }
604 SetOptimize(old)
605 }
606 }
607
608
609 func TestRoundTrip32(t *testing.T) {
610 step := uint32(997)
611 if testing.Short() {
612 step = 99991
613 }
614 count := 0
615 for i := uint32(0); i < 0xff<<23; i += step {
616 f := math.Float32frombits(i)
617 if i&1 == 1 {
618 f = -f
619 }
620 s := FormatFloat(float64(f), 'g', -1, 32)
621
622 parsed, err := ParseFloat(s, 32)
623 parsed32 := float32(parsed)
624 switch {
625 case err != nil:
626 t.Errorf("ParseFloat(%q, 32) gave error %s", s, err)
627 case float64(parsed32) != parsed:
628 t.Errorf("ParseFloat(%q, 32) = %v, not a float32 (nearest is %v)", s, parsed, parsed32)
629 case parsed32 != f:
630 t.Errorf("ParseFloat(%q, 32) = %b (expected %b)", s, parsed32, f)
631 }
632 count++
633 }
634 t.Logf("tested %d float32's", count)
635 }
636
637
638
639 func TestParseFloatIncorrectBitSize(t *testing.T) {
640 const s = "1.5e308"
641 const want = 1.5e308
642
643 for _, bitSize := range []int{0, 10, 100, 128} {
644 f, err := ParseFloat(s, bitSize)
645 if err != nil {
646 t.Fatalf("ParseFloat(%q, %d) gave error %s", s, bitSize, err)
647 }
648 if f != want {
649 t.Fatalf("ParseFloat(%q, %d) = %g (expected %g)", s, bitSize, f, want)
650 }
651 }
652 }
653
654 func BenchmarkAtof64Decimal(b *testing.B) {
655 for i := 0; i < b.N; i++ {
656 ParseFloat("33909", 64)
657 }
658 }
659
660 func BenchmarkAtof64Float(b *testing.B) {
661 for i := 0; i < b.N; i++ {
662 ParseFloat("339.7784", 64)
663 }
664 }
665
666 func BenchmarkAtof64FloatExp(b *testing.B) {
667 for i := 0; i < b.N; i++ {
668 ParseFloat("-5.09e75", 64)
669 }
670 }
671
672 func BenchmarkAtof64Big(b *testing.B) {
673 for i := 0; i < b.N; i++ {
674 ParseFloat("123456789123456789123456789", 64)
675 }
676 }
677
678 func BenchmarkAtof64RandomBits(b *testing.B) {
679 initAtof()
680 b.ResetTimer()
681 for i := 0; i < b.N; i++ {
682 ParseFloat(benchmarksRandomBits[i%1024], 64)
683 }
684 }
685
686 func BenchmarkAtof64RandomFloats(b *testing.B) {
687 initAtof()
688 b.ResetTimer()
689 for i := 0; i < b.N; i++ {
690 ParseFloat(benchmarksRandomNormal[i%1024], 64)
691 }
692 }
693
694 func BenchmarkAtof64RandomLongFloats(b *testing.B) {
695 initAtof()
696 samples := make([]string, len(atofRandomTests))
697 for i, t := range atofRandomTests {
698 samples[i] = FormatFloat(t.x, 'g', 20, 64)
699 }
700 b.ResetTimer()
701 idx := 0
702 for i := 0; i < b.N; i++ {
703 ParseFloat(samples[idx], 64)
704 idx++
705 if idx == len(samples) {
706 idx = 0
707 }
708 }
709 }
710
711 func BenchmarkAtof32Decimal(b *testing.B) {
712 for i := 0; i < b.N; i++ {
713 ParseFloat("33909", 32)
714 }
715 }
716
717 func BenchmarkAtof32Float(b *testing.B) {
718 for i := 0; i < b.N; i++ {
719 ParseFloat("339.778", 32)
720 }
721 }
722
723 func BenchmarkAtof32FloatExp(b *testing.B) {
724 for i := 0; i < b.N; i++ {
725 ParseFloat("12.3456e32", 32)
726 }
727 }
728
729 func BenchmarkAtof32Random(b *testing.B) {
730 n := uint32(997)
731 var float32strings [4096]string
732 for i := range float32strings {
733 n = (99991*n + 42) % (0xff << 23)
734 float32strings[i] = FormatFloat(float64(math.Float32frombits(n)), 'g', -1, 32)
735 }
736 b.ResetTimer()
737 for i := 0; i < b.N; i++ {
738 ParseFloat(float32strings[i%4096], 32)
739 }
740 }
741
742 func BenchmarkAtof32RandomLong(b *testing.B) {
743 n := uint32(997)
744 var float32strings [4096]string
745 for i := range float32strings {
746 n = (99991*n + 42) % (0xff << 23)
747 float32strings[i] = FormatFloat(float64(math.Float32frombits(n)), 'g', 20, 32)
748 }
749 b.ResetTimer()
750 for i := 0; i < b.N; i++ {
751 ParseFloat(float32strings[i%4096], 32)
752 }
753 }
754
View as plain text