diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 9b95081d..e0695d0c 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -5,7 +5,7 @@
     "test": {
       "strategy": {
         "matrix": {
-          "go-version": ["1.16.x", "1.20.x"],
+          "go-version": ["1.18.x", "1.21.x"],
           "os":         ["ubuntu-latest", "macos-latest", "windows-latest"]
         }
       },
diff --git a/go.mod b/go.mod
index 82989481..57b1d373 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
 module github.com/BurntSushi/toml
 
-go 1.16
+go 1.18
diff --git a/internal/toml-test/README.md b/internal/toml-test/README.md
index 398b1c97..616b73e2 100644
--- a/internal/toml-test/README.md
+++ b/internal/toml-test/README.md
@@ -8,8 +8,7 @@ JSON, described below.
 
 Both encoders and decoders share valid tests, except an encoder accepts JSON and
 outputs TOML rather than the reverse. The TOML representations are read with a
-blessed decoder and is compared. Encoders have their own set of invalid tests in
-the invalid-encoder directory. The JSON given to a TOML encoder is in the same
+blessed decoder and is compared. The JSON given to a TOML encoder is in the same
 format as the JSON that a TOML decoder should output.
 
 Compatible with TOML version [v1.0.0][v1].
@@ -24,16 +23,13 @@ should run in most environments. It's recommended you use a binary, or a tagged
 release if you build from source especially in CI environments. This prevents
 your tests from breaking on changes to tests in this tool.
 
-To compile from source you will need Go 1.16 or newer (older versions will *not*
-work):
+To compile from source you will need Go 1.18 or newer:
 
-    $ git clone https://github.com/BurntSushi/toml-test.git
-    $ cd toml-test
-    $ go build ./cmd/toml-test
+    $ go install github.com/toml-lang/toml-test/cmd/toml-test@latest
 
 This will build a `./toml-test` binary.
 
-[r]: https://github.com/BurntSushi/toml-test/releases
+[r]: https://github.com/toml-lang/toml-test/releases
 
 Usage
 -----
@@ -69,11 +65,11 @@ See `toml-test -help` for detailed usage.
 For your decoder to be compatible with `toml-test` it **must** satisfy the
 expected interface:
 
-- Your decoder **must** accept TOML data on `stdin` until EOF.
+- Your decoder **must** accept TOML data on `stdin`.
 - If the TOML data is invalid, your decoder **must** return with a non-zero
-  exit, code indicating an error.
+  exit code, indicating an error.
 - If the TOML data is valid, your decoder **must** output a JSON encoding of
-  that data on `stdout` and return with a zero exit code indicating success.
+  that data on `stdout` and return with a zero exit code, indicating success.
 
 An example in pseudocode:
 
@@ -94,12 +90,12 @@ Details on the tagged JSON is explained below in "JSON encoding".
 For your encoder to be compatible with `toml-test`, it **must** satisfy the
 expected interface:
 
-- Your encoder **must** accept JSON data on `stdin` until EOF.
+- Your encoder **must** accept JSON data on `stdin`.
 - If the JSON data cannot be converted to a valid TOML representation, your
-  encoder **must** return with a non-zero exit code indicating an error.
+  encoder **must** return with a non-zero exit code, indicating an error.
 - If the JSON data can be converted to a valid TOML representation, your encoder
   **must** output a TOML encoding of that data on `stdout` and return with a
-  zero exit code indicating success.
+  zero exit code, indicating success.
 
 An example in pseudocode:
 
@@ -121,9 +117,9 @@ The following JSON encoding applies equally to both encoders and decoders:
 - TOML tables correspond to JSON objects.
 - TOML table arrays correspond to JSON arrays.
 - TOML values correspond to a special JSON object of the form:
-  `{"type": "{TTYPE}", "value": {TVALUE}}`
+  `{"type": "{TOML_TYPE}", "value": "{TOML_VALUE}"}`
 
-In the above, `TTYPE` may be one of:
+In the above, `TOML_TYPE` may be one of:
 
 - string
 - integer
@@ -134,7 +130,7 @@ In the above, `TTYPE` may be one of:
 - date-local
 - time-local
 
-`TVALUE` is always a JSON string.
+`TOML_VALUE` is always a JSON string.
 
 Empty hashes correspond to empty JSON objects (`{}`) and empty arrays correspond
 to empty JSON arrays (`[]`).
@@ -147,19 +143,19 @@ Examples:
 
     TOML                JSON
 
-    a = 42              {"type": "integer": "value": "42}
+    a = 42              {"type": "integer": "value": "42"}
 
----
+<!-- -->
 
     [tbl]               {"tbl": {
-    a = 42                  "a": {"type": "integer": "value": "42}
+    a = 42                  "a": {"type": "integer": "value": "42"}
                         }}
 
----
+<!-- -->
 
     a = ["a", 2]        {"a": [
-                            {"type": "string", "value": "1"},
-                            {"type: "integer": "value": "2"}
+                            {"type": "string",  "value": "1"},
+                            {"type": "integer": "value": "2"}
                         ]}
 
 Or a more complex example:
@@ -200,14 +196,13 @@ Implementation-defined behaviour
 This only tests behaviour that's should be true for every encoder implementing
 TOML; a few things are left up to implementations, and are not tested here.
 
-- Millisecond precision (4 digits) is required for datetimes and times, and
+- Millisecond precision (3 digits) is required for datetimes and times, and
   further precision is implementation-specific, and any greater precision than
   is supported must be truncated (not rounded).
 
   This tests only millisecond precision, and not any further precision or the
   truncation of it.
 
-
 Assumptions of Truth
 --------------------
 The following are taken as ground truths by `toml-test`:
@@ -216,9 +211,9 @@ The following are taken as ground truths by `toml-test`:
 - All tests classified as `valid` **are** valid.
 - All expected outputs in `valid/test-name.json` are exactly correct.
 - The Go standard library package `encoding/json` decodes JSON correctly.
-- When testing encoders, the TOML decoder at
-  [BurntSushi/toml](https://github.com/BurntSushi/toml) is assumed to be 
-  correct. (Note that this assumption is not made when testing decoders!)
+- When testing encoders the
+  [BurntSushi/toml](https://github.com/BurntSushi/toml) TOML decoder is assumed
+  to be correct. (Note that this assumption is not made when testing decoders!)
 
 Of particular note is that **no TOML decoder** is taken as ground truth when
 testing decoders. This means that most changes to the spec will only require an
@@ -228,10 +223,40 @@ added.) Obviously, this advantage does not apply to testing TOML encoders since
 there must exist a TOML decoder that conforms to the specification in order to
 read the output of a TOML encoder.
 
+Usage without `toml-test` binary
+--------------------------------
+While the `toml-test` tool is a convenient way to run the tests, you can also
+re-implement its behaviour in your own language's test-suite, which may be an
+easier way to run the tests.
+
+Because multiple TOML versions are supported, not all tests are valid for every
+version of TOML; for example the 1.0.0 tests contain a test that trailing commas
+in tables are invalid, but in 1.1.0 this should be considered valid.
+
+In short: you can't "just" copy all .toml and .json files from the tests/
+directory. The [tests/files-toml-1.0.0] and [tests/files-toml-1.1.0] files
+contain a list of files you should run for that TOML version.
+
+You can use those lists to determine which tests to run, or include only those
+tests in your library by copying them with something like:
+
+    <files-toml-1.0.0 while read l; do
+        mkdir -p ~/my-test/"$(dirname "$l")"
+        cp -r "$l" ~/my-test/"$l"
+    done
+
+These files are generated with `toml-test -list-files`:
+
+    % toml-test -list-files -toml=1.0.0
+    % toml-test -list-files -toml=1.1.0
+
+[tests/files-toml-1.0.0]: tests/files-toml-1.0.0
+[tests/files-toml-1.1.0]: tests/files-toml-1.1.0
+
 Adding tests
 ------------
 `toml-test` was designed so that tests can be easily added and removed. As
-mentioned above, tests are split into two groups: invalid and valid tests. 
+mentioned above, tests are split into two groups: invalid and valid tests.
 
 Invalid tests **only check if a decoder rejects invalid TOML data**. Or, in the
 case of testing encoders, invalid tests **only check if an encoder rejects an
diff --git a/internal/toml-test/json.go b/internal/toml-test/json.go
index a5fa2830..65bf9857 100644
--- a/internal/toml-test/json.go
+++ b/internal/toml-test/json.go
@@ -14,21 +14,21 @@ import (
 //
 // reflect.DeepEqual could work here, but it won't tell us how the two
 // structures are different.
-func (r Test) CompareJSON(want, have interface{}) Test {
+func (r Test) CompareJSON(want, have any) Test {
 	switch w := want.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		return r.cmpJSONMaps(w, have)
-	case []interface{}:
+	case []any:
 		return r.cmpJSONArrays(w, have)
 	default:
 		return r.fail(
-			"Key '%s' in expected output should be a map or a list of maps, but it's a %T",
-			r.Key, want)
+			"Key '%s' in expected output should be a map or a list of maps, but it's a %s",
+			r.Key, fmtType(want))
 	}
 }
 
-func (r Test) cmpJSONMaps(want map[string]interface{}, have interface{}) Test {
-	haveMap, ok := have.(map[string]interface{})
+func (r Test) cmpJSONMaps(want map[string]any, have any) Test {
+	haveMap, ok := have.(map[string]any)
 	if !ok {
 		return r.mismatch("table", want, haveMap)
 	}
@@ -73,16 +73,16 @@ func (r Test) cmpJSONMaps(want map[string]interface{}, have interface{}) Test {
 	return r
 }
 
-func (r Test) cmpJSONArrays(want, have interface{}) Test {
-	wantSlice, ok := want.([]interface{})
+func (r Test) cmpJSONArrays(want, have any) Test {
+	wantSlice, ok := want.([]any)
 	if !ok {
-		return r.bug("'value' should be a JSON array when 'type=array', but it is a %T", want)
+		return r.bug("'value' should be a JSON array when 'type=array', but it is a %s", fmtType(want))
 	}
 
-	haveSlice, ok := have.([]interface{})
+	haveSlice, ok := have.([]any)
 	if !ok {
 		return r.fail(
-			"Malformed output from your encoder: 'value' is not a JSON array: %T", have)
+			"Malformed output from your encoder: 'value' is not a JSON array: %s", fmtType(have))
 	}
 
 	if len(wantSlice) != len(haveSlice) {
@@ -99,15 +99,15 @@ func (r Test) cmpJSONArrays(want, have interface{}) Test {
 	return r
 }
 
-func (r Test) cmpJSONValues(want, have map[string]interface{}) Test {
+func (r Test) cmpJSONValues(want, have map[string]any) Test {
 	wantType, ok := want["type"].(string)
 	if !ok {
-		return r.bug("'type' should be a string, but it is a %T", want["type"])
+		return r.bug("'type' should be a string, but it is a %s", fmtType(want["type"]))
 	}
 
 	haveType, ok := have["type"].(string)
 	if !ok {
-		return r.fail("Malformed output from your encoder: 'type' is not a string: %T", have["type"])
+		return r.fail("Malformed output from your encoder: 'type' is not a string: %s", fmtType(have["type"]))
 	}
 
 	if wantType != haveType {
@@ -122,12 +122,12 @@ func (r Test) cmpJSONValues(want, have map[string]interface{}) Test {
 	// Atomic values are always strings
 	wantVal, ok := want["value"].(string)
 	if !ok {
-		return r.bug("'value' %v should be a string, but it is a %[1]T", want["value"])
+		return r.bug("'value' %v should be a string, but it is a %s", want["value"], fmtType(want["value"]))
 	}
 
 	haveVal, ok := have["value"].(string)
 	if !ok {
-		return r.fail("Malformed output from your encoder: %T is not a string", have["value"])
+		return r.fail("Malformed output from your encoder: %s is not a string", fmtType(have["value"]))
 	}
 
 	// Excepting floats and datetimes, other values can be compared as strings.
@@ -227,7 +227,7 @@ func (r Test) kjoin(key string) Test {
 	return r
 }
 
-func isValue(m map[string]interface{}) bool {
+func isValue(m map[string]any) bool {
 	if len(m) != 2 {
 		return false
 	}
@@ -240,14 +240,14 @@ func isValue(m map[string]interface{}) bool {
 	return true
 }
 
-func (r Test) mismatch(wantType string, want, have interface{}) Test {
-	return r.fail("Key '%s' is not an %s but %[4]T:\n"+
+func (r Test) mismatch(wantType string, want, have any) Test {
+	return r.fail("Key '%[1]s' is not an %[2]s but %[5]s:\n"+
 		"  Expected:     %#[3]v\n"+
 		"  Your encoder: %#[4]v",
-		r.Key, wantType, want, have)
+		r.Key, wantType, want, have, fmtType(have))
 }
 
-func (r Test) valMismatch(wantType, haveType string, want, have interface{}) Test {
+func (r Test) valMismatch(wantType, haveType string, want, have any) Test {
 	return r.fail("Key '%s' is not an %s but %s:\n"+
 		"  Expected:     %#[3]v\n"+
 		"  Your encoder: %#[4]v",
diff --git a/internal/toml-test/runner.go b/internal/toml-test/runner.go
index 6bec6f2b..2eb44110 100644
--- a/internal/toml-test/runner.go
+++ b/internal/toml-test/runner.go
@@ -1,4 +1,4 @@
-//go:generate ./gen-multi.py
+//go:generate ./gen.py
 
 package tomltest
 
@@ -335,7 +335,7 @@ func (t Test) runValid(p Parser, fsys fs.FS) Test {
 		if err != nil {
 			return t.bug(err.Error())
 		}
-		var have interface{}
+		var have any
 		if _, err := toml.Decode(t.Output, &have); err != nil {
 			//return t.fail("decode TOML from encoder %q:\n  %s", cmd, err)
 			return t.fail("decode TOML from encoder:\n  %s", err)
@@ -349,7 +349,7 @@ func (t Test) runValid(p Parser, fsys fs.FS) Test {
 		return t.fail(err.Error())
 	}
 
-	var have interface{}
+	var have any
 	if err := json.Unmarshal([]byte(t.Output), &have); err != nil {
 		return t.fail("decode JSON output from parser:\n  %s", err)
 	}
@@ -380,7 +380,7 @@ func (t Test) ReadWant(fsys fs.FS) (path, data string, err error) {
 	return path, string(d), nil
 }
 
-func (t *Test) ReadWantJSON(fsys fs.FS) (v interface{}, err error) {
+func (t *Test) ReadWantJSON(fsys fs.FS) (v any, err error) {
 	var path string
 	path, t.Want, err = t.ReadWant(fsys)
 	if err != nil {
@@ -392,7 +392,7 @@ func (t *Test) ReadWantJSON(fsys fs.FS) (v interface{}, err error) {
 	}
 	return v, nil
 }
-func (t *Test) ReadWantTOML(fsys fs.FS) (v interface{}, err error) {
+func (t *Test) ReadWantTOML(fsys fs.FS) (v any, err error) {
 	var path string
 	path, t.Want, err = t.ReadWant(fsys)
 	if err != nil {
@@ -413,11 +413,11 @@ func (t Test) Type() testType {
 	return TypeValid
 }
 
-func (t Test) fail(format string, v ...interface{}) Test {
+func (t Test) fail(format string, v ...any) Test {
 	t.Failure = fmt.Sprintf(format, v...)
 	return t
 }
-func (t Test) bug(format string, v ...interface{}) Test {
+func (t Test) bug(format string, v ...any) Test {
 	return t.fail("BUG IN TEST CASE: "+format, v...)
 }
 
diff --git a/internal/toml-test/tests/invalid/float/exp-trailing-us.toml b/internal/toml-test/tests/invalid/float/exp-trailing-us.toml
index 07c06413..4d31fcd7 100644
--- a/internal/toml-test/tests/invalid/float/exp-trailing-us.toml
+++ b/internal/toml-test/tests/invalid/float/exp-trailing-us.toml
@@ -1 +1 @@
-exp-trailing-us = 1e_23_
+exp-trailing-us = 1e23_
diff --git a/internal/toml-test/tests/invalid/float/float.multi b/internal/toml-test/tests/invalid/float/float.multi
index 07081954..c686d0a9 100644
--- a/internal/toml-test/tests/invalid/float/float.multi
+++ b/internal/toml-test/tests/invalid/float/float.multi
@@ -25,7 +25,7 @@ exp-double-e-1 = 1ee2
 exp-double-e-2 = 1e2e3
 
 exp-leading-us = 1e_23
-exp-trailing-us = 1e_23_
+exp-trailing-us = 1e23_
 exp-double-us = 1e__23
 
 inf-incomplete-1 = in
@@ -38,3 +38,6 @@ nan-incomplete-3 = -na
 
 nan_underscore = na_n
 inf_underscore = in_f
+
+trailing-us-exp-1 = 1_e2
+trailing-us-exp-2 = 1.2_e2
diff --git a/internal/toml-test/tests/invalid/float/trailing-us-exp-1.toml b/internal/toml-test/tests/invalid/float/trailing-us-exp-1.toml
new file mode 100644
index 00000000..7d4d3cce
--- /dev/null
+++ b/internal/toml-test/tests/invalid/float/trailing-us-exp-1.toml
@@ -0,0 +1 @@
+trailing-us-exp-1 = 1_e2
diff --git a/internal/toml-test/tests/invalid/float/trailing-us-exp-2.toml b/internal/toml-test/tests/invalid/float/trailing-us-exp-2.toml
new file mode 100644
index 00000000..f869025f
--- /dev/null
+++ b/internal/toml-test/tests/invalid/float/trailing-us-exp-2.toml
@@ -0,0 +1 @@
+trailing-us-exp-2 = 1.2_e2
diff --git a/internal/toml-test/tests/invalid/float/trailing-us-exp.toml b/internal/toml-test/tests/invalid/float/trailing-us-exp.toml
deleted file mode 100644
index 7bba9715..00000000
--- a/internal/toml-test/tests/invalid/float/trailing-us-exp.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-# trailing underscore in integer part is not allowed
-trailing-us-exp = 1_e2
-# trailing underscore in float part is not allowed
-trailing-us-exp2 = 1.2_e2
diff --git a/internal/toml-test/tests/valid/array/string-with-comma-2.json b/internal/toml-test/tests/valid/array/string-with-comma-2.json
new file mode 100644
index 00000000..8b591d52
--- /dev/null
+++ b/internal/toml-test/tests/valid/array/string-with-comma-2.json
@@ -0,0 +1,12 @@
+{
+  "title": [
+    {
+      "type": "string",
+      "value": "Client: XXXX,\nJob: XXXX"
+    },
+    {
+      "type": "string",
+      "value": "Code: XXXX"
+    }
+  ]
+}
diff --git a/internal/toml-test/tests/valid/array/string-with-comma-2.toml b/internal/toml-test/tests/valid/array/string-with-comma-2.toml
new file mode 100644
index 00000000..2997c91c
--- /dev/null
+++ b/internal/toml-test/tests/valid/array/string-with-comma-2.toml
@@ -0,0 +1,5 @@
+title = [
+"""Client: XXXX,
+Job: XXXX""",
+"Code: XXXX"
+]
diff --git a/internal/toml-test/tests/valid/datetime/milliseconds.json b/internal/toml-test/tests/valid/datetime/milliseconds.json
index c49e400b..543ae73b 100644
--- a/internal/toml-test/tests/valid/datetime/milliseconds.json
+++ b/internal/toml-test/tests/valid/datetime/milliseconds.json
@@ -1,18 +1,18 @@
 {
   "utc1": {
     "type": "datetime",
-    "value": "1987-07-05T17:45:56.1234Z"
+    "value": "1987-07-05T17:45:56.123Z"
   },
   "utc2": {
     "type": "datetime",
-    "value": "1987-07-05T17:45:56.6000Z"
+    "value": "1987-07-05T17:45:56.600Z"
   },
   "wita1": {
     "type": "datetime",
-    "value": "1987-07-05T17:45:56.1234+08:00"
+    "value": "1987-07-05T17:45:56.123+08:00"
   },
   "wita2": {
     "type": "datetime",
-    "value": "1987-07-05T17:45:56.6000+08:00"
+    "value": "1987-07-05T17:45:56.600+08:00"
   }
 }
diff --git a/internal/toml-test/tests/valid/datetime/milliseconds.toml b/internal/toml-test/tests/valid/datetime/milliseconds.toml
index 24b81f85..b608b577 100644
--- a/internal/toml-test/tests/valid/datetime/milliseconds.toml
+++ b/internal/toml-test/tests/valid/datetime/milliseconds.toml
@@ -1,4 +1,4 @@
-utc1  = 1987-07-05T17:45:56.1234Z
+utc1  = 1987-07-05T17:45:56.123Z
 utc2  = 1987-07-05T17:45:56.6Z
-wita1 = 1987-07-05T17:45:56.1234+08:00
+wita1 = 1987-07-05T17:45:56.123+08:00
 wita2 = 1987-07-05T17:45:56.6+08:00
diff --git a/internal/toml-test/tests/valid/key/unicode.json b/internal/toml-test/tests/valid/key/unicode.json
index 62ae54e8..25258ae9 100644
--- a/internal/toml-test/tests/valid/key/unicode.json
+++ b/internal/toml-test/tests/valid/key/unicode.json
@@ -3,6 +3,24 @@
     "type": "string",
     "value": "zwj"
   },
+  "tiếng-Việt": [
+    {
+      "tiəŋ˧˦": {
+        "viət̚˧˨ʔ": {
+          "type": "string",
+          "value": "north"
+        }
+      }
+    },
+    {
+      "tiəŋ˦˧˥": {
+        "viək̚˨˩ʔ": {
+          "type": "string",
+          "value": "central"
+        }
+      }
+    }
+  ],
   "ÅÅ": {
     "type": "string",
     "value": "U+00C5 U+0041 U+030A"
@@ -11,6 +29,14 @@
     "type": "string",
     "value": "Euro"
   },
+  "中文": {
+    "中文": {
+      "中文": {
+        "type": "string",
+        "value": "Chinese language"
+      }
+    }
+  },
   "😂": {
     "type": "string",
     "value": "rofl"
diff --git a/internal/toml-test/tests/valid/key/unicode.toml b/internal/toml-test/tests/valid/key/unicode.toml
index 0bc75b92..e4137b63 100644
--- a/internal/toml-test/tests/valid/key/unicode.toml
+++ b/internal/toml-test/tests/valid/key/unicode.toml
@@ -4,3 +4,12 @@
 😂 = "rofl"
 a‍b = "zwj"
 ÅÅ = "U+00C5 U+0041 U+030A"
+
+[中文]
+中文 = {中文 = "Chinese language"}
+
+[[tiếng-Việt]]
+tiəŋ˧˦.viət̚˧˨ʔ = "north"
+
+[[tiếng-Việt]]
+tiəŋ˦˧˥.viək̚˨˩ʔ = "central"
diff --git a/internal/toml-test/tests/valid/string/multiline.json b/internal/toml-test/tests/valid/string/multiline.json
index bb0c47b1..66e572bd 100644
--- a/internal/toml-test/tests/valid/string/multiline.json
+++ b/internal/toml-test/tests/valid/string/multiline.json
@@ -50,9 +50,5 @@
   "whitespace-after-bs": {
     "type": "string",
     "value": "The quick brown fox jumps over the lazy dog."
-  },
-  "only-ignore-first": {
-    "type": "string",
-    "value": "Here are two\nlines of text.\nAnd another\n  two.\n"
   }
 }
diff --git a/internal/toml-test/tests/valid/string/multiline.toml b/internal/toml-test/tests/valid/string/multiline.toml
index 4f2fd008..f3b3c2ed 100644
--- a/internal/toml-test/tests/valid/string/multiline.toml
+++ b/internal/toml-test/tests/valid/string/multiline.toml
@@ -35,16 +35,6 @@ whitespace-after-bs = """\
        the lazy dog.\	
        """
 
-only-ignore-first = """
-Here are \
-  two
-lines of text.
-And \
-
-  another
-  two.
-"""
-
 no-space = """a\
     b"""
 
diff --git a/internal/toml-test/toml.go b/internal/toml-test/toml.go
index 346f0a96..e4d049e5 100644
--- a/internal/toml-test/toml.go
+++ b/internal/toml-test/toml.go
@@ -1,8 +1,10 @@
 package tomltest
 
 import (
+	"fmt"
 	"math"
 	"reflect"
+	"strings"
 )
 
 // CompareTOML compares the given arguments.
@@ -13,36 +15,36 @@ import (
 //
 // Reflect.DeepEqual could work here, but it won't tell us how the two
 // structures are different.
-func (r Test) CompareTOML(want, have interface{}) Test {
+func (r Test) CompareTOML(want, have any) Test {
 	if isTomlValue(want) {
 		if !isTomlValue(have) {
 			return r.fail("Type for key '%s' differs:\n"+
-				"  Expected:     %[2]v (%[2]T)\n"+
-				"  Your encoder: %[3]v (%[3]T)",
-				r.Key, want, have)
+				"  Expected:     %v (%s)\n"+
+				"  Your encoder: %v (%s)",
+				r.Key, want, fmtType(want), have, fmtType(have))
 		}
 
 		if !deepEqual(want, have) {
 			return r.fail("Values for key '%s' differ:\n"+
-				"  Expected:     %[2]v (%[2]T)\n"+
-				"  Your encoder: %[3]v (%[3]T)",
-				r.Key, want, have)
+				"  Expected:     %v (%s)\n"+
+				"  Your encoder: %v (%s)",
+				r.Key, want, fmtType(want), have, fmtType(have))
 		}
 		return r
 	}
 
 	switch w := want.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		return r.cmpTOMLMap(w, have)
-	case []interface{}:
+	case []any:
 		return r.cmpTOMLArrays(w, have)
 	default:
-		return r.fail("Unrecognized TOML structure: %T", want)
+		return r.fail("Unrecognized TOML structure: %s", fmtType(want))
 	}
 }
 
-func (r Test) cmpTOMLMap(want map[string]interface{}, have interface{}) Test {
-	haveMap, ok := have.(map[string]interface{})
+func (r Test) cmpTOMLMap(want map[string]any, have any) Test {
+	haveMap, ok := have.(map[string]any)
 	if !ok {
 		return r.mismatch("table", want, haveMap)
 	}
@@ -70,19 +72,19 @@ func (r Test) cmpTOMLMap(want map[string]interface{}, have interface{}) Test {
 	return r
 }
 
-func (r Test) cmpTOMLArrays(want []interface{}, have interface{}) Test {
-	// Slice can be decoded to []interface{} for an array of primitives, or
-	// []map[string]interface{} for an array of tables.
+func (r Test) cmpTOMLArrays(want []any, have any) Test {
+	// Slice can be decoded to []any for an array of primitives, or
+	// []map[string]any for an array of tables.
 	//
-	// TODO: it would be nicer if it could always decode to []interface{}?
-	haveSlice, ok := have.([]interface{})
+	// TODO: it would be nicer if it could always decode to []any?
+	haveSlice, ok := have.([]any)
 	if !ok {
-		tblArray, ok := have.([]map[string]interface{})
+		tblArray, ok := have.([]map[string]any)
 		if !ok {
 			return r.mismatch("array", want, have)
 		}
 
-		haveSlice = make([]interface{}, len(tblArray))
+		haveSlice = make([]any, len(tblArray))
 		for i := range tblArray {
 			haveSlice[i] = tblArray[i]
 		}
@@ -103,7 +105,7 @@ func (r Test) cmpTOMLArrays(want []interface{}, have interface{}) Test {
 }
 
 // reflect.DeepEqual() that deals with NaN != NaN
-func deepEqual(want, have interface{}) bool {
+func deepEqual(want, have any) bool {
 	var wantF, haveF float64
 	switch f := want.(type) {
 	case float32:
@@ -124,10 +126,15 @@ func deepEqual(want, have interface{}) bool {
 	return reflect.DeepEqual(want, have)
 }
 
-func isTomlValue(v interface{}) bool {
+func isTomlValue(v any) bool {
 	switch v.(type) {
-	case map[string]interface{}, []interface{}:
+	case map[string]any, []any:
 		return false
 	}
 	return true
 }
+
+// fmt %T with "interface {}" replaced with "any", which is far more readable.
+func fmtType(t any) string {
+	return strings.ReplaceAll(fmt.Sprintf("%T", t), "interface {}", "any")
+}
diff --git a/internal/toml-test/version.go b/internal/toml-test/version.go
index 87c5fda6..0cf4e3e7 100644
--- a/internal/toml-test/version.go
+++ b/internal/toml-test/version.go
@@ -6,7 +6,7 @@ type versionSpec struct {
 }
 
 var versions = map[string]versionSpec{
-	"next": versionSpec{
+	"1.1.0": versionSpec{
 		exclude: []string{
 			"invalid/datetime/no-secs",          // Times without seconds is no longer invalid.
 			"invalid/string/basic-byte-escapes", // \x is now valid.
diff --git a/toml_test.go b/toml_test.go
index ad1043f1..24794b52 100644
--- a/toml_test.go
+++ b/toml_test.go
@@ -327,7 +327,7 @@ func runTomlTest(t *testing.T, includeNext bool, wantFail ...string) {
 			},
 		}
 		if includeNext {
-			r.Version = "next"
+			r.Version = "1.1.0"
 		}
 
 		tests, err := r.Run()