libgo/go/strconv/ftoa_test.go

   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         "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 } // keep compiler in the dark
  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         {20, 'g', -1, "20"},
  34         {1234567.8, 'g', -1, "1.2345678e+06"},
  35         {200000, 'g', -1, "200000"},
  36         {2000000, 'g', -1, "2e+06"},
  37
  38         // g conversion and zero suppression
  39         {400, 'g', 2, "4e+02"},
  40         {40, 'g', 2, "40"},
  41         {4, 'g', 2, "4"},
  42         {.4, 'g', 2, "0.4"},
  43         {.04, 'g', 2, "0.04"},
  44         {.004, 'g', 2, "0.004"},
  45         {.0004, 'g', 2, "0.0004"},
  46         {.00004, 'g', 2, "4e-05"},
  47         {.000004, 'g', 2, "4e-06"},
  48
  49         {0, 'e', 5, "0.00000e+00"},
  50         {0, 'f', 5, "0.00000"},
  51         {0, 'g', 5, "0"},
  52         {0, 'g', -1, "0"},
  53
  54         {-1, 'e', 5, "-1.00000e+00"},
  55         {-1, 'f', 5, "-1.00000"},
  56         {-1, 'g', 5, "-1"},
  57         {-1, 'g', -1, "-1"},
  58
  59         {12, 'e', 5, "1.20000e+01"},
  60         {12, 'f', 5, "12.00000"},
  61         {12, 'g', 5, "12"},
  62         {12, 'g', -1, "12"},
  63
  64         {123456700, 'e', 5, "1.23457e+08"},
  65         {123456700, 'f', 5, "123456700.00000"},
  66         {123456700, 'g', 5, "1.2346e+08"},
  67         {123456700, 'g', -1, "1.234567e+08"},
  68
  69         {1.2345e6, 'e', 5, "1.23450e+06"},
  70         {1.2345e6, 'f', 5, "1234500.00000"},
  71         {1.2345e6, 'g', 5, "1.2345e+06"},
  72
  73         {1e23, 'e', 17, "9.99999999999999916e+22"},
  74         {1e23, 'f', 17, "99999999999999991611392.00000000000000000"},
  75         {1e23, 'g', 17, "9.9999999999999992e+22"},
  76
  77         {1e23, 'e', -1, "1e+23"},
  78         {1e23, 'f', -1, "100000000000000000000000"},
  79         {1e23, 'g', -1, "1e+23"},
  80
  81         {below1e23, 'e', 17, "9.99999999999999748e+22"},
  82         {below1e23, 'f', 17, "99999999999999974834176.00000000000000000"},
  83         {below1e23, 'g', 17, "9.9999999999999975e+22"},
  84
  85         {below1e23, 'e', -1, "9.999999999999997e+22"},
  86         {below1e23, 'f', -1, "99999999999999970000000"},
  87         {below1e23, 'g', -1, "9.999999999999997e+22"},
  88
  89         {above1e23, 'e', 17, "1.00000000000000008e+23"},
  90         {above1e23, 'f', 17, "100000000000000008388608.00000000000000000"},
  91         {above1e23, 'g', 17, "1.0000000000000001e+23"},
  92
  93         {above1e23, 'e', -1, "1.0000000000000001e+23"},
  94         {above1e23, 'f', -1, "100000000000000010000000"},
  95         {above1e23, 'g', -1, "1.0000000000000001e+23"},
  96
  97         {fdiv(5e-304, 1e20), 'g', -1, "5e-324"},
  98         {fdiv(-5e-304, 1e20), 'g', -1, "-5e-324"},
  99
 100         {32, 'g', -1, "32"},
 101         {32, 'g', 0, "3e+01"},
 102
 103         {100, 'x', -1, "%x"},
 104
 105         {math.NaN(), 'g', -1, "NaN"},
 106         {-math.NaN(), 'g', -1, "NaN"},
 107         {math.Inf(0), 'g', -1, "+Inf"},
 108         {math.Inf(-1), 'g', -1, "-Inf"},
 109         {-math.Inf(0), 'g', -1, "-Inf"},
 110
 111         {-1, 'b', -1, "-4503599627370496p-52"},
 112
 113         // fixed bugs
 114         {0.9, 'f', 1, "0.9"},
 115         {0.09, 'f', 1, "0.1"},
 116         {0.0999, 'f', 1, "0.1"},
 117         {0.05, 'f', 1, "0.1"},
 118         {0.05, 'f', 0, "0"},
 119         {0.5, 'f', 1, "0.5"},
 120         {0.5, 'f', 0, "0"},
 121         {1.5, 'f', 0, "2"},
 122
 123         // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
 124         {2.2250738585072012e-308, 'g', -1, "2.2250738585072014e-308"},
 125         // http://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
 126         {2.2250738585072011e-308, 'g', -1, "2.225073858507201e-308"},
 127
 128         // Issue 2625.
 129         {383260575764816448, 'f', 0, "383260575764816448"},
 130         {383260575764816448, 'g', -1, "3.8326057576481645e+17"},
 131 }
 132
 133 func TestFtoa(t *testing.T) {
 134         for i := 0; i < len(ftoatests); i++ {
 135                 test := &ftoatests[i]
 136                 s := FormatFloat(test.f, test.fmt, test.prec, 64)
 137                 if s != test.s {
 138                         t.Error("testN=64", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
 139                 }
 140                 x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 64)
 141                 if string(x) != "abc"+test.s {
 142                         t.Error("AppendFloat testN=64", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
 143                 }
 144                 if float64(float32(test.f)) == test.f && test.fmt != 'b' {
 145                         s := FormatFloat(test.f, test.fmt, test.prec, 32)
 146                         if s != test.s {
 147                                 t.Error("testN=32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
 148                         }
 149                         x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 32)
 150                         if string(x) != "abc"+test.s {
 151                                 t.Error("AppendFloat testN=32", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
 152                         }
 153                 }
 154         }
 155 }
 156
 157 func TestFtoaRandom(t *testing.T) {
 158         N := int(1e4)
 159         if testing.Short() {
 160                 N = 100
 161         }
 162         t.Logf("testing %d random numbers with fast and slow FormatFloat", N)
 163         for i := 0; i < N; i++ {
 164                 bits := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
 165                 x := math.Float64frombits(bits)
 166
 167                 shortFast := FormatFloat(x, 'g', -1, 64)
 168                 SetOptimize(false)
 169                 shortSlow := FormatFloat(x, 'g', -1, 64)
 170                 SetOptimize(true)
 171                 if shortSlow != shortFast {
 172                         t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
 173                 }
 174
 175                 prec := rand.Intn(12) + 5
 176                 shortFast = FormatFloat(x, 'e', prec, 64)
 177                 SetOptimize(false)
 178                 shortSlow = FormatFloat(x, 'e', prec, 64)
 179                 SetOptimize(true)
 180                 if shortSlow != shortFast {
 181                         t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
 182                 }
 183         }
 184 }
 185
 186 func BenchmarkFormatFloatDecimal(b *testing.B) {
 187         for i := 0; i < b.N; i++ {
 188                 FormatFloat(33909, 'g', -1, 64)
 189         }
 190 }
 191
 192 func BenchmarkFormatFloat(b *testing.B) {
 193         for i := 0; i < b.N; i++ {
 194                 FormatFloat(339.7784, 'g', -1, 64)
 195         }
 196 }
 197
 198 func BenchmarkFormatFloatExp(b *testing.B) {
 199         for i := 0; i < b.N; i++ {
 200                 FormatFloat(-5.09e75, 'g', -1, 64)
 201         }
 202 }
 203
 204 func BenchmarkFormatFloatNegExp(b *testing.B) {
 205         for i := 0; i < b.N; i++ {
 206                 FormatFloat(-5.11e-95, 'g', -1, 64)
 207         }
 208 }
 209
 210 func BenchmarkFormatFloatBig(b *testing.B) {
 211         for i := 0; i < b.N; i++ {
 212                 FormatFloat(123456789123456789123456789, 'g', -1, 64)
 213         }
 214 }
 215
 216 func benchmarkAppendFloat(b *testing.B, f float64, fmt byte, prec, bitSize int) {
 217         dst := make([]byte, 30)
 218         for i := 0; i < b.N; i++ {
 219                 AppendFloat(dst[:0], f, fmt, prec, bitSize)
 220         }
 221 }
 222
 223 func BenchmarkAppendFloatDecimal(b *testing.B) { benchmarkAppendFloat(b, 33909, 'g', -1, 64) }
 224 func BenchmarkAppendFloat(b *testing.B)        { benchmarkAppendFloat(b, 339.7784, 'g', -1, 64) }
 225 func BenchmarkAppendFloatExp(b *testing.B)     { benchmarkAppendFloat(b, -5.09e75, 'g', -1, 64) }
 226 func BenchmarkAppendFloatNegExp(b *testing.B)  { benchmarkAppendFloat(b, -5.11e-95, 'g', -1, 64) }
 227 func BenchmarkAppendFloatBig(b *testing.B) {
 228         benchmarkAppendFloat(b, 123456789123456789123456789, 'g', -1, 64)
 229 }
 230
 231 func BenchmarkAppendFloat32Integer(b *testing.B)       { benchmarkAppendFloat(b, 33909, 'g', -1, 32) }
 232 func BenchmarkAppendFloat32ExactFraction(b *testing.B) { benchmarkAppendFloat(b, 3.375, 'g', -1, 32) }
 233 func BenchmarkAppendFloat32Point(b *testing.B)         { benchmarkAppendFloat(b, 339.7784, 'g', -1, 32) }
 234 func BenchmarkAppendFloat32Exp(b *testing.B)           { benchmarkAppendFloat(b, -5.09e25, 'g', -1, 32) }
 235 func BenchmarkAppendFloat32NegExp(b *testing.B)        { benchmarkAppendFloat(b, -5.11e-25, 'g', -1, 32) }
 236
 237 func BenchmarkAppendFloat64Fixed1(b *testing.B) { benchmarkAppendFloat(b, 123456, 'e', 3, 64) }
 238 func BenchmarkAppendFloat64Fixed2(b *testing.B) { benchmarkAppendFloat(b, 123.456, 'e', 3, 64) }
 239 func BenchmarkAppendFloat64Fixed3(b *testing.B) { benchmarkAppendFloat(b, 1.23456e+78, 'e', 3, 64) }
 240 func BenchmarkAppendFloat64Fixed4(b *testing.B) { benchmarkAppendFloat(b, 1.23456e-78, 'e', 3, 64) }