math/big: don't return io.EOF on successful call of ParseFloat

Fixes $9938.

Change-Id: Ie8680a875225748abd660fb26b4c25546e7b92d3
Reviewed-on: https://go-review.googlesource.com/5620
Reviewed-by: Alan Donovan <adonovan@google.com>

diff --git a/src/math/big/floatconv.go b/src/math/big/floatconv.go
index a857fa651378cf718ae312c6186d96fb3641af22..e41d447db0ead3a0514ca6e01ef9c513a98ecce2 100644 (file)
--- a/src/math/big/floatconv.go
+++ b/src/math/big/floatconv.go
@@ -126,11 +126,9 @@ func (z *Float) Scan(r io.ByteScanner, base int) (f *Float, b int, err error) {
 }
 
 // Parse is like z.Scan(r, base), but instead of reading from an
-// io.ByteScanner, it parses the string s. An error is returned if the
-// string contains invalid or trailing characters not belonging to the
-// number.
-//
-// TODO(gri) define possible errors more precisely
+// io.ByteScanner, it parses the string s. An error is returned if
+// the string contains invalid or trailing bytes not belonging to
+// the number.
 func (z *Float) Parse(s string, base int) (f *Float, b int, err error) {
        r := strings.NewReader(s)
 
@@ -139,11 +137,10 @@ func (z *Float) Parse(s string, base int) (f *Float, b int, err error) {
        }
 
        // entire string must have been consumed
-       var ch byte
-       if ch, err = r.ReadByte(); err != io.EOF {
-               if err == nil {
-                       err = fmt.Errorf("expected end of string, found %q", ch)
-               }
+       if ch, err2 := r.ReadByte(); err2 == nil {
+               err = fmt.Errorf("expected end of string, found %q", ch)
+       } else if err2 != io.EOF {
+               err = err2
        }
 
        return

diff --git a/src/math/big/floatconv_test.go b/src/math/big/floatconv_test.go
index 11e5df448a6be97f008f96d2a663d6538383c6c4..a22a1f7ddf0830b8ab2b447d1a4253d2e22ae8af 100644 (file)
--- a/src/math/big/floatconv_test.go
+++ b/src/math/big/floatconv_test.go
@@ -5,7 +5,6 @@
 package big
 
 import (
-       "io"
        "math"
        "strconv"
        "testing"
@@ -59,7 +58,7 @@ func TestFloatSetFloat64String(t *testing.T) {
                {"+10000000000000000000000000000000000000000e-0", 1e40},
        } {
                var x Float
-               x.prec = 53 // TODO(gri) find better solution
+               x.SetPrec(53)
                _, ok := x.SetString(test.s)
                if !ok {
                        t.Errorf("%s: parse error", test.s)
@@ -313,8 +312,7 @@ func TestFloatFormat(t *testing.T) {
                {"3.14", 'x', 0, "%x"},
        } {
                f, _, err := ParseFloat(test.x, 0, 1000, ToNearestEven)
-               // TODO(gri) should we return io.EOF at the end?
-               if err != nil && err != io.EOF {
+               if err != nil {
                        t.Errorf("%v: %s", test, err)
                        continue
                }