-int-as-float also skips int64 tests

Also add some tests for max float64 values.

Fixes #154

cmd/toml-test/main.go

@@ -91,6 +91,9 @@ func parseFlags() (tomltest.Runner, []string, int, string, bool, bool) {
 		IntAsFloat: intAsFloat.Bool(),
 		Errors:     errs,
 	}
+	if intAsFloat.Bool() {
+		r.SkipTests = append(r.SkipTests, "valid/integer/long")
+	}
 
 	if len(f.Args) == 0 && !listFiles.Bool() {
 		zli.Fatalf("no parser command")

cmd/toml-test/usage.go

@@ -92,7 +92,7 @@ Flags:
 
                   Quote glob characters so they won't be picked up by the
                   shell.
-                  Supported paterns: https://godocs.io/path/filepath#Match
+                  Supported patterns: https://godocs.io/path/filepath#Match
 
     -skip         Tests to skip, this uses the same syntax as the -run flag.
 
@@ -103,7 +103,10 @@ Flags:
                   useful to get a list of "known failures" for CI integrations
                   and such.
 
-    -int-as-float Treat all integers as floats, rather than integers.
+    -int-as-float Treat all integers as floats, rather than integers. This also
+                  skips the int64 test as that's outside of the safe float
+                  range (it still tests the boundary of safe float64 natural
+                  numbers).
 
     -errors       TOML or JSON file with expected errors for invalid test
                   files; an invalid test is considered to be "failed" if the

tests/valid/float/max-int.json

@@ -0,0 +1,10 @@
+{
+  "max_float": {
+    "type": "float",
+    "value": "9007199254740991"
+  },
+  "min_float": {
+    "type": "float",
+    "value": "-9007199254740991"
+  }
+}

tests/valid/float/max-int.toml

@@ -0,0 +1,3 @@
+# Maximum and minimum safe natural numbers.
+max_float =  9_007_199_254_740_991.0
+min_float = -9_007_199_254_740_991.0

tests/valid/integer/float64-max.json

@@ -0,0 +1,10 @@
+{
+  "max_int": {
+    "type": "integer",
+    "value": "9007199254740991"
+  },
+  "min_int": {
+    "type": "integer",
+    "value": "-9007199254740991"
+  }
+}

tests/valid/integer/float64-max.toml

@@ -0,0 +1,4 @@
+# Maximum and minimum safe float64 natural numbers. Mainly here for
+# -int-as-float.
+max_int =  9_007_199_254_740_991
+min_int = -9_007_199_254_740_991

toml.go

@@ -5,6 +5,7 @@ import (
 	"math"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -21,16 +22,16 @@ func (r Test) CompareTOML(want, have any) Test {
 	if isTomlValue(want) {
 		if !isTomlValue(have) {
 			return r.fail("Type for key %q differs:\n"+
-				"  Expected:     %v (%s)\n"+
-				"  Your encoder: %v (%s)",
-				r.Key, want, fmtType(want), have, fmtType(have))
+				"  Expected:     %s (%s)\n"+
+				"  Your encoder: %s (%s)",
+				r.Key, fmtVal(want), fmtType(want), fmtVal(have), fmtType(have))
 		}
 
 		if !deepEqual(want, have) {
 			return r.fail("Values for key %q differ:\n"+
-				"  Expected:     %v (%s)\n"+
-				"  Your encoder: %v (%s)",
-				r.Key, want, fmtType(want), have, fmtType(have))
+				"  Expected:     %s (%s)\n"+
+				"  Your encoder: %s (%s)",
+				r.Key, fmtVal(want), fmtType(want), fmtVal(have), fmtType(have))
 		}
 		return r
 	}
@@ -156,6 +157,15 @@ func isTomlValue(v any) bool {
 func fmtType(t any) string  { return strings.ReplaceAll(fmt.Sprintf("%T", t), "interface {}", "any") }
 func fmtHashV(t any) string { return strings.ReplaceAll(fmt.Sprintf("%#v", t), "interface {}", "any") }
 
+func fmtVal(v any) string {
+	switch vv := v.(type) {
+	case float64:
+		return strconv.FormatFloat(vv, 'f', -1, 64)
+	default:
+		return fmt.Sprintf("%v", vv)
+	}
+}
+
 func mapKeys[M ~map[string]V, V any](m M) []string {
 	keys := make([]string, 0, len(m))
 	for k := range m {