From b84736e9b6401df0c6eeab9950bef09458a6aefd Mon Sep 17 00:00:00 2001
From: Christopher Speller <crspeller@gmail.com>
Date: Fri, 29 Sep 2017 12:46:30 -0700
Subject: Updating server dependancies. (#7538)

---
 .../x/text/internal/number/decimal_test.go         | 63 ++++++++++++++--------
 1 file changed, 42 insertions(+), 21 deletions(-)

(limited to 'vendor/golang.org/x/text/internal/number/decimal_test.go')

diff --git a/vendor/golang.org/x/text/internal/number/decimal_test.go b/vendor/golang.org/x/text/internal/number/decimal_test.go
index 5c8170049..04aa8b2c8 100644
--- a/vendor/golang.org/x/text/internal/number/decimal_test.go
+++ b/vendor/golang.org/x/text/internal/number/decimal_test.go
@@ -22,6 +22,15 @@ func mkfloat(num string) float64 {
 // digits are shifted. Numbers may have an additional exponent or be the special
 // value NaN, Inf, or -Inf.
 func mkdec(num string) (d Decimal) {
+	var r RoundingContext
+	d.Convert(r, dec(num))
+	return
+}
+
+type dec string
+
+func (s dec) Convert(d *Decimal, _ RoundingContext) {
+	num := string(s)
 	if num[0] == '-' {
 		d.Neg = true
 		num = num[1:]
@@ -52,7 +61,7 @@ func mkdec(num string) (d Decimal) {
 	for i := range d.Digits {
 		d.Digits[i] -= '0'
 	}
-	return d.normalize()
+	*d = d.normalize()
 }
 
 func byteNum(s string) []byte {
@@ -77,11 +86,11 @@ func TestDecimalString(t *testing.T) {
 		want string
 	}{
 		{want: "0"},
-		{Decimal{Digits: nil, Exp: 1000}, "0"}, // exponent of 1000 is ignored
-		{Decimal{Digits: byteNum("12345"), Exp: 0}, "0.12345"},
-		{Decimal{Digits: byteNum("12345"), Exp: -3}, "0.00012345"},
-		{Decimal{Digits: byteNum("12345"), Exp: +3}, "123.45"},
-		{Decimal{Digits: byteNum("12345"), Exp: +10}, "1234500000"},
+		{Decimal{digits: digits{Digits: nil, Exp: 1000}}, "0"}, // exponent of 1000 is ignored
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: 0}}, "0.12345"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: -3}}, "0.00012345"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: +3}}, "123.45"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: +10}}, "1234500000"},
 	} {
 		if got := test.x.String(); got != test.want {
 			t.Errorf("%v == %q; want %q", test.x, got, test.want)
@@ -232,16 +241,28 @@ func TestRounding(t *testing.T) {
 }
 
 func TestConvert(t *testing.T) {
-	scale2 := &RoundingContext{Scale: 2}
-	scale2away := &RoundingContext{Scale: 2, Mode: AwayFromZero}
-	inc0_05 := &RoundingContext{Increment: 5, Scale: 2}
-	inc50 := &RoundingContext{Increment: 50}
-	prec3 := &RoundingContext{Precision: 3}
+	scale2 := RoundingContext{}
+	scale2.SetScale(2)
+	scale2away := RoundingContext{Mode: AwayFromZero}
+	scale2away.SetScale(2)
+	inc0_05 := RoundingContext{Increment: 5, IncrementScale: 2}
+	inc0_05.SetScale(2)
+	inc50 := RoundingContext{Increment: 50}
+	prec3 := RoundingContext{}
+	prec3.SetPrecision(3)
+	roundShift := RoundingContext{DigitShift: 2, MaxFractionDigits: 2}
 	testCases := []struct {
 		x   interface{}
-		rc  *RoundingContext
+		rc  RoundingContext
 		out string
 	}{
+		// TODO: uncommented tests can be restored when convert does its own
+		// rounding.
+		// {-0.001, scale2, "-0.00"}, // not normalized
+		// {0.1234, prec3, "0.123"},
+		// {1234.0, prec3, "1230"},
+		// {1.2345e10, prec3, "12300000000"},
+
 		{int8(-34), scale2, "-34"},
 		{int16(-234), scale2, "-234"},
 		{int32(-234), scale2, "-234"},
@@ -252,25 +273,25 @@ func TestConvert(t *testing.T) {
 		{uint32(234), scale2, "234"},
 		{uint64(234), scale2, "234"},
 		{uint(234), scale2, "234"},
-		{-0.001, scale2, "-0"},
-		{-1e9, scale2, "-1000000000.00"},
-		{0.234, scale2, "0.23"},
-		{0.234, scale2away, "0.24"},
-		{0.1234, prec3, "0.123"},
-		{1234.0, prec3, "1230"},
-		{1.2345e10, prec3, "12300000000"},
+		{-1e9, scale2, "-1000000000"},
+		{0.234, scale2away, "0.234"}, // rounding postponed as not ToNearestEven
 
 		{0.03, inc0_05, "0.05"},
 		{0.025, inc0_05, "0"},
-		{0.075, inc0_05, "0.10"},
+		{0.075, inc0_05, "0.1"},
 		{325, inc50, "300"},
 		{375, inc50, "400"},
 
+		// Here the scale is 2, but the digits get shifted left. As we use
+		// AppendFloat to do the rounding an exta 0 gets added.
+		{0.123, roundShift, "0.123"},
+
 		{converter(3), scale2, "100"},
 
 		{math.Inf(1), inc50, "Inf"},
 		{math.Inf(-1), inc50, "-Inf"},
 		{math.NaN(), inc50, "NaN"},
+		{"clearly not a number", scale2, "NaN"},
 	}
 	for _, tc := range testCases {
 		var d Decimal
@@ -285,7 +306,7 @@ func TestConvert(t *testing.T) {
 
 type converter int
 
-func (c converter) Convert(d *Decimal, r *RoundingContext) {
+func (c converter) Convert(d *Decimal, r RoundingContext) {
 	d.Digits = append(d.Digits, 1, 0, 0)
 	d.Exp = 3
 }
-- 
cgit v1.2.3-1-g7c22