math/big: add "smoke test" for big.Float division

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

diff --git a/src/math/big/float_test.go b/src/math/big/float_test.go
index ec67a6d6065640abfbd89413e99d36ac00a408ed..e37d2ed365af71738cc7ebcd3c336c742e66ef73 100644 (file)
--- a/src/math/big/float_test.go
+++ b/src/math/big/float_test.go
@@ -521,6 +521,47 @@ func TestFloatQuo(t *testing.T) {
        }
 }
 
+// TestFloatQuoSmoke tests all divisions x/y for values x, y in the range [-n, +n];
+// it serves as a smoke test for basic correctness of division.
+func TestFloatQuoSmoke(t *testing.T) {
+       n := 1000
+       if testing.Short() {
+               n = 10
+       }
+
+       const dprec = 3         // max. precision variation
+       const prec = 10 + dprec // enough bits to hold n precisely
+       for x := -n; x <= n; x++ {
+               for y := -n; y < n; y++ {
+                       if y == 0 {
+                               continue
+                       }
+
+                       a := float64(x)
+                       b := float64(y)
+                       c := a / b
+
+                       // vary operand precision (only ok as long as a, b can be represented correctly)
+                       for ad := -dprec; ad <= dprec; ad++ {
+                               for bd := -dprec; bd <= dprec; bd++ {
+                                       A := NewFloat(a, uint(prec+ad), 0)
+                                       B := NewFloat(b, uint(prec+bd), 0)
+                                       C := NewFloat(0, 53, 0).Quo(A, B) // C has float64 mantissa width
+
+                                       cc, acc := C.Float64()
+                                       if cc != c {
+                                               t.Errorf("%g/%g = %s; want %.5g\n", a, b, C.Format('g', 5), c)
+                                               continue
+                                       }
+                                       if acc != Exact {
+                                               t.Errorf("%g/%g got %s result; want exact result", a, b, acc)
+                                       }
+                               }
+                       }
+               }
+       }
+}
+
 // normBits returns the normalized bits for x: It
 // removes multiple equal entries by treating them
 // as an addition (e.g., []int{5, 5} => []int{6}),