From 99c5690ca9e0b7a0b747f5fee0d8ef736c67b14e Mon Sep 17 00:00:00 2001
From: Martin Tournoij <martin@arp242.net>
Date: Sat, 23 Sep 2023 19:17:12 +0100
Subject: [PATCH] Update toml-test

Because toml-test now requires Go 1.18, also update the version here to
Go 1.18. Latest Debian has Go 1.19, and Go 1.18 is EOL now. People can
still continue to use older versions for older Go versions.
---
 .github/workflows/test.yml                    |  2 +-
 go.mod                                        |  2 +-
 internal/toml-test/README.md                  | 83 ++++++++++++-------
 internal/toml-test/json.go                    | 44 +++++-----
 internal/toml-test/runner.go                  | 14 ++--
 .../tests/invalid/float/exp-trailing-us.toml  |  2 +-
 .../toml-test/tests/invalid/float/float.multi |  5 +-
 .../invalid/float/trailing-us-exp-1.toml      |  1 +
 .../invalid/float/trailing-us-exp-2.toml      |  1 +
 .../tests/invalid/float/trailing-us-exp.toml  |  4 -
 .../valid/array/string-with-comma-2.json      | 12 +++
 .../valid/array/string-with-comma-2.toml      |  5 ++
 .../tests/valid/datetime/milliseconds.json    |  8 +-
 .../tests/valid/datetime/milliseconds.toml    |  4 +-
 .../toml-test/tests/valid/key/unicode.json    | 26 ++++++
 .../toml-test/tests/valid/key/unicode.toml    |  9 ++
 .../tests/valid/string/multiline.json         |  4 -
 .../tests/valid/string/multiline.toml         | 10 ---
 internal/toml-test/toml.go                    | 51 +++++++-----
 internal/toml-test/version.go                 |  2 +-
 toml_test.go                                  |  2 +-
 21 files changed, 181 insertions(+), 110 deletions(-)
 create mode 100644 internal/toml-test/tests/invalid/float/trailing-us-exp-1.toml
 create mode 100644 internal/toml-test/tests/invalid/float/trailing-us-exp-2.toml
 delete mode 100644 internal/toml-test/tests/invalid/float/trailing-us-exp.toml
 create mode 100644 internal/toml-test/tests/valid/array/string-with-comma-2.json
 create mode 100644 internal/toml-test/tests/valid/array/string-with-comma-2.toml

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()