encoder: Lossless double encoding, reject NaN and Inf

Doubles were formatted with %f, which pads to six decimal places and silently
loses everything beyond it: 0.1234567890123 went out as 0.123457, and both
1e-10 and 1e-300 became 0.000000. Values now use the shortest decimal
representation that round-trips exactly and satisfies the specification.

The specification allows only decimal point notation - "a plus or a minus,
followed by any number of numeric characters, followed by a period and any
number of numeric characters" - so exponent notation is avoided and a period
is always present, including for whole numbers.

NaN and infinities have no representation per the same section of the
specification, and previously went on the wire as NaN/+Inf/-Inf, which no
receiver can read as a number. They are now rejected with an error.

Author: alexejk

encode.go

@@ -4,8 +4,10 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"math"
 	"reflect"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -138,7 +140,9 @@ func (e *StdEncoder) encodeValue(x *xmlWriter, value interface{}) error {
 		e.encodeInteger(x, value.(int))
 
 	case reflect.Float64:
-		e.encodeDouble(x, value.(float64))
+		if err := e.encodeDouble(x, value.(float64)); err != nil {
+			return fmt.Errorf("cannot encode double value: %w", err)
+		}
 
 	case reflect.String:
 		e.encodeString(x, value.(string))
@@ -186,8 +190,33 @@ func (e *StdEncoder) encodeInteger(x *xmlWriter, val int) {
 	x.element("int", strconv.Itoa(val))
 }
 
-func (e *StdEncoder) encodeDouble(x *xmlWriter, val float64) {
-	x.element("double", fmt.Sprintf("%f", val))
+func (e *StdEncoder) encodeDouble(x *xmlWriter, val float64) error {
+	// XML-RPC has no representation for these, and emitting them produces a document the
+	// receiver cannot interpret as a number
+	if math.IsNaN(val) {
+		return fmt.Errorf("unsupported value NaN")
+	}
+
+	if math.IsInf(val, 1) {
+		return fmt.Errorf("unsupported value +Inf")
+	}
+
+	if math.IsInf(val, -1) {
+		return fmt.Errorf("unsupported value -Inf")
+	}
+
+	// The specification allows only decimal point notation - no exponent - so 'f' is used
+	// with a precision of -1, giving the fewest digits that still round-trip exactly
+	formatted := strconv.FormatFloat(val, 'f', -1, 64)
+
+	// A whole number formats without a period, which the grammar does not allow
+	if !strings.ContainsRune(formatted, '.') {
+		formatted += ".0"
+	}
+
+	x.element("double", formatted)
+
+	return nil
 }
 
 func (e *StdEncoder) encodeBoolean(x *xmlWriter, val bool) {

encode_test.go

@@ -4,6 +4,8 @@ import (
 	"encoding/xml"
 	"errors"
 	"fmt"
+	"math"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -145,7 +147,7 @@ func TestStdEncoder_Encode(t *testing.T) {
 				Int:    123,
 				Double: float64(12345),
 			},
-			paramValidator: exactParamsValidator(`<param><value><int>123</int></value></param><param><value><double>12345.000000</double></value></param>`),
+			paramValidator: exactParamsValidator(`<param><value><int>123</int></value></param><param><value><double>12345.0</double></value></param>`),
 		},
 		{
 			name: "String arg - simple",
@@ -536,7 +538,7 @@ func Test_encodeMap(t *testing.T) {
 				"<member><name>string</name><value><string>value</string></value></member>",
 				"<member><name>int</name><value><int>42</int></value></member>",
 				"<member><name>bool</name><value><boolean>1</boolean></value></member>",
-				"<member><name>float</name><value><double>3.140000</double></value></member>",
+				"<member><name>float</name><value><double>3.14</double></value></member>",
 			},
 			err: nil,
 		},
@@ -660,6 +662,73 @@ func Test_encodeTime_writerErrors(t *testing.T) {
 	}
 }
 
+func Test_encodeDouble(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  float64
+		expect string
+		errMsg string
+	}{
+		{name: "zero", input: 0, expect: "<double>0.0</double>"},
+		{name: "negative zero", input: math.Copysign(0, -1), expect: "<double>-0.0</double>"},
+		{name: "integral", input: 12345, expect: "<double>12345.0</double>"},
+		{name: "negative", input: -12.214, expect: "<double>-12.214</double>"},
+		{name: "no padding to six decimals", input: 3.14, expect: "<double>3.14</double>"},
+		// %f used to truncate all of these to six decimal places
+		{name: "full float64 precision", input: 3.14159265358979, expect: "<double>3.14159265358979</double>"},
+		{name: "many significant digits", input: 0.1234567890123, expect: "<double>0.1234567890123</double>"},
+		{name: "small magnitude", input: 1e-10, expect: "<double>0.0000000001</double>"},
+		{name: "large magnitude", input: 1e20, expect: "<double>100000000000000000000.0</double>"},
+		{name: "no exponent notation", input: 1e21, expect: "<double>1000000000000000000000.0</double>"},
+		{name: "NaN is rejected", input: math.NaN(), errMsg: "unsupported value NaN"},
+		{name: "positive infinity is rejected", input: math.Inf(1), errMsg: "unsupported value +Inf"},
+		{name: "negative infinity is rejected", input: math.Inf(-1), errMsg: "unsupported value -Inf"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := new(strings.Builder)
+			x := newXMLWriter(buf)
+
+			err := (&StdEncoder{}).encodeDouble(x, tt.input)
+			if tt.errMsg != "" {
+				require.EqualError(t, err, tt.errMsg)
+
+				return
+			}
+
+			require.NoError(t, err)
+			require.NoError(t, x.err)
+			require.Equal(t, tt.expect, buf.String())
+		})
+	}
+}
+
+func Test_encodeDouble_roundTrips(t *testing.T) {
+	// Every emitted value must parse back to the exact same float64
+	values := []float64{
+		0, 1, -1, 0.5, 3.14159265358979, 0.1234567890123, 1e-10, 1e20, 1e21,
+		math.SmallestNonzeroFloat64, math.MaxFloat64, -math.MaxFloat64,
+	}
+
+	for _, want := range values {
+		t.Run(strconv.FormatFloat(want, 'g', -1, 64), func(t *testing.T) {
+			buf := new(strings.Builder)
+			x := newXMLWriter(buf)
+			require.NoError(t, (&StdEncoder{}).encodeDouble(x, want))
+
+			wire := strings.TrimSuffix(strings.TrimPrefix(buf.String(), "<double>"), "</double>")
+			got, err := strconv.ParseFloat(wire, 64)
+			require.NoError(t, err)
+			require.Equal(t, want, got, "wire value %q must round-trip", wire)
+
+			// The specification permits only decimal point notation
+			require.Contains(t, wire, ".", "wire value %q must carry a decimal point", wire)
+			require.NotContains(t, wire, "e", "wire value %q must not use exponent notation", wire)
+		})
+	}
+}
+
 func Test_Encode_escapesCallerSuppliedNames(t *testing.T) {
 	tests := []struct {
 		name       string